diff --git a/cellbender/remove_background/checkpoint.py b/cellbender/remove_background/checkpoint.py
index 44ed12e..c01ca67 100644
--- a/cellbender/remove_background/checkpoint.py
+++ b/cellbender/remove_background/checkpoint.py
@@ -17,7 +17,19 @@
 import tempfile
 import shutil
 import traceback
+import weakref
+import copy
+import gc
 
+# Try to use dill as a more robust alternative to pickle
+try:
+    import dill
+    USE_DILL = True
+    logger_dill = logging.getLogger('cellbender')
+    logger_dill.debug('Using dill for enhanced pickling support')
+except ImportError:
+    USE_DILL = False
+    dill = None
 
 logger = logging.getLogger('cellbender')
 
@@ -29,6 +41,136 @@
 USE_CUDA = torch.cuda.is_available()
 
 
+def _clean_weakrefs_recursive(obj, seen=None):
+    """Recursively clean weak references from an object to make it picklable."""
+    if seen is None:
+        seen = set()
+    
+    # Avoid infinite recursion
+    obj_id = id(obj)
+    if obj_id in seen:
+        return obj
+    seen.add(obj_id)
+    
+    # Handle different object types
+    if isinstance(obj, weakref.ReferenceType):
+        # Replace weak reference with None or the referenced object if still alive
+        referenced = obj()
+        return referenced if referenced is not None else None
+    
+    elif hasattr(obj, '__dict__'):
+        # Clean attributes of objects with __dict__
+        cleaned_obj = copy.copy(obj)
+        for key, value in obj.__dict__.items():
+            try:
+                cleaned_value = _clean_weakrefs_recursive(value, seen)
+                setattr(cleaned_obj, key, cleaned_value)
+            except (TypeError, AttributeError):
+                # If we can't clean it, try to remove it
+                try:
+                    delattr(cleaned_obj, key)
+                except AttributeError:
+                    pass
+        return cleaned_obj
+    
+    elif isinstance(obj, dict):
+        return {k: _clean_weakrefs_recursive(v, seen) for k, v in obj.items()}
+    
+    elif isinstance(obj, (list, tuple)):
+        return type(obj)(_clean_weakrefs_recursive(item, seen) for item in obj)
+    
+    else:
+        return obj
+
+
+def _safe_torch_save(obj, filepath, use_dill=False):
+    """Safely save a PyTorch object, handling weak references and other pickle issues."""
+    
+    # First, try the standard torch.save
+    try:
+        torch.save(obj, filepath)
+        return True, "Standard torch.save succeeded"
+    except (TypeError, pickle.PicklingError) as e:
+        if "weakref" not in str(e).lower():
+            # If it's not a weakref issue, re-raise
+            raise e
+    
+    # Try with dill if available
+    if USE_DILL and use_dill:
+        try:
+            torch.save(obj, filepath, pickle_module=dill)
+            return True, "torch.save with dill succeeded"
+        except Exception as e:
+            logger.debug(f"Dill also failed: {e}")
+    
+    # Try cleaning weak references
+    try:
+        logger.info("Attempting to clean weak references from object...")
+        cleaned_obj = _clean_weakrefs_recursive(obj)
+        torch.save(cleaned_obj, filepath)
+        return True, "torch.save succeeded after cleaning weak references"
+    except Exception as e:
+        logger.debug(f"Cleaning weak references failed: {e}")
+    
+    # Try with dill on cleaned object
+    if USE_DILL:
+        try:
+            cleaned_obj = _clean_weakrefs_recursive(obj)
+            torch.save(cleaned_obj, filepath, pickle_module=dill)
+            return True, "torch.save with dill succeeded after cleaning weak references"
+        except Exception as e:
+            logger.debug(f"Dill on cleaned object failed: {e}")
+    
+    return False, "All save attempts failed"
+
+
+def _prepare_model_for_saving(model_obj):
+    """Prepare a model object for saving by cleaning problematic references."""
+    
+    # Try to detach the model from any computational graph
+    try:
+        if hasattr(model_obj, 'eval'):
+            model_obj.eval()
+    except Exception:
+        pass
+    
+    # Force garbage collection to clean up any dangling references
+    gc.collect()
+    
+    return model_obj
+
+
+def _prepare_optimizer_for_saving(scheduler):
+    """Prepare an optimizer/scheduler for saving by extracting essential state."""
+    
+    # Try to get just the essential state information
+    try:
+        if hasattr(scheduler, 'state_dict'):
+            return {
+                'type': type(scheduler).__name__,
+                'state_dict': scheduler.state_dict(),
+                'param_groups': getattr(scheduler, 'param_groups', None)
+            }
+    except Exception:
+        pass
+    
+    # Fallback to extracting optimizer states manually
+    try:
+        if hasattr(scheduler, 'optim_objs'):
+            optim_states = {}
+            for name, optim in scheduler.optim_objs.items():
+                if hasattr(optim, 'state_dict'):
+                    optim_states[name] = {
+                        'type': type(optim).__name__,
+                        'state_dict': optim.state_dict()
+                    }
+            return {'optim_objs': optim_states}
+    except Exception:
+        pass
+    
+    return None
+
+
 def save_random_state(filebase: str) -> List[str]:
     """Write states of various random number generators to files.
 
@@ -112,35 +254,118 @@ def save_checkpoint(filebase: str,
 
             file_list = save_random_state(filebase=filebase)
 
-            torch.save(model_obj, filebase + '_model.torch')
-            torch.save(scheduler, filebase + '_optim.torch')
-            scheduler.save(filebase + '_optim.pyro')  # use PyroOptim method
-            pyro.get_param_store().save(filebase + '_params.pyro')
-            file_list = file_list + [filebase + '_model.torch',
-                                     filebase + '_optim.torch',
-                                     filebase + '_optim.pyro',
-                                     filebase + '_params.pyro']
+            # Prepare and save the model using robust methods
+            logger.debug("Preparing model for saving...")
+            prepared_model = _prepare_model_for_saving(model_obj)
+            
+            success, message = _safe_torch_save(prepared_model, filebase + '_model.torch', use_dill=True)
+            if success:
+                file_list.append(filebase + '_model.torch')
+                logger.info(f"Model saved successfully: {message}")
+            else:
+                logger.warning(f"Could not save full model object: {message}")
+                logger.info('Attempting to save model state_dict instead...')
+                try:
+                    # Save model state dict and class info separately
+                    model_checkpoint = {
+                        'state_dict': model_obj.state_dict(),
+                        'model_class': type(model_obj).__name__,
+                        'model_module': type(model_obj).__module__,
+                    }
+                    # Try to save additional model attributes that might be needed
+                    if hasattr(model_obj, '__dict__'):
+                        model_attributes = {}
+                        for key, value in model_obj.__dict__.items():
+                            try:
+                                # Test if the attribute can be pickled
+                                pickle.dumps(value)
+                                model_attributes[key] = value
+                            except (TypeError, pickle.PicklingError):
+                                # Skip unpicklable attributes
+                                logger.debug(f'Skipping unpicklable model attribute: {key}')
+                                continue
+                        model_checkpoint['attributes'] = model_attributes
+                    
+                    torch.save(model_checkpoint, filebase + '_model.torch')
+                    file_list.append(filebase + '_model.torch')
+                    logger.info('Successfully saved model state_dict and attributes')
+                except Exception as e2:
+                    logger.error(f'Could not save model state_dict either: {e2}')
+                    return False
+            
+            # Prepare and save the scheduler/optimizer using robust methods
+            logger.debug("Preparing optimizer/scheduler for saving...")
+            
+            # Try the robust saving approach first
+            success, message = _safe_torch_save(scheduler, filebase + '_optim.torch', use_dill=True)
+            if success:
+                file_list.append(filebase + '_optim.torch')
+                logger.info(f"Optimizer saved successfully: {message}")
+            else:
+                logger.warning(f"Could not save full scheduler object: {message}")
+                
+                # Try to prepare a clean version of the optimizer
+                prepared_optim = _prepare_optimizer_for_saving(scheduler)
+                if prepared_optim is not None:
+                    try:
+                        torch.save(prepared_optim, filebase + '_optim.torch')
+                        file_list.append(filebase + '_optim.torch')
+                        logger.info('Successfully saved prepared optimizer state')
+                    except Exception as e:
+                        logger.warning(f'Could not save prepared optimizer: {e}')
+                else:
+                    logger.warning('Could not prepare optimizer for saving')
+            
+            # Try to use PyroOptim save method if available
+            try:
+                scheduler.save(filebase + '_optim.pyro')  # use PyroOptim method
+                file_list.append(filebase + '_optim.pyro')
+                logger.debug('Saved using PyroOptim method')
+            except (TypeError, AttributeError, pickle.PicklingError) as e:
+                logger.debug(f'Could not save using PyroOptim method: {e}')
+                # Try alternative: save state dict if available
+                try:
+                    if hasattr(scheduler, 'get_state'):
+                        state = scheduler.get_state()
+                        torch.save(state, filebase + '_optim.pyro')
+                        file_list.append(filebase + '_optim.pyro')
+                        logger.debug('Saved optimizer state via get_state')
+                except Exception as e2:
+                    logger.debug(f'Could not save optimizer state via get_state: {e2}')
+            
+            # Save param store
+            try:
+                pyro.get_param_store().save(filebase + '_params.pyro')
+                file_list.append(filebase + '_params.pyro')
+                logger.debug('Saved param store')
+            except Exception as e:
+                logger.warning(f'Could not save param store: {e}')
 
             if train_loader is not None:
-                # train_loader_file = save_dataloader_state(filebase=filebase,
-                #                                           data_loader_state=train_loader.get_state(),
-                #                                           name='train')
-                torch.save(train_loader, filebase + '_train.loaderstate')
-                file_list.append(filebase + '_train.loaderstate')
+                try:
+                    torch.save(train_loader, filebase + '_train.loaderstate')
+                    file_list.append(filebase + '_train.loaderstate')
+                except (TypeError, pickle.PicklingError) as e:
+                    logger.warning(f'Could not save train_loader: {e}')
+                    
             if test_loader is not None:
-                # test_loader_file = save_dataloader_state(filebase=filebase,
-                #                                          data_loader_state=test_loader.get_state(),
-                #                                          name='test')
-                torch.save(test_loader, filebase + '_test.loaderstate')
-                file_list.append(filebase + '_test.loaderstate')
+                try:
+                    torch.save(test_loader, filebase + '_test.loaderstate')
+                    file_list.append(filebase + '_test.loaderstate')
+                except (TypeError, pickle.PicklingError) as e:
+                    logger.warning(f'Could not save test_loader: {e}')
 
             np.save(filebase + '_args.npy', args)
             file_list.append(filebase + '_args.npy')
 
-            make_tarball(files=file_list, tarball_name=tarball_name)
-
-        logger.info(f'Saved checkpoint as {os.path.abspath(tarball_name)}')
-        return True
+            # Only create tarball if we have the essential files
+            if filebase + '_model.torch' in file_list:
+                make_tarball(files=file_list, tarball_name=tarball_name)
+                logger.info(f'Saved checkpoint as {os.path.abspath(tarball_name)}')
+                return True
+            else:
+                logger.error('Could not save essential model file, checkpoint not created')
+                return False
 
     except KeyboardInterrupt:
         logger.warning('Keyboard interrupt: will not save checkpoint')
@@ -218,36 +443,85 @@ def load_from_checkpoint(filebase: Optional[str],
 
         # Load the saved model.
         if 'model' in to_load:
-            model_obj = torch.load(filebase + '_model.torch', **load_kwargs)
-            logger.debug('Model loaded from ' + filebase + '_model.torch')
-            out.update({'model': model_obj})
+            model_data = torch.load(filebase + '_model.torch', **load_kwargs)
+            
+            # Check if this is a full model object or a state_dict checkpoint
+            if isinstance(model_data, dict) and 'state_dict' in model_data:
+                # This is a state_dict-based checkpoint
+                logger.info('Loading model from state_dict checkpoint')
+                logger.warning('State_dict checkpoint detected. You will need to reconstruct the model object manually.')
+                # Return the checkpoint data so the calling code can reconstruct the model
+                out.update({'model_checkpoint': model_data})
+            else:
+                # This is a full model object
+                model_obj = model_data
+                logger.debug('Model loaded from ' + filebase + '_model.torch')
+                out.update({'model': model_obj})
 
         # Load the saved optimizer.
         if 'optim' in to_load:
-            scheduler = torch.load(filebase + '_optim.torch', **load_kwargs)
-            scheduler.load(filebase + '_optim.pyro', **load_kwargs)  # use PyroOptim method
-            logger.debug('Optimizer loaded from ' + filebase + '_optim.*')
-            out.update({'optim': scheduler})
+            try:
+                scheduler_data = torch.load(filebase + '_optim.torch', **load_kwargs)
+                
+                # Check if this is a prepared optimizer state or full scheduler
+                if isinstance(scheduler_data, dict) and ('type' in scheduler_data or 'optim_objs' in scheduler_data):
+                    logger.info('Loading optimizer from prepared state')
+                    logger.warning('Prepared optimizer state detected. You may need to reconstruct the scheduler manually.')
+                    out.update({'optim_state': scheduler_data})
+                else:
+                    # This should be a full scheduler object
+                    scheduler = scheduler_data
+                    
+                    # Try to load additional PyroOptim state if available
+                    if os.path.exists(filebase + '_optim.pyro'):
+                        try:
+                            scheduler.load(filebase + '_optim.pyro', **load_kwargs)  # use PyroOptim method
+                            logger.debug('Loaded additional PyroOptim state')
+                        except AttributeError:
+                            # If load method doesn't exist, try loading as state
+                            try:
+                                state = torch.load(filebase + '_optim.pyro', **load_kwargs)
+                                if hasattr(scheduler, 'set_state'):
+                                    scheduler.set_state(state)
+                                    logger.debug('Set scheduler state from pyro file')
+                            except Exception:
+                                pass  # State might not be critical
+                    
+                    logger.debug('Optimizer loaded from ' + filebase + '_optim.torch')
+                    out.update({'optim': scheduler})
+                    
+            except Exception as e:
+                logger.warning(f'Could not fully load optimizer, will need to reinitialize: {e}')
+                # Note: The calling code should handle reinitializing the optimizer if needed
 
         # Load the pyro param store.
         if 'param_store' in to_load:
-            pyro.get_param_store().load(filebase + '_params.pyro', map_location=force_device)
-            logger.debug('Pyro param store loaded from ' + filebase + '_params.pyro')
+            if os.path.exists(filebase + '_params.pyro'):
+                try:
+                    pyro.get_param_store().load(filebase + '_params.pyro', map_location=force_device)
+                    logger.debug('Pyro param store loaded from ' + filebase + '_params.pyro')
+                except Exception as e:
+                    logger.warning(f'Could not load param store: {e}')
 
         # Load dataloader states.
         if 'dataloader' in to_load:
-            # load_dataloader_state(data_loader=train_loader, file=filebase + '_train.loaderstate')
-            # load_dataloader_state(data_loader=test_loader, file=filebase + '_test.loaderstate')
             train_loader = None
             test_loader = None
             if os.path.exists(filebase + '_train.loaderstate'):
-                train_loader = torch.load(filebase + '_train.loaderstate', **load_kwargs)
-                logger.debug('Train loader loaded from ' + filebase + '_train.loaderstate')
-                out.update({'train_loader': train_loader})
+                try:
+                    train_loader = torch.load(filebase + '_train.loaderstate', **load_kwargs)
+                    logger.debug('Train loader loaded from ' + filebase + '_train.loaderstate')
+                    out.update({'train_loader': train_loader})
+                except Exception as e:
+                    logger.warning(f'Could not load train_loader: {e}')
+                    
             if os.path.exists(filebase + '_test.loaderstate'):
-                test_loader = torch.load(filebase + '_test.loaderstate', **load_kwargs)
-                logger.debug('Test loader loaded from ' + filebase + '_test.loaderstate')
-                out.update({'test_loader': test_loader})
+                try:
+                    test_loader = torch.load(filebase + '_test.loaderstate', **load_kwargs)
+                    logger.debug('Test loader loaded from ' + filebase + '_test.loaderstate')
+                    out.update({'test_loader': test_loader})
+                except Exception as e:
+                    logger.warning(f'Could not load test_loader: {e}')
 
         # Load args, which can be modified in the case of auto-learning-rate updates.
         if 'args' in to_load:
@@ -256,8 +530,11 @@ def load_from_checkpoint(filebase: Optional[str],
 
         # Update states of random number generators across the board.
         if 'random_state' in to_load:
-            load_random_state(filebase=filebase)
-            logger.debug('Loaded random state globally for python, numpy, pytorch, and cuda')
+            try:
+                load_random_state(filebase=filebase)
+                logger.debug('Loaded random state globally for python, numpy, pytorch, and cuda')
+            except Exception as e:
+                logger.warning(f'Could not load random state: {e}')
 
         # Copy the posterior file outside the temp dir so it can be loaded later.
         if 'posterior' in to_load:
@@ -375,4 +652,4 @@ def create_workflow_hashcode(module_path: str,
     except Exception:
         return ''
 
-    return hasher.hexdigest()
+    return hasher.hexdigest()
\ No newline at end of file
diff --git a/cellbender/remove_background/estimation.py b/cellbender/remove_background/estimation.py
index 777bf03..a025c18 100644
--- a/cellbender/remove_background/estimation.py
+++ b/cellbender/remove_background/estimation.py
@@ -387,8 +387,9 @@ def _mckp_chunk_estimate_noise(
 
     # Now we want the smallest additional_noise_counts_per_gene deltas for each gene.
     # https://stackoverflow.com/questions/55179493/
-    df_out = df[['m', 'g', 'delta', 'topk']].groupby('g', group_keys=False).apply(
-        lambda x: x.nsmallest(x['topk'].iat[0], columns='delta')
+    df_out = df[['m', 'g', 'delta', 'topk']].groupby('g').apply(
+        lambda x: x.nsmallest(x['topk'].iat[0], columns='delta'),
+        include_groups=False
     )
     logger.debug(f'{timestamp()} Computing nsmallest done')
 
@@ -683,8 +684,9 @@ def _chunk_estimate_noise(self,
 
         # Now we want the smallest additional_noise_counts_per_gene deltas for each gene.
         # https://stackoverflow.com/questions/55179493/
-        df_out = df[['m', 'g', 'delta', 'topk']].groupby('g', group_keys=False).apply(
-            lambda x: x.nsmallest(x['topk'].iat[0], columns='delta')
+        df_out = df[['m', 'g', 'delta', 'topk']].groupby('g').apply(
+            lambda x: x.nsmallest(x['topk'].iat[0], columns='delta'),
+            include_groups=False
         )
         logger.debug(f'{timestamp()} Computing nsmallest done')
 
diff --git a/cellbender/remove_background/report.ipynb b/cellbender/remove_background/report.ipynb
index b091c1b..1fa4696 100644
--- a/cellbender/remove_background/report.ipynb
+++ b/cellbender/remove_background/report.ipynb
@@ -43,13 +43,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "from cellbender.remove_background.report import generate_summary_plots"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "cellbender remove-background --cuda --epochs 150 --learning-rate 5e-5 --input /ocean/projects/cis240075p/asachan/datasets/TA_muscle/ERCC1_KO_mice/samples_2025/pool1_4_female/cell_ranger_outs/multi/count/raw_feature_bc_matrix.h5 --output cellbender_feature_bc_matrix.h5"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -66,15 +73,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Input file: /ocean/projects/cis240075p/asachan/datasets/TA_muscle/ERCC1_KO_mice/samples_2025/pool5_8_male/cell_ranger_outs/multi/count/raw_feature_bc_matrix.h5\n",
+      "Output file: /ocean/projects/cis240075p/asachan/datasets/TA_muscle/ERCC1_KO_mice/samples_2025/pool5_8_male/cell_ranger_outs/multi/count/cellbender/lr_e_neg5/cellbender_feature_bc_matrix.h5\n"
+     ]
+    }
+   ],
    "source": [
     "# Allows us to get the filenames without needing to rewrite this notebook\n",
-    "\n",
     "import os\n",
-    "input_file = os.environ['INPUT_FILE']\n",
-    "output_file = os.environ['OUTPUT_FILE']\n",
+    "#input_file = os.environ['INPUT_FILE']\n",
+    "input_file = '/ocean/projects/cis240075p/asachan/datasets/TA_muscle/ERCC1_KO_mice/samples_2025/pool5_8_male/cell_ranger_outs/multi/count/raw_feature_bc_matrix.h5'\n",
+    "#output_file = os.environ['OUTPUT_FILE']\n",
+    "output_file = '/ocean/projects/cis240075p/asachan/datasets/TA_muscle/ERCC1_KO_mice/samples_2025/pool5_8_male/cell_ranger_outs/multi/count/cellbender/lr_e_neg5/cellbender_feature_bc_matrix.h5'\n",
     "\n",
     "# For the case of a simulated dataset where we have the ground truth\n",
     "try:\n",
@@ -97,11 +114,2963 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "### CellBender version 0.3.2"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "2025-08-12 22:02:03"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "# cellbender_feature_bc_matrix.h5"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/ocean/projects/cis240075p/asachan/.conda/envs/cellbender/lib/python3.10/site-packages/anndata/_core/anndata.py:381: FutureWarning: The dtype argument is deprecated and will be removed in late 2024.\n",
+      "  warnings.warn(\n",
+      "/ocean/projects/cis240075p/asachan/.conda/envs/cellbender/lib/python3.10/site-packages/anndata/_core/anndata.py:381: FutureWarning: The dtype argument is deprecated and will be removed in late 2024.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Loaded dataset"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AnnData object with n_obs × n_vars = 40949 × 32285\n",
+      "    obs: 'background_fraction', 'cell_probability', 'cell_size', 'droplet_efficiency', 'n_raw', 'n_cellbender'\n",
+      "    var: 'ambient_expression', 'feature_type', 'genome', 'gene_id', 'cellbender_analyzed', 'n_raw', 'n_cellbender'\n",
+      "    uns: 'cell_size_lognormal_std', 'empty_droplet_size_lognormal_loc', 'empty_droplet_size_lognormal_scale', 'swapping_fraction_dist_params', 'estimator', 'features_analyzed_inds', 'fraction_data_used_for_testing', 'learning_curve_learning_rate_epoch', 'learning_curve_learning_rate_value', 'learning_curve_test_elbo', 'learning_curve_test_epoch', 'learning_curve_train_elbo', 'learning_curve_train_epoch', 'target_false_positive_rate'\n",
+      "    obsm: 'cellbender_embedding'\n",
+      "    layers: 'raw', 'cellbender'\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/ocean/projects/cis240075p/asachan/.conda/envs/cellbender/lib/python3.10/site-packages/anndata/_core/anndata.py:381: FutureWarning: The dtype argument is deprecated and will be removed in late 2024.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Examine how many counts were removed in total"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "removed 12503382 counts from non-empty droplets\n",
+      "removed 19.22% of the counts in non-empty droplets\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Rough estimate of expectations based on nothing but the plot above:\n",
+      "roughly 12417291 noise counts should be in non-empty droplets\n",
+      "that is approximately 19.09% of the counts in non-empty droplets\n",
+      "with a false positive rate [FPR] of 1.0%, we would expect to remove about 20.09% of the counts in non-empty droplets\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "It looks like the algorithm did a decent job meeting that expectation."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Assessing convergence of the algorithm"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">The learning curve tells us about the progress of the algorithm in inferring all the latent variables in our model.  We want to see the ELBO increasing as training epochs increase.  Generally it is desirable for the ELBO to converge at some high plateau, and be fairly stable.</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">What to watch out for:</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">1. large downward spikes in the ELBO (of value more than a few hundred)</span>*\n",
+       "*<span style=\"color:gray\">2. the test ELBO can be smaller than the train ELBO, but generally we want to see both curves increasing and reaching a stable plateau.  We do not want the test ELBO to dip way back down at the end.</span>*\n",
+       "*<span style=\"color:gray\">3. lack of convergence, where it looks like the ELBO would change quite a bit if training went on for more epochs.</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**Automated assessment** --------"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "- We typically expect to see the training ELBO increase almost monotonically.  This curve seems to have a concerted period of motion in the wrong direction near epoch 42. If this is early in training, this is probably okay."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**Summary**:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "This learning curve looks normal."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Examine count removal per gene"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Pearson correlation coefficient for the above is 0.9900"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "This meets expectations."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "### Table of top genes removed\n",
+       "\n",
+       "Ranked by fraction removed, and excluding genes with fewer than 2700 total raw counts (90th percentile)"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ambient_expression</th>\n",
+       "      <th>feature_type</th>\n",
+       "      <th>genome</th>\n",
+       "      <th>gene_id</th>\n",
+       "      <th>cellbender_analyzed</th>\n",
+       "      <th>n_raw</th>\n",
+       "      <th>n_cellbender</th>\n",
+       "      <th>n_removed</th>\n",
+       "      <th>fraction_removed</th>\n",
+       "      <th>fraction_remaining</th>\n",
+       "      <th>n_raw_cells</th>\n",
+       "      <th>n_cellbender_cells</th>\n",
+       "      <th>n_removed_cells</th>\n",
+       "      <th>fraction_removed_cells</th>\n",
+       "      <th>fraction_remaining_cells</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>gene_name</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>mt-Nd2</th>\n",
+       "      <td>0.006947</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000064345</td>\n",
+       "      <td>True</td>\n",
+       "      <td>96231</td>\n",
+       "      <td>269</td>\n",
+       "      <td>95962</td>\n",
+       "      <td>0.997205</td>\n",
+       "      <td>0.002795</td>\n",
+       "      <td>84194</td>\n",
+       "      <td>269</td>\n",
+       "      <td>83925</td>\n",
+       "      <td>0.996805</td>\n",
+       "      <td>0.003195</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Ndufb1-ps</th>\n",
+       "      <td>0.000262</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000113902</td>\n",
+       "      <td>True</td>\n",
+       "      <td>4093</td>\n",
+       "      <td>360</td>\n",
+       "      <td>3733</td>\n",
+       "      <td>0.912045</td>\n",
+       "      <td>0.087955</td>\n",
+       "      <td>3747</td>\n",
+       "      <td>360</td>\n",
+       "      <td>3387</td>\n",
+       "      <td>0.903923</td>\n",
+       "      <td>0.096077</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Gapdh</th>\n",
+       "      <td>0.001497</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000057666</td>\n",
+       "      <td>True</td>\n",
+       "      <td>23534</td>\n",
+       "      <td>2085</td>\n",
+       "      <td>21449</td>\n",
+       "      <td>0.911405</td>\n",
+       "      <td>0.088595</td>\n",
+       "      <td>21077</td>\n",
+       "      <td>2085</td>\n",
+       "      <td>18992</td>\n",
+       "      <td>0.901077</td>\n",
+       "      <td>0.098923</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Aldoa</th>\n",
+       "      <td>0.003214</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000030695</td>\n",
+       "      <td>True</td>\n",
+       "      <td>50466</td>\n",
+       "      <td>4610</td>\n",
+       "      <td>45856</td>\n",
+       "      <td>0.908651</td>\n",
+       "      <td>0.091349</td>\n",
+       "      <td>45481</td>\n",
+       "      <td>4610</td>\n",
+       "      <td>40871</td>\n",
+       "      <td>0.898639</td>\n",
+       "      <td>0.101361</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Tnni2</th>\n",
+       "      <td>0.004772</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000031097</td>\n",
+       "      <td>True</td>\n",
+       "      <td>74248</td>\n",
+       "      <td>6854</td>\n",
+       "      <td>67394</td>\n",
+       "      <td>0.907688</td>\n",
+       "      <td>0.092312</td>\n",
+       "      <td>67200</td>\n",
+       "      <td>6854</td>\n",
+       "      <td>60346</td>\n",
+       "      <td>0.898006</td>\n",
+       "      <td>0.101994</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mt-Nd4l</th>\n",
+       "      <td>0.001333</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000065947</td>\n",
+       "      <td>True</td>\n",
+       "      <td>19778</td>\n",
+       "      <td>1909</td>\n",
+       "      <td>17869</td>\n",
+       "      <td>0.903479</td>\n",
+       "      <td>0.096521</td>\n",
+       "      <td>17466</td>\n",
+       "      <td>1909</td>\n",
+       "      <td>15557</td>\n",
+       "      <td>0.890702</td>\n",
+       "      <td>0.109298</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mt-Cytb</th>\n",
+       "      <td>0.007846</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000064370</td>\n",
+       "      <td>True</td>\n",
+       "      <td>117987</td>\n",
+       "      <td>11402</td>\n",
+       "      <td>106585</td>\n",
+       "      <td>0.903362</td>\n",
+       "      <td>0.096638</td>\n",
+       "      <td>104175</td>\n",
+       "      <td>11402</td>\n",
+       "      <td>92773</td>\n",
+       "      <td>0.890550</td>\n",
+       "      <td>0.109450</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mt-Nd4</th>\n",
+       "      <td>0.009956</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000064363</td>\n",
+       "      <td>True</td>\n",
+       "      <td>148994</td>\n",
+       "      <td>14635</td>\n",
+       "      <td>134359</td>\n",
+       "      <td>0.901775</td>\n",
+       "      <td>0.098225</td>\n",
+       "      <td>130619</td>\n",
+       "      <td>14635</td>\n",
+       "      <td>115984</td>\n",
+       "      <td>0.887957</td>\n",
+       "      <td>0.112043</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mt-Co2</th>\n",
+       "      <td>0.007697</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000064354</td>\n",
+       "      <td>True</td>\n",
+       "      <td>114980</td>\n",
+       "      <td>11355</td>\n",
+       "      <td>103625</td>\n",
+       "      <td>0.901244</td>\n",
+       "      <td>0.098756</td>\n",
+       "      <td>100608</td>\n",
+       "      <td>11355</td>\n",
+       "      <td>89253</td>\n",
+       "      <td>0.887136</td>\n",
+       "      <td>0.112864</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mt-Atp6</th>\n",
+       "      <td>0.009065</td>\n",
+       "      <td>Gene Expression</td>\n",
+       "      <td>mm10</td>\n",
+       "      <td>ENSMUSG00000064357</td>\n",
+       "      <td>True</td>\n",
+       "      <td>135230</td>\n",
+       "      <td>13670</td>\n",
+       "      <td>121560</td>\n",
+       "      <td>0.898913</td>\n",
+       "      <td>0.101087</td>\n",
+       "      <td>118715</td>\n",
+       "      <td>13670</td>\n",
+       "      <td>105045</td>\n",
+       "      <td>0.884850</td>\n",
+       "      <td>0.115150</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox5b decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Camk1d decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ak1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5g3 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cst3 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Tnnc2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5e decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb5 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufc1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps3a1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Gng5 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps20 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps8 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufs5 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5k decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rpl6 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Chchd2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5j2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rpl21 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufa4 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufa5 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cycs decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Gapdh decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Selenow decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox6b1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufc2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Aldoa decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Mylpf decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox6a2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox8b decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rplp2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ctsd decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Tnni2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Slc25a4 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufa13 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox4i1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rpl13 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Acta1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Hspa8 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox5a decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rplp1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox7a2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cisd1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Chchd10 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Gpx4 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5d decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufs7 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Uqcr11 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Uqcr10 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Pgam2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps27a decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Uqcrq decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ubb decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Nme2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5g1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rpl23 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Eif1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb1-ps decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5mpl decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Uqcrfs1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Uqcrb decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox7c decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps24 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Tpt1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Cox6c decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb9 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufa6 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5g2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb4 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rpl24 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5j decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5o decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Rps2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb10 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Hsp90ab1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Drap1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Fth1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb8 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Atp5md decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene Ndufb11 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Co1 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Co2 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Atp6 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Co3 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd3 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd4l decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd4 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd5 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Nd6 decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "**WARNING**: The expression of the highly-expressed gene mt-Cytb decreases quite markedly after CellBender.  Check to ensure this makes sense!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Cell probabilities"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "The inferred posterior probability that each droplet is non-empty."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">We sometimes write \"non-empty\" instead of \"cell\" because dead cells and other cellular debris can still lead to a \"non-empty\" droplet, which will have a high posterior cell probability.  But these kinds of low-quality droplets should be removed during cell QC to retain only high-quality cells for downstream analyses.</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/ocean/projects/cis240075p/asachan/algo_dev/CellBender/cellbender/remove_background/report.py:792: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  plt.plot(adata.obs['cell_probability'][order].values, '.', ms=2, alpha=0.2, color='red')\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## Concordance of data before and after `remove-background`"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">The intent is to change the input data as little as possible while achieving noise removal.  These plots show general summary statistics about similarity of the input and output data.  We expect to see the data lying close to a straight line (gray).  There may be outlier genes/features, which are often those highest-expressed in the ambient RNA.</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "The plots here show data for inferred cell-containing droplets, and exclude the empty droplets."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 900x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "## PCA of encoded gene expression"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/ocean/projects/cis240075p/asachan/algo_dev/CellBender/cellbender/remove_background/report.py:1021: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
+      "  c=np.log10(adata.obs['cell_size'][cells][sizeorder]),\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAHMCAYAAAB1H8rNAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXeYXVW5/z+7nj69Tya9E0hIQkuAhIAgiIAIgoCABaIUDUWvXAuIcNGrF6SIgPwQ9CoqygVBgUhL6IQklIT0OklmMv30c3Zbvz/2mZFhJmVCJgm4Ps9znmTWXnvttfdeZ+/vedf7vksRQggkEolEIpFI9hHq/u6ARCKRSCSSfy+k+JBIJBKJRLJPkeJDIpFIJBLJPkWKD4lEIpFIJPsUKT4kEolEIpHsU6T4kEgkEolEsk+R4kMikUgkEsk+RYoPiUQikUgk+xQpPiQSiUQikexTpPiQSAaBjRs3oigKF1988f7uygHDiy++iKIo3HDDDfutD8OHD2f48OG7XX9H9/Hiiy9GURQ2bty4V/snkfy7IMXHR2T16tVcffXVTJ06lbKyMgzDoKysjCOOOIJrr72WxYsX7+8uSiQSiURyQCHFxx4ihOBHP/oREyZM4LbbbkNRFM455xy+853vcMEFFxAKhbjzzjuZPn06v/zlL/d3dyX7mPr6elasWMEtt9yyv7siGQRuueUWVqxYQX19/f7uikTysUTf3x34uHLjjTdyww030NDQwMMPP8zMmTP71GlpaeEXv/gF8Xh8P/RQsj8xDIPx48fv725IBona2lpqa2v3dzckko8t0vKxB6xfv56bbroJ0zR56qmn+hUeAFVVVfzXf/0X3/nOd/psy2Qy3HLLLUyZMoVIJEI0GuWoo47i4Ycf7lP3g3Plb7/9Np/5zGcoKSkhHA4za9YsXn311X6P7zgOd999N0ceeSRFRUWEw2EOPfRQ7rrrLjzPG9A5d3R0cN111zFhwgRCoRDFxcUcf/zxzJ8/v1e9Rx99FEVROPLII7Ftu9e2ZcuWEQ6Hqauro6Wlpae8ex4+Ho9zxRVXUF9fTzAYZOLEidxxxx18eOHlD87Dr169mnPOOYeqqipUVeXFF1/sqffMM89wyimnUFFRQSAQYNSoUXz729+mq6urz/m9++67fPGLX2T48OEEAgEqKyuZOnUq8+bN63UeyWSSH//4x0yaNImioiJisRijRo3inHPO6TXFtjOfj6amJi6//HKGDx+OaZpUVlZy5pln9jtF9+CDD6IoCg8++CAvvPACs2fPJhaLUVRUxGc+8xlWrFjR7/3aGQO5Lt33JpVKcdVVV9HQ0EAoFGLKlCk89thjgD/Obr75ZsaMGUMwGGTUqFHcddddO+3Da6+9xgknnEBxcTGxWIyTTjqJt956q9+6Ax3HQgjuuusuDjroIILBIPX19VxxxRU7/RGQTCa5+uqrGTJkCMFgkPHjx3Prrbfu8HvSn8/HB+/5xo0bOffcc6moqCAYDDJ9+nSefPLJftuKx+PMmzevz7HXr18v/YYkn1yEZMB8//vfF4A477zz9mj/zs5OceihhwpATJ06VVxxxRXisssuE6NGjRKA+N73vter/gsvvCAA8ZnPfEaEQiExZ84ccc0114izzz5bqKoqgsGgWLlyZa99LMsSJ510kgDEuHHjxNy5c8W3vvUtccghhwhAXHDBBbvd340bN4rhw4cLQBxzzDFi3rx54pJLLhG1tbVCURRx33339ap/+eWXC0B8+9vf7ilLp9NiwoQJQlVV8fzzz/eqP2zYMFFbWyumT58uRo8eLa6++mpxxRVXiNraWgGIyy67rFf9DRs2CEAcffTRoqSkRBx++OFi3rx5Yu7cuWLx4sVCCCFuuOEGAYiysjJx4YUXimuvvVaceOKJAhATJ04U8Xi8p7133nlHBINBEQqFxDnnnCO++93vissuu0yceOKJwjAMkUwmhRBCeJ4nZsyYIQBx1FFHiauuukp8+9vfFl/84hdFTU2NuPPOO/v08aKLLurV9/Xr14u6ujoBiDlz5ojvfve74vzzzxemaQrTNMUTTzzRq/5vfvMbAYjPf/7zQtd18dnPflZce+214pRTThGAqKysFK2trbt9LwdyXbrvTV1dnTjyyCPF2LFjxeWXXy4uueQSEY1Ghaqq4tlnnxVnnnmmqK+vF1/72tfE5ZdfLqqqqgQg/vjHP/Zqq3scf/rTnxamaYpTTjlFXHfddeLss88WmqaJYDAoFi5c2GufPRnH3/zmNwUgamtrxZVXXimuvvpqMWrUKDF9+nRRW1srhg0b1qt+LpcThx12mADE5MmTxXe+8x1x6aWXipKSEnHaaaf1ex8vuugiAYgNGzb0lHXf89mzZ4vKykpxxBFHiHnz5okLL7xQBAKBfsd+NpsVU6dOFYA49NBDxXe+8x0xd+5cUVZWJs4444x+jy2RfBKQ4mMPOO644wQg7r///j3av/vB9dOf/rRXeTabFSeddJJQFEUsXbq0p7z7oQ2I3/zmN732ueeeewQgvvGNb/Qqv/766wUgrrjiCuE4Tk+54zjiK1/5igDEY489tlv9nTVrllAURTz88MO9yjs7O8XkyZNFMBgUzc3NPeW5XE4ceuihQlEU8dRTTwkhhLj44osFIH74wx/2aX/YsGECEDNnzhS5XK6nvL29XYwcOVIAYsGCBT3l3Q95QFx33XV92nv++ed7BEJnZ2evbd0v83nz5vWUXX311Tu8Hh0dHcJ1XSGEEO+++64AxBlnnNGnnuu6oqOjo08fP/zi6H7R33TTTb3KX3nlFaFpmigrK+sROx/sr6Zp4tlnn+21z3e/+91+x9GOGOh1EeJf9+bUU0/tdW8WLlwoAFFaWiqmT5/eq71169YJwzDElClTerX1wXH8QaEmhBCPPfaYAMTo0aN7rrcQAx/Hr7zyigDEqFGjRHt7e095NpsVRx55pAD6iI+bb75ZAOLMM8/sdez169eL0tLSAYsPQNxwww296j/99NMCECeffHKv8htvvFEA4txzzxWe5/WUb968WVRUVEjxIfnEIsXHHjBhwgQB9LxYP8iGDRvE9ddf3+tz22239Wxva2sTmqaJ6dOn99v222+/3cdq0P3QnjlzZp/6lmUJXdfFtGnTespc1xVlZWWipqZG2LbdZ5/Ozk6hKIo4++yzd3mu3f0566yz+t3e/dL45S9/2at89erVIhqNisrKSvGzn/1MAOLYY4/t9QLppvsF9+FfvUL866V48cUX95R1P+Srq6t7vRC76f7FuGzZsn77PGXKFFFZWdnzd7f4eOaZZ/q/CAW6xccXv/jFndb7YB8/+OJobGwUgBg6dKiwLKvPPhdccIEAxEMPPdRT1n3+559/fp/669ev77GK7A4DvS5C/OverF27tk/9ESNGCEA899xzfbbNnj1b6Lre6353j+MPC4xuZs2aJQDx4osvCiH2bBx/7WtfE4B44IEH+tTvPv6Hxcfo0aOFqqr9nmO3+BmI+Bg2bFi/43zo0KGivLy8V9moUaOEqqq92unmpptukuJD8olFOpzuZTZu3MiPfvSjXmXDhg1j3rx5ACxatAjXdXeY76Dbv6C/ufzp06f3KTMMg+rqajo7O3vKVq9eTUdHB2PGjOGmm27qt5+hUGi3/AVee+01wJ+X7q+/ra2t/fZ3zJgx3HPPPVxwwQV8+9vfpqKigj/84Q9omtbvcXRdZ8aMGX3KZ8+eDcDSpUv7bJs8eTKBQKDfPhuGwSOPPMIjjzzSZ7tlWbS2ttLe3k55eTnnnHMOt99+O2eccQZnnXUWJ5xwAjNnzmTUqFG99ps4cSJTpkzh4YcfZtOmTZx++ukcffTRTJ8+HdM0+z2vD9J9DscccwyGYfTZPmfOHP73f/+XpUuXcuGFF/ba1t+9b2hoAOh173fGQK9LNyUlJX2uBUBdXR0bNmxg2rRpfbbV19fjOA7Nzc19IkKOOeYYVLWvu9ns2bNZsGABS5cuZdasWXs0jpcsWQLArFmz+tQ9+uij+4y/ZDLJ2rVraWho6PccZ8+e3ef7vCumTJnS7zhvaGjo+T4BJBIJ1q1bR0NDQ7+5R44++ugBHVci+TghxcceUFNTw4oVK9i2bVufbbNnz+5xkHQcp89Lpr29HfBFyKJFi3Z4jFQq1aespKSk37q6ruO6bp9jrFmzZqcPzv6O8WG62/rnP//JP//5zwG1deKJJ1JUVEQikeDss8/eaVhiRUVFvw/smpoagH6dBbu39ddnx3F2+dJIpVKUl5dz+OGH89JLL3HzzTfzl7/8hd/97ncAjBs3juuvv54vfvGLAGiaxvPPP8+NN97IX/7yF/7jP/4DgFgsxkUXXcQtt9xCNBrd4fG6z2FHURLd5f05fvZ373Xd//p+8N7vjIFel26Ki4v7rdd9/P62d2/7sNMxQHV1db/tffhe78k47t63v2Pouk5FRUWvsp3V/2CfBsLOvqcfdGBNJBI7PfaOyiWSTwIy2mUP6I5uee655wa8b/eD+qqrrkL40179fl544YU97l/3MT73uc/t9BgbNmzY7bZuv/32nbb1m9/8ptd+QgguvPBCEokEFRUV3HfffSxcuHCHx2lra+v3Jdrc3NyrHx9EUZQd9rm0tHSn/RVCMGzYsJ59jjrqKJ588kk6Ozt55ZVX+MEPfsD27ds577zzePbZZ3vqlZaWctttt9HY2MiaNWu4//77GT9+PHfddRff+MY3dnIl/3UO3ef0YZqamnZ4rnuDPbkug8H27dv7Lf/wvd6Tcdy9T3/HcByHtra2XmU7q//BPg0GRUVFOz32jsolkk8CUnzsARdffDG6rvOXv/xlwKGOhx9+OKqq8tJLLw1S72D8+PGUlJTw+uuv9/vLcyAceeSRAAPu789+9jOefvppzj//fJ5//nkMw+C8887r+TX7YRzH6TdkuDt09tBDDx1Qnzs7O1m+fPmA+gwQCASYMWMGN954I3fccQcAjz/+eL91R48ezVe/+lUWLFhANBrdYb1uus/h5ZdfxnGcPtu7BefUqVMH3O/d4aNcl73Jyy+/3G8I64fv9Z6M4+5rt2DBgn6P+2GBG4vFGD16NFu3bmXdunU77NNgUFRUxMiRI9m6dWu/adpffvnlQTu2RLK/keJjDxg1ahTf//73sSyLk08+eYd5Nvozn1dVVXH++efz1ltv8eMf/7jfX/vr1q3bLavEjtB1nSuvvJKmpia++c1vks1m+9Rpamri/fff32Vb06dP55hjjuHRRx/lgQce6LfOe++91ytvx+uvv873vvc9Ro8eza9+9SsOPvhgbrvtNrZu3cpFF13UJ29HN9dddx35fL7n746Ojp65/i9/+cu77Gs3V111FQCXXHJJv1Nj6XSa119/vefvV199td9r1P3LMxwOA7BhwwbWr1/fp15nZyf5fJ5QKLTTfg0ZMoRPfepTbNy4kV/84he9tr3xxhv84Q9/oLS0lM997nM7P8E9ZKDXZbBYs2YNd999d6+yxx9/nAULFjB69GiOOeYYYM/GcXdOjJtvvpmOjo6e8lwux3XXXddvf7785S/jeR7/8R//0UsUbdiwoUeADhYXXnghnudx3XXX9fpeNDY29hkjEsknCenzsYf88Ic/RAjBj3/8Y2bOnMm0adM4/PDDKSsro6uri40bN/aY64899the+951112sWbOGH/7wh/zud7/j6KOPprq6mm3btrFixQoWLVrEww8/zIgRI/a4fz/4wQ945513uOeee3jiiSeYM2cO9fX1tLS0sGbNGl555RVuvvlmJk6cuMu2/vCHPzBnzhy++tWvcscdd3DEEUdQUlLCli1bePfdd1m2bBmvvfYaVVVVdHV18cUvfhFVVfnjH/9ILBYD4Otf/zrPPfccf/nLX7j11lu55ppreh2jtraWfD7PpEmTOO2007Btm7/85S80NTVx2WWX9bmGO+P444/nJz/5Cddddx1jxozhlFNOYcSIEaRSKTZt2sSCBQs4+uijefrppwH47//+b55//nmOOeYYRowYQTQaZfny5Tz11FOUlpZy6aWXAvDOO+9w5plncthhhzFhwgTq6upobW3l8ccfx7btHh+QnXHPPfcwc+ZMvv3tbzN//nymT59OY2MjjzzyCKqq8pvf/Kbnmu1tBnpdBotPf/rTXHPNNTz11FNMnjyZtWvX8uijjxIMBnnggQd6OaMOdBzPnDmTK6+8kjvvvJNJkyZx1llnYRgGjz/+OKWlpf3621xzzTU89thj/PWvf2Xq1KmcdNJJdHV18ec//5ljjz2Wv/3tb4N2Lb7zne/w2GOP8cc//pFVq1Zx4oknEo/He4792GOP9eucK5F87Nnr8TP/ZqxcuVLMmzdPTJ48WRQXFwtd13tyH8ybN68n6dWHyefz4s477xRHHXWUKCoqEqZpioaGBjFnzhxx2223iba2tp663SGC119/fb9tDRs2rE/4oBB+Uqzf/va3Ys6cOaK0tFQYhiHq6urEzJkzxc033yw2b9682+eZSCTEzTffLKZOnSoikYgIBoNi+PDh4pRTThH33nuvSKVSQgghzjzzTAGIW2+9tU8bXV1dYsSIEcIwDPHGG2/06X9XV5e47LLLRF1dnTBNU4wfP17cfvvtvfIfCLHjHBof5qWXXhJnn322qK2tFYZhiIqKCjF58mRx1VVXiUWLFvXUe+aZZ8TFF18sJkyYIIqKikQ4HBZjx44VV155pdi4cWNPvcbGRnHdddeJGTNmiOrqamGapqivrxef/vSnxT/+8Y/d7uOWLVvE17/+dTF06FBhGIYoLy8Xp59+unjzzTf71O0Otf1wfpduADFr1qydXoc9vS5C7HhsCfGv0Nj+6C8U9YPj+NVXXxXHH3+8iMViIhqNik996lP9nr8QAx/HnueJO++8U4wfP16Ypilqa2vFZZddJrq6unZ4PvF4XFx11VWirq5OBAIBMW7cOPHzn/9crFu3bsChtjsalzu6Xp2dneLKK68UtbW1wjTNnmO/8cYbAhDf+ta3+m1PIvk4owixAxu4RLKP6A4zlMuTSyT/4te//jWXXnop99xzD3Pnzt3f3ZFI9irSnieRSCT7kf78bzZv3syPf/xjdF3ns5/97H7olUQyuEifD4lEItmPfP7zn8e2baZNm0ZJSQkbN27kySef7Fl8sq6ubn93USLZ60jxIZFIJPuRL33pS/zud7/jr3/9K/F4nGg0yhFHHMEVV1zBmWeeub+7J5EMCtLnQyKRSCQSyT5F+nxIJBKJRCLZp0jxIZFIJBKJZJ8ixYdEIpFIJJJ9ihQfEolEIpFI9in/luJj48aNKIrSsw7Ex4Xhw4f3JOTaFfvzHD+u1/ejMhjnfccddzBx4kRCoRCKonxi1vsYyFgeTHZ0zwZrDH/cvhuNjY0oiiKjbiR7nX9L8SH55PKXv/yFK6+8kmOOOYaioiIUReGCCy7Y5X5btmzhK1/5CnV1dQQCAYYPH868efPo7OzcB73unz/+8Y9861vfIhgMMm/ePK6//vqeVYYlkn3B4sWLgcFbaVny74vM8yH5RHHTTTfxzjvvEI1GGTJkCCtXrtzlPuvWrWPGjBm0tLRw+umnM378eN58801uv/12nn76aV555RXKy8t32U59fT0rVqyguLh4b5wKTz75ZM+/MtHUJ4O9PUYGmyVLlgAwbdq0/dwTyScNafmQfKK47bbbWL16NYlEgl/96le7tc9ll11GS0sLd9xxB4899hg/+clPeP7557nqqqtYtWoV3/ve93arHcMwGD9+fL8rp+4J3Wm3pfD45LC3x8hgIy0fksHigBcfb775Jueccw719fUEAgFqa2s58cQT+fOf/9yrXvcS1MXFxYRCIQ4++GBuueUW8vn8gI43kHY+OH+7evVqzjnnHKqqqlBVlRdffLGn3htvvMFZZ51FTU0NpmnS0NDA3Llz+13TQQjBXXfdxUEHHUQwGKS+vp4rrriCeDw+oPP4ICtXruSMM86grKyMSCTC0Ucfzfz58/vUURSF4447boftHHzwwRiGQVNT0x73BQZ2jYUQ3H777UycOLHP9ejPb+C4445jzJgxKIqyW31Zt24d8+fPZ/jw4Vx++eW9tv3oRz8iEonwu9/9jnQ6vcu2dsd/YOPGjZx77rlUVFQQDAaZPn16j4WjmxtuuAFFUXjhhRcAUBSl5/NBdndc7WqcDsY4hr0/lnf3WbAnff2o/O1vf+P444+ntraWQCBAXV0ds2bN4u677+5Vr78xMnz48F73+MOf/vxD9ub5OY7D7bffziGHHEIwGGTYsGH89Kc/RQjBkiVLqKuro7q6esDtSiQ744Cedvn1r3/NN77xDTRN47TTTmPMmDG0tLTw1ltvcffdd/OFL3wBgP/8z//klltuoaKigvPOO49oNMpTTz3Ff/7nf/LMM88wf/58TNPc5fH2tJ1169ZxxBFHMHbsWM4//3yy2SxFRUUAPPDAA1x66aUEAgFOO+00GhoaWLNmDffffz9PPPEEr7/+OkOHDu1pa968edxxxx3U1tZy6aWXYhgGjz/+OG+88QaWZe3WeXyQDRs2cNRRR3HwwQczd+5cmpqa+NOf/sTJJ5/MH/7wB8455xwAxo8fz3HHHccLL7zA6tWrGTt2bK92Xn31VZYtW8bnP//5j/SrbaDX+PLLL+dXv/oVdXV1XHrppZimyd/+9jfefPNNbNvGMIw97gvQ84I/8cQTUdXeWjwWizFz5kzmz5/P66+/zvHHH/+RjrVp0yYOP/xwRo4cyZe+9CU6Ojr405/+xOmnn86zzz7bI/xmz54NwIMPPsimTZu4/vrr+7Q10HEFOx+nu9q+J8fbm2N5d58Fe9rXj8J9993H3Llzqamp4bOf/SwVFRW0tLTw7rvv8pvf/IbLLrtsp/vPmzePrq6uPuVPPPEES5YsIRwO9yrfm+dnWRannnoq//znP5kyZQpXXnkl7e3t3HDDDaxdu5bm5ma5sJ1kcBAHKMuXLxe6rovS0lKxbNmyPtsbGxuFEEK8+uqrAhANDQ2iqampZ7tt2+LUU08VgLj55pt77bthwwYBiIsuuqin7KO0A4jrrruuTx9XrVolDMMQo0aNElu2bOm17dlnnxWqqoozzjijp+yVV14RgBg1apRob2/vKc9ms+LII48UgBg2bNhOrlr/fbv22mt7bVu0aJHQdV2UlJSIeDzeU/7II48IQFxzzTV92rvooosEIObPn7/bx/7g9RVi4Nd44cKFAhBjx44VnZ2dPeX5fF4cc8wxu7weL7zwggDE+eefv8M61157rQDEz3/+8363X3755QIQd999985PWuz4vD94L2644YZe255++mkBiJNPPrlPe7NmzRL9fUUHOq52NU739jgWYu+O5d19FuxJX3d1zz5c3h9Tp04VpmmK7du399nW2tq6R+3Onz9f6LouRo8e3auNPbkXO+NrX/uaAMSNN94oPM/rKV+wYEHPmLj++ut3uz2JZHc5YMXHFVdcIQBx66237rRe95fn3nvv7bNt1apVQlVVMWLEiF7l/T0APko71dXVIpfL9dlv3rx5AhBPPvlkv30/44wzhKZpIpFI9OrDAw880Kdu94t0oOKjuLi4p/0P0i0mHnzwwZ4y27ZFbW2tKC8v73U+nZ2dIhQKiVGjRvV6QO3q2B9+wA70Gn/1q18VgHjooYf61H/55Zf3ivi45JJLBCB+/etf97v9P//zPwUg/uu//muHbXSzqxfZsGHDhOM4ffYbOnSoKC8v71O+I/Ex0HG1q3G6t8exEHt3LO/us2BP+rq3xEc4HBYdHR27rLs77b733nuiqKhIlJeXi9WrV/fatif3Yke88cYbAhCnnnpqv9snTJggAPG3v/1tl21JJAPlgJ12ef311wE4+eSTd1qv2xt7zpw5fbaNHTuWIUOGsGHDBuLx+E49zD9KO5MnTyYQCPTZ77XXXgNgwYIFLFq0qM/2lpYWXNdl9erVTJs2racPs2bN6lP36KOPRtO0HfZ/R0ydOpVYLNanfPbs2Tz00EMsXbqUiy66CABd17nkkku48cYb+etf/8p5550HwO9+9zuy2SyXXnrpbvtS9MdAr/HSpUsB/9w/zJFHHomuH7DDt1+mTJnS7z1saGjoGSu7w0DHVTc7Gqe72r4nx9ubY3l3nwV72tePyvnnn88111zDxIkTOffcc5k1axYzZ86ksrJywG01NTXxmc98hnw+z9///nfGjBnTa/vePL8777wTYIcO1d0RXtLZVDIYHLBP7+450Pr6+p3W63Ze25EfQm1tLZs3b6arq2un4uOjtFNTU9PvPu3t7QD87Gc/2+k5pFKpXn3oz7lL13UqKip22k5/7MhRrLvPH3b+u/TSS7n55pu59957e8THfffdh2mafPnLXx7w8T/IQK/xzq6Hpmm7Ff66K7rv5Y6cILvLS0pKPvKxdtSGrut4nrfb7Qx0XHWzo3G6q+17cry9OZZ391kAe35tPgpXX301FRUV3H333dxxxx384he/QFEUZs2axc9+9jOmT5++W+2k02lOPfVUGhsb+f3vf9+v6N6b5zd//nzKy8s54ogj+t2+fv16qqqqduu6SyQD5YCNdul+UG/dunWn9bpfHs3Nzf1u747M2FVc/UdpZ0fWgA++2IQ/xdXvp/vXYXf97du392nLcRza2tp2eg790V9b8K/z/PD51NfXc9ppp7Fw4UJWrlzZ42j6uc99bo9+yX2QgV7jbmfH/s7Bdd2eB/FHYdy4cQCsXr263+1r1qwB6OOAuz8Z6LjqZldWq701jj+4z94Yy7v7LNjTvu4NLrzwQl5//XXa29v5+9//zle/+lUWLlzISSedRGtr6y73d12Xc889lyVLlnDTTTfxxS9+cVDPL5fL0dLSwtChQ/u970uWLGHbtm29rCdbtmxBURQef/xxPv3pTxOJRBg1alSP07ZEMhAOWPHRncnxqaee2mm9Qw89FKBXSGA3a9euZcuWLYwYMWKXv1z3VjsfpPscXnrppd2q323eXLBgQZ9tL7/8Mq7r7vaxu1myZAnJZLJPefd5dp/3B+n2zr/33nu57777AJg7d+6Aj/1hBnqNu+u//PLLfeq//vrrOI7zkfvUHWEyf/78PtaHZDLJK6+8QjgcPqAyiw50XO2P4+3Nsby7z4IP1t1X1+bDlJSUcMopp/DrX/+aiy++mI6ODhYuXLjL/ebNm8eTTz7JV77yFf7zP/9zh/X21vlpmoamabS0tPS7/eabbwZ6T7m88847ANx6661ce+21vPPOO0yaNImrr776I/VF8m/KIPuU7DEf9HBfvnx5n+3dHu7dXvXDhw8XLS0tPdsdxxGnn366AMRNN93Ua9/+nL72VjsfZMWKFcIwDDFmzBixatWqPtvz+bxYuHBhz9/dTpT7KtqluLi4V7RLN57nibFjx4rS0lIRCoXEuHHjduuYHz72h6/LQK/xiy++2BPt0tXV1VOez+fFscceu1ccToUQ4sQTTxSAuOOOO3qVX3XVVQIQc+fO3Y2z3nPnxR05lu6ofKDjalfH39vjWIi9O5Z391mwJ33dGw6nzz//fL+O2N0RXP/4xz922u5tt90mAHHCCScIy7J2eqw9uRc7Yvz48f06lP7kJz/peXY8+uijPeU33XSTKCoq6hWp9tvf/lbU19fv1vEkkg9ywPp8TJw4kbvvvpuvf/3rHHrooZx++umMGTOG9vZ2Fi1aRFFRES+88AIzZszgO9/5Dv/93//NpEmTOOuss4hEIjz11FMsW7aMo48+mm9/+9u7PN7eaueDjB8/ngceeICvfOUrHHTQQXz6059m7Nix2LbN5s2beemll6isrOxJAT5z5kyuvPJK7rzzzp4+dOdGKC0t3aP8Gsceeyz3338/b7zxBjNnzuzJ8+F5Hvfee2+vPA/dKIrC17/+9Z5fNJdeeumAj9sfA73Gs2bN4tJLL+W+++7joIMO4vOf/zyGYfDEE09QXFxMXV1dn9wcjz32GI899hjwr+md1157rSdRU0VFBT//+c977XP33XczY8YMvvnNb/Lcc88xYcIE3njjDV544QXGjh3b8yvwQGGg42p/HG9vjuXdfRbsj2sD8LnPfY5oNMqRRx7J8OHDEULw0ksvsWjRIqZNm8YJJ5yww32bm5u55pprUBSFSZMm9TvWpkyZwhlnnLHXz++6667joosu4vOf/zznnnsuNTU1vPjii7z33ns0NDTQ2NjYx/Lxmc98ppdv0Nq1axk9evQArpZEUmB/q59d8eqrr4ozzzxTVFZWCsMwRG1trTjppJPEI4880qveww8/LGbOnCmi0agIBAJi4sSJ4qabbhLZbLZPmzv7VbO32vkg7777rrjooovE0KFDhWmaorS0VBx00EHi0ksvFc8991yvup7niTvvvFOMHz9emKYpamtrxWWXXSa6urrEsGHDBmz5uOiii8T7778vTjvtNFFSUiJCoZCYMWOGePrpp3e6f0dHh1BVVQSDQdHW1rZbx+zv2P0xkGvsuq649dZbxbhx4/pcj2g0KiZPntyr/vXXX9/zq62/z46u3+bNm8XFF18sampqhGEYYujQoeJb3/rWboVP7uq897blo5vdHVcf1fIx0ON1s7fGcje7+ywYSF/3huXjV7/6lTjjjDPEiBEjRCgUEqWlpWLKlCnipz/9aZ+Q1w+3+0EL5Y4+/fVhoPdiR/ziF78QI0aMELqui6qqKnHmmWeKxYsX9xv+PWbMmD7Wwc9+9rPiW9/61m4fTyLpRhFCiH0jcyQfJ1588UWOO+44LrjgAn73u9/t7+70Yc2aNYwdO5Zzzz2Xhx9+eH93RyL5RJNOpykqKmLBggW9onAaGhr48Y9/3G8KeIlkZxywDqeS/ct///d/A3DFFVfs1340Nzf3cQTNZDLMmzcP8E3eEolkcHn33XcBfwqom/b2drZs2dKrTCLZXQ5Ynw/Jvue9997jySefZPHixTz11FOceuqpO8wBsK/4xS9+wcMPP8zs2bOpra2lubmZ5557ji1btnDyySdz9tln79f+SST/DrzzzjuMGTOGaDTaU7Z06VIMw2DixIn7sWeSjyty2kXSw4MPPsiXv/xlioqKOOmkk7j77rv3KLHZ3uS5557j5z//OW+//TYdHR3ous7YsWM577zzmDdv3kdeWE4ikUgk+x4pPiQSiUQikexTpM+HRCKRSCSSfYoUHxKJRCKRHKDcfPPNPXlgdoetW7fyhS98gZKSEoqKijj99NNZv379IPdy4BwQ0y6e57Ft2zZisdhHWjVVIpFIJPsXIQTJZLLfJIAfJ3K5HJZl7ZW2TNMkGAwOeL8tW7Ywbtw4FEVh+PDhLFu2bKf1U6kUU6dOJR6Pc80112AYBrfddhtCCN5+++29shjn3uKAiHbZtm0bDQ0N+7sbEolEItlLNDY2MmTIkP3djT0il8tROaKSVPPeWf24pqaGDRs2DFiAXHvttRx55JG4rrtbizHefffdrFmzhjfffJPDDjsMgJNPPplJkybxP//zP/zXf/3XHvV/MDggLB/xeJySkhIaGxv7TfctkUgkko8HiUSChoYGurq6drma+IFKIpGguLiYqzZdRaAo8JHayify3DbsNuLx+IDebwsXLmTOnDksXbqUK6+8kra2tl1aPg4//HAA3nzzzV7lJ510EuvWrWPt2rUDP4FB4oCwfHRPtRQVFUnxIZFIJJ8APglT6IGiAMGPKD66SSQSvdsOBAgE+m/bdV2uvPJKvva1r3HwwQfvVvue5/Huu+/yla98pc+2ww8/nPnz55NMJonFYgPv/CDw8Z2Qk0gkEolkEFHE3vmAn4q+uLi453PLLbfs8Lj33HMPmzZt4sc//vFu97Wjo4N8Pt/voo3dZdu2bRvYBRhEDgjLh0QikUgkBxofFA8fpQ2gj1vBjqwe7e3t/PCHP+QHP/gBlZWVu32cbDa7w3a7fU266xwISPEhkUgkEskgs7tuBd///vcpKyvjyiuvHFD7oVAIgHw+32dbLpfrVedAQIoPiUQikUj6YW9aPnaHNWvWcN999/GLX/yi1xRJLpfDtm02btxIUVERZWVlffYtKysjEAjQ1NTUZ1t3WV1d3cBPYJCQPh8SiUQikfTD3vT52B22bt2K53l885vfZMSIET2fN954g9WrVzNixAhuvPHGfvdVVZWDDz6Yt956q8+2N954g5EjRx4wzqYgLR8SiUQikRwQTJo0if/7v//rU/7973+fZDLJ7bffzqhRowDYvHkzmUyG8ePH99Q766yz+O53v8tbb73F9OnTAVi1ahXPP/8811577b45id3kgMjz0R1TPdA4aIlEIpEcWHwSnufd5/CDlu9+5FDbXCLPj6t+8pGux+zZs/vk+Zg9ezYLFizgg6/wZDLJoYceSjKZ5Nprr8UwDG699VZc1+Xtt98ekAPrYCMtHxKJRCKR9MO+9vn4qMRiMV588UWuuuoqbrrpJjzPY/bs2dx2220HlPAAKT4kEolEIumXA0V8vPjii7tVBjBkyBAeeeSRj37QQUY6nEokEolEItmnSMuHRCKRSCT9cKBYPj6JSPEhkUh2C88TqOrHf70OiWR3keJj8JDiQyKR7JJVT69n5T/WU3doNVO/dBCaLmdsJRLJniOfIBKJZKc4lsv7T6yjY10X61/YTHxLcn93SSLZJ+zrJGP/TkjLh0Qi2SmaoVI1oYxcV46SYUVEKw+c9SEkksFETrsMHlJ8SCSSnaIoCkdcOoVxJ40gVhPBjJj7u0sSieRjjhQfEolkl+imRsWYvotZSSSfZKTlY/CQ4kMikUgkkn6Q4mPwkA6nEolEIpFI9inS8iGRSCQSST9Iy8fgIcWHRCKRSCT9IMXH4CHFh0QikUgk/SDFx+AhfT4kEolEIpHsU6TlQyKRSCSSflDYC5aPvdKTTx5SfEgkEolE0h97Iz26nHbpFzntIpFIJBKJZJ8iLR8SiUQikfSDdDgdPKT4kEgkEomkH6T4GDzktItEIpFIJJJ9irR8SCQSiUTSD9LyMXhI8SGR/BvhpTNkX38HNRomeNjBKKo0fkokO0KKj8FDig+J5N+I5GPPkfjrfNRImLJ5FxKadtD+7pJEcsAixcfgIcWHRPJvhJfJgeUgdAuRt/qt47a2k5u/ACUSJnTKHBTT3GmbbmeC1AtvokbDROccjqLLx4pEItk58ikhkfwbETt9DkoogBqLEJrev9Uj9+SzZB99CiUYQKsoI3D04TttM/7Y8yQefQ41EkSNRYgcNXkwui6R7HOk5WPwkOJDIvk3Qq8qp+SC03ZaRwkFUQwDJWCiBHZu9QBQNBUKH0WTPiSSTw5SfAweUnxIJBIAhG2T/OPfsVauJ3DiLAJTJmBMO8TfJgSK0v8qFUVnzEErL0GNhglNm7gvuyyRSD6mSPEhkXzMEI2NeH95FGIx1HO/gBKN7nIfz3FZ9/RqUutbKa0yqDhsBNFRNQC46QyJh/6P9ILF2OsbMcqLcOMpnEgxRjxLsGk1LHsP5TOnoh13fJ+2taIoRZ85dq+fp0Syv5GWj8FDig+J5GOG98w/Ec+9AIaBGDUS5bjZu9xn+9tNLPvtUuylywgHXeqPG8dBN3wBoyRM6433kHno97jpNEKLIvQxiK0tZP7wD9R8mspgG7qpoDzxOM5B02j848s4ySxBO0lgw0qKP3U4oXPPkI6mkk8cUnwMHvJpIZHsI5zGbdjvvI8+diTG2JF73lBlJUQjEImglJXu1i56UEcLajjCQwGcjIWbt9Etm9yqVaBtQQtb2KEoTu1QvHwGe1MzXiZLqDRL8dhK1LHj6HxzDa3Pvou1vZPqbUsJ5FvJvb+UwPiRaNOn7lZfhOfJ/CISyb85UnxIJPsAYdukfvkQ9rJV6CMaKL7xGtTSkj1qS/3MydAwBMIhGDduh/Xy8SxCQLAkRMVB1Rz2zZl0HlOPnksRbignvq6VZKfL9i6dKkNFDwUwRtWQsxywVdxQDMpraK8qIXLO0SjxFkKPPcDQdStwLA3bVAmkkgQ3x8nccjvqD79PZPKYnfbdffJviH/+E2X6dNTzLkDRtD26BhLJvkBaPgYPKT4kkn2B5yEsG+G4CNtBuN4eN6XoOkw9dKd1OlZu5+1fvoxwBYd8fQaVh9RRO30ItdOHYKdyvP2jx4mv2U6i0wOnnqhXTcRL4a1oRRSFUcpKMYrCiGiE4lNmwqJF5O79BYrIURyOwpDhWIdOI/BmCq+5Fev1JSRu/V+G/OJajNJYv30SmQziqadgy2ZEKglzToD6+j2+DhLJYCPFx+AhxYdEsg9QAgGil3wR6633MCaMQqsoG7RjCSGI//VZAi8uIFEyjI6Vo6k8pK5nu5POk+/M4GZt3LSFIgSWMprQtlXgJjEyjVBRDBs2YmY6CVSB8+pLkM+hKA6WkyeT2QYrEqi4BLIpXBS8zZsRjrPjjgWDKOPGIZIJlBEjoWzwroFEIjmwkeJDItlHGBPGYEzY+bTE3sDbso3o2y9Tk1pHiZEhHDuNfGeaQGkEgGBVESPPPZxV9y2g4d2XKOlcj6MaKI6DH0zrEVHaMFsWYdp5tN8uwzaLcJ0oHhbxXAwrbhFKN+GUVmEWx3C1ciLJ7Yh3l8Hxx/TbL0VVUed+A07+DNTVoYRCg34tJJKPgrR8DB5SfEgknzCUYIBAVTGlE2tJmWVs/P3LbH7kDWqOHUvlUaMJN5RjL3mHmhcfprJ1BSouSaJkg2VoIRP1kAkEtWZ0smiajeIouF6SLfUx8k6E0PYAQc9GBDQwNKyqOsT7W1DaO8j94VHMIw7tFf7rrFmPu7ERffJBaFUVMGbwBZhEsjeQ4mPwkOJDItlLeLZD4sWleJZN8awpaNHwHrWTXL2N5qeWEKovo+6MI1D1gTllqpUVhL91Ce7GRhqf3kT+nUby67aRXb6O+PMVhFJtWE/OJ2x3oeAhULDNKOrYMbTEDZJvdjFevE+pB3i+LSRR5JEuTiKA8nwnsSS0BQ2yRorA+k1E0xkUTcPZ2IgQ0J2OzG1tJ337/bibt2JMO4ToD66SkS6Sjw1SfAweUnxIJHuJ5Kvv0Xz/3/DyDl4mR8XZcwbcRtPC1bx33R/wkilKxtcSHVNHyeThO93H6UqSXLqWZFseJxSj9qjhmJUVeMkslUcoOM+9gNq2lkhzHGWlgbAsInYWEHQSg0CI4LmfwzjlU2y46kGGpJcCHp6q43oKCgqKpaI7HorqEcTCi4AStHHzLng6OgaK56Im45BOQyyKcBzEa6/D5k0IG0QyBUI+iSUSiRQfEsneQwgQoCD2+B278bG3ySfyiK4MQlEwiv9lPRFCkHryBZJ/egp1aD3h884gl1fJPPMSHc8tpWtLivSwCSRWTkR7ZSHZ99YRqC1G3bKZULqVAFksoLPSIZBWiXaaqIDudZB85iGMl55n2vb1BEgBCornoeGhoFDRJRBOBCPoUZSycHQwgwooBmZWR9dyKLqKl+wi98v/R+BrX4KVKxC//wPBTBfuoVMxvnJeT2ittWU7qCpmXeVHvuwSyWAhLR+DhxQfEsleIjbjYLy8jZe3KT5u9xJudSM6O8E0KZ1YS2ZrJ4YhGDvvU0SGV/XU8do7STz0f2ReXoqbs2n886vk60dSs/YVAnmVoBMi6sVRFraQXL4JkhmcRBolaWGg46LROK6LtjobPaMzekkxZZksGw9KEi/1KO5qp1a46OBHr6CjIAAFDUFxykZLCdA1dFehdFuQ5sgotGAChW2owoJ1K8nfdR/ugpcJloURK1ehjhiOPvMw1HGjcNq7yK3eTNsDj4OiUvWNzxM+dPzevRESyV5Cio/BQ4oPiWQvoZoGpScdMeD9xGuvwUO/hViUsZddTs2xYwlVxQiU/MvqYW9tRlg2WmU5wrL9MNlN26hsWU/Y7iToCYJaiGB7I9rLb9Nu1NAaHYooKkUk87i2wEIna6YQioXQPYTugO6Qi3g4OmTDAktX0CyBjUle0QiqHppwQUBAy+AJDcUxcNGxMQllE4i6ErxsM4rnIlwgk0VZvxaoRwkGIRLG+/U95P/nVuL1k3CMGFZLEkXXsDY1S/EhkfwbIsWHRLKfyT33MvbCJajhAKHjP0XJp0/s2eY6HktufALx6GOUDisiMmsauboR5Ddsw9Gj5HWNqBfHtV2wcujZJCouMRKkgw7tm4uIuXFCZHFRqF5dRCQlKE1bDEu1g4DqTRpt1S412z2wTDLo5DHRtRyuJvCEiuHZoIGKh+UZeMJFVXMoRU3Y8RZcSwFMPKGjlpch6utwtm1HHTEMLdGOveg1sC0CjU3YU08iNLoetbyU8PQJ++/CSyS7QGEvWD72Sk8+eUjxIZHsJ4TrYjV3sLlZx0zo5OM69uIsB33KQ9X8iJDOxiRbHl9M7YZNpDdbZJauJGGHyYhScpFq1FMOQ317Idb76whlO1EQqAgMHJRcBh2DcqWNCqUVF42ORDlViQDlWhxVcUEVlFgKoXZBJAsYCsJWMchjYKFiFx6eAgU/+EUNW2gCuooU2qoUNE8Q26wQTinYpo6j58ktX40SCmFEywjrGVxh4WkumpckPONQyr7+BZRIGEWRj2bJAcxemHZBTrv0ixQfkk8cQgjE2nWgKCijRg7aC064Lp1PvoK1uZnik44kNHbogPrY/MA/6HpuMe3vbKErO4IurRzjtS7KFm+j/vAhAMS3pWnbnKUoAyYZ3LyH7iQxlRAkVJyly2hLBYloJugatqPjoZAjQI4gIbIUKQkMxUYXNiElgysUEAqqIrANyBYJ8jo0NoDqOFRvUahvVDFcC9soCA4bNAGuCq4OCHAMAarAU8AKCtwMKEKgbd+CsAOQTiIWLcE+8iBEeTmK58Kkg8m//AaJPzxE+MvnYlwxVwoQieTfECk+JJ84vFdfx/71g6AqGF//Gtrh0wflONlVm+n487M4XSmc9jhDbrgEIQQIsctcFm4qS2rJanKbWxDt7aiOQUjNIaIhUk1J2t7dSqzCJJ+ycMNR1ifHMkpZTkmoE9wIal4hlI8TXvoKAZElj45OGheVPCYtVBAhg0aevAgQIIeKR1DkUFBwPANNOKi2wMxDOgS5EKiOoKPGYkQjeDpkI+ABqguhHHgauIW0I7EUODp4KggF0jEIZzyEqxZ+LQpoa8NevRVl5qfQiwIk9DqCD/4WLZ8k/4tWtKMPQ50yVQoQyQGJdDgdPKT4kHziEE3NiNY2FEVBNDXv9n5d722m8dFFhBvKGX7+TLSAsdP6WiyMGgujZnLoZUV4uTxt9z9Gfu0WSs86nujRU/rs49kO7//8H7QsXEHMzBMeUonYmkDXVSJFAUL1Bu/9aiElW5ZTVKJgDxtDdGIDYbWZIdZqVD1NVqskla1BTyaJOCk0HILkMAtTJAoeNbQQIoeF7lsphIGCQAPUQiyLIhRUV1DeCuEEOBrkwlDWAS01vrVY6GCZft9zOQhlPnAuKthByJtgOKC5vhjRbA8bE03x8Cwbe+UG8k1Zio45mEjyPTw7h1AEIt1K7rvXYB4yDf3ir6AcdNBu3yuJZF8gxcfgIcWH5BOHOuNItDXrQFXRjjxst/drfGwRrc+9i6JAbGwNVUfvPAoj0FBN3TXnYTW1E54ylvzaRlIvv42bytD1xMI+4iMbz9P60grW3v8CXlMLGUNQ8/mjqPz6ZFp++wxkO+n8zePEEzol7kaSePD6CmrMANXuFoKxBJ7qErA68LqStCiVhOkgQgZwMXBQESio6NgEyRFG4KGgInBRcdBRcAngoCMQnopjKag6DFvvomiwdhSsOMgXE0M3QTAHqgBbB1MDVQHhQioKyUIW9UwYiuO+BUR4KugajqaAbaHaaYJtm+G5VvQh1bhjR5G3LLSuRrwlS3G2NKMJDX56S08eEIlE8slGig/JJw61rhbzumsHtI/neuS7suQ3bkPTVeKvvt+v+Eg1JXCyNsUjylAUheCYoQTHFHw9aiswG2qwmtoITRrda78tS7bz5v3vIpq3YygQsrvQPQ/7nZWEPnc0WlEEe3sbwXiOKg9K6CBAniI3QVEhgsVKqFgBlbRdhuHkKaUZCxMdmyhWIScHBadTt8cS4iEAFRUPEOh4eKpHxhQoQpA2VVrrBEKDaBIyEbBNcF3IByEW98vSZZDIQ802UDUQGqh+k5gWOAaYWf9IppfCCjhgumg5HcUGEavGU1XMk+YgKmqwfn03Wsd2FCMMRUUgp14kBxjS8jF4SPEhkQArHlvFxuUZAkqASF0MLdD3q9G+soUlty/EyTocdOE0hs7pvUCaXl5Czfe+gtPWRWB4ba9tze+10r4+jqqYTPj0NMSzXZDLoUQjPHHPNoJrNYakHXTdo9jyhYeCR4gsJhYAeTuMZYdwCVBDMxouNgYhsqi4eKj4USkeEbL4ssO3dqi6jacLdNsFTyUXEriG/2C0gh624ftyaEGo3eb/37AhlgDN80WIZYBtQEd5wRriQmknKK7/t1ABBRRVIDQHRXURikDRXXAUcjnINSZQF60jOm82nHAmbqqL4PFHoZz8Kbnmi+SAQ4qPwUOKD4kEaFvVTlaN4tWPZOicodSeNbNPnWRjF6mtCYTj0rW+vZf4EJ6Ha3voJTH0kliffeumVNH41nb0gMb4yyfjzmlg4x/fYP2SDpTGZym2thBTOzCFhUmOIFk0POLEoBA+myeAiqCUBAoe4UIdBxVPhUzUwxE6ZbkMnmb5Phu2Rk4YKBEHoYJmeARzhZXfFN9vQxVgBfyPaftCYugGUFXQs75fh+r59SkIEVeHSAqCWV+EoIJm+1WE7qB4oDoqqAq6pWIJgdeZwEPFe3UxOSVA1U3fIjBpDGo0Mjg3VSL5iEjxMXhI8SGRAKNPGkW6JYNHBeVnTCZUX96nTtWh9dQdORQrZTHk2FHYWRsA4Xos/eWrJBq7GP+FyTQcOxK7rQtFU9FLiwCom1zFKbccg6opGCGD5vRE1mx7l3xjJxOstdSxDdOzSBDDwCZAvmDDMNnEMCygik7C5AqleSJkUBFYaKRDKoRtVKHhqI4vCAR4qosw06RjgALRhJ+vw3BBxXcQzQf9KBbwBYjm+b4bioCcCXbAj3iJJPxwW/xIXbSCxSMX8pe1iaYAFT8xmQGeo6DlFTw0XFTwHAQ6lg3e8nWknnud0JFTel1jYVlkn3gWrytB6OTZaHU1g3K/JRLJ/kWKD4kEqJ9Wy7b3O1n2+Hpe+dW7HHftNKrGlQFgJzJYrXFCw6o4/LrjAWhf18VT33sZBIw5tprmt7bgZG02/nMNJWGL7fc/gVAU0uVDEbrJ6C8diVpSTLolRWbtNra9tA7RuBXNyaPi4aChqAEyRFHVTkwtieIpWHYpAbIIAlgYFJEkSA4FFw0XCs6keCqKp/jGCU8D4fnRKOa/LBWq51smVNePYjHzft4O0/F9NlQPImn//5bpWzLyRYVwWq1g4bD8kFvdgeJO3yqSCftCJZCDcFbB0/38IcJ0Ea5AtQXCdvEcDUuPYEdK0aJR9Ia6PvfBWvwemT89gcjmEJZN7Btf2mdjQCL5MNLyMXhI8SGRFEi35XDyLpnOPNmuPAB2V4r1P32EbGMbFcdPZsiX/dTnTe+20rLST09eO6mMkpFlpLenAHht3h+JtG5CMzXati8nrwbZ+swyOkpHYycyxOx2SMTxOjrxjADbrWpiIkFKBNhcMYXJiX/gKCq65iCwidmCKDmcD/iAqHiF9WbBQkdkg2iuP2Fj2lk0NV1QFaA5oKm+D4dmQ9MQyAegpAt02/9UbfevgWH79bstG7bpCxSh4E+lFERGKAO6C57r/yuEX1+1fadRVxd4qj+9oyoemuKAquDW1hOadTjFxx1OyQWn9rkHSiSMEg6B66IWRQf9nkskO0OKj8FDig+JpMCk00cBEK0MUT/FX+o939xJdlMLTjxD8r2NCCGwGrcT69xMZbWKF45ROypMaEQ97S++w4p7H8HrjGPrgsiEBizDwk5aZNa2sTWnIHSdWH45Nbn1eMJ3sPTQULGpF9upb21E1XMEjBxdlTaOlkfvCGLGw8SwC0vc+08zB60wNaOjqILNlTqq6lC+LY/peng5PyLFsCCa8KdZLAPSEd/XI14ExV2QN3yLiG77VhLFhXDGFyJlnb7YsAJ+HhDDAc+AXAR0AZEklPonQSQJCIGrCAzLFyqK56+Qq7g6umeR39aO1rgdpyNO/MWlqKZO7KhJPSG2xsHjiX3rK3iJFOZhk/fp/ZdIJPsOKT4kkgIVI4uZfdXUXmV6LEigOIji2FSeejheJkfz7X8iv3ozk0Y0EDxqCvEH/0rze+sRjkekvRHL1XC0CMUnTCP06hKslgzR3PuMyaRY601ieHYlYVJESCNQyBMAXILkEQhMxyIb0LACedA8RHGaaMLDFTpuYeUW8N1Qu60fHbVZWg528BQo0gXRDX4EC8IXFa4Jlub/Hcj5IqOjFNaP9P+u2wZagJ5VsFwFijzfpyMd9qdeAlk/66llQMDzy4TmT9UohSkdT/WjaFT8aRw1r+EpfpYyFxXVtXHjSTLL1tPx2hqUQiK3oqN9oaEoCuahkwb7Vksku4W0fAweUnxIJDuh9U8v4GxpJlBeRHhIOU4iSf7t97HaU+j1VeRXrMfa3ombzKBGQxjFYYQNZm0FbU8tJhRvplprIZrdhKM5hK1MIfjVwUNFw0PHpZMiAlgEyOMSRM1ZBLMqbsAjmhRouLho2Ka/noqW17GFgYuGgYOmuqiKi1D9kFehgxUppEIvTJd0r9BZ0wSJItgyBFIxyEShKO1Hr6ien9NDifiCxcxDa7UfYqs6vq+Hp/n+HiV5v4xC236oi//x8H1PFFVDUVxUFPJeEDsQw4xFUSJh3LYOVMDL2/vt/kokO0OKj8FDig+J5AMIIbAXvoazbhPm0YcjHAfPckk0xon/z/0E3l1EcNVWUMPYRXOoOWIsrFiB96mpmJPHsfbvq7C2daGMHEHm/Y0EO1aSUvIYmo7nKiieIEMQA5UOSjDw8BAUm9sJ651olorjBLHcCLGtgoCeQXMgK0LkDVCjWRRFoKkgMkGyhPDIU70tg9AFjurn6bA13w+jG9X3TcXM+/8P5v2MpPmAP71i5n3rRV4HRwUNyIZ9sdGdSEz1/ERi4AscPQ+JYj+xWDir9DyoDUvgaSqOUPAUBU8PIoaPIOM1INpSWJua0StLKT9lBnptJbEZB++HOy2RSPYnMquPRPIBvM1byD70Z/J/eYLsAw9Tdd4JxIdMpLkzQNfTr2Ov2YCRS4JhgKYSeuVZau1GhlTl2bQyx/rFcbZt18h2ZikuAWJRrMoGtoYnsTY0lQ5RgYdGtrAai0aeWnULZWY7hpZHM/OY5NHwsESQrF3CdlFLQgmj6RaK4vX8HHNQ0dUsajCFojlUtEJJAuwQWCHfKmFkfWFh2BDI+5EsKH6q9KpmGL0Ghq33p14QgFaIiBG+U6npQP1mf1qmZqs/xRLKQiwJTfWwfhSsHwvpkMBVFYQKiqegCuEnOCupIH3caejlFZTlWwhbXYhtzbS/vo54+SgqPjcLd9MW4nf8hvRj8xGuuz9vv0TSi25B/VE/A2H58uWcffbZjBw5knA4TEVFBcceeyxPPPHEbu2/ePFiTj31VGpqaohGoxxyyCHccccduAfYd0taPiT/VgghcPIuRnAHQz8QAF0HTUWJhAnUV2KNO5i2zTrljUtRvBIoMuD4Exjy+SMQv3oTHBuat2NvCxJObcdFp3rxYsJOF8IDy6ghaQVIOgFsJ0MKnTA5hiqbqKEZBY+c57+4t9ZBPOJQ3ZilvAM8VALkCZlxVC2P5/iiwsx6QIJcxMIJCNL4VglXBeGBlvPXYDHS/hRMS7XvoxHM+Q6nzUP8HB6e5qdPH7nWdyrNBf1ol2DaFy3BLBg531KSD0F5u2/xKE7C6jH+/rYJVhBCeXAUFU+ouJ6GUDXalUrir27ByK8hoKtYWgnpUCmZQCmdrzcz7hxI/+Fx8kuWoxbHMMaOwJw4pv97I5HsY/bHtMumTZtIJpNcdNFF1NXVkclk+Otf/8ppp53Gvffey6WXXrrDfRcvXsyMGTMYM2YM//Ef/0E4HOapp57iW9/6FuvWreP222//aCezF5HiQ/Jvg+d6LH3gbbYtbWLEccOZcEQUb/GbqEOGok4/HEVRsFq6SFkGWkkNkbNOQ1EUpp4zhlCxyRbTpjXZSaa4mqqR9bhL2hk+aw7aqvdp7jCw12ygpMLAc1yM1hR6Lo6uejiiEiOeoMKxyWOSIEqOACMKa6+oAsgG2F5qsnx8GivikCj1qHpRR0GlSE8gdP9Xi+aAYoOmOCia05OpVCmEuopCFtKumC8MIprKlpEeXSW+5SOU9v08OkohG4Kg5YfKdlb4Fg3T9nOC2AFIGYU1W6KFXB/+oXBN6CiDaNovCKUhFO+Ow1GwiGB7Bnk1TNYpwrYhJwKYkQjm8ccjmlWyRaNoOHIIAGpFGYquo8QiMrxW8m/PKaecwimnnNKr7IorrmDatGnceuutOxUf9957LwALFy6krMzPUzR37lxmzZrFgw8+KMWHRLI/SDWn2PzKZtKtGdY/u56Ry16H5W+jVNcSqKlFaRhK+qUl5FsSKIaO1dyJOQHKhhUxc+7BNB1Wzuqn1tLy/Fash56nU81in3kwoYpJbPztP9C62ggFddRDJ5EXXdQ0rsfEJdLxPhm7GgWPEpKU0UIeky5iRMhgYbJJDMG0EniOjfDyaJaGhYmh5MF0e0RGaxm0Vvkv/lHrfDHi6P60ipHz/TW8gjhwDNg0zGP9KF+UDNlaSCym+/4cnga254fiqoXcHkZBzziGPwuTC/qH746acUw/TNfVfGFSvUkjnDDQUPAUyIkgthImp4cwJk0gUDuKVMqkIzOS0kMaKDp8HOPHj0KMG0e02hca5slzaF+6GSECRLKufChJDhgOFIdTTdNoaGhg0aJFO62XSCQIBoOUlJT0Kq+trWXVqlUfvSN7Efk9l/zbEK4IUz62HM8TVE2qQk0aeAr+/ERhRdXAhJHoS1agRcIYw3tn4Kw5tJZtr21AbN2GkoxDTCe5pYv0m8sJtm2h3GpC83Ry7cXQsoFi0YXmOAink7FqK3lCmJ5DkDxJYuSEQZYweUwUFOxUMbWLdNyiDDXNNlqgA/AjQRR8B9L2Sj+jqG1CV5Gfc8NV/QdcyNUwbZeuCCSLfIGQKPLzcwjV3z+WgnDWt3rYpu/rYViQiYEe9/8OZPxpFNWFYAoUvZBcLAXZmB/5AvhOqIaLEhToOR1PqKSJkFWKydaPpvzMMxl2ziwq3l2Hu34D+WdeIvneO5jjRlJxyzW4aZ381laa/vwSnStaMIrDRF5fQXjMkH02JiSSnbE3xUcikehVHggECAQCO9wvnU6TzWaJx+P87W9/46mnnuKcc87Z6bFmz57Nn/70J+bOncvVV1/dM+3y6KOP8rOf/eyjncheRooPySeCbFuSzX9/j3BNMXVzxqMZWp86ekDnqKuPIr09RawuhtI6BHvsOJTaBixHx8xbRI87jMDIepRwEKPKX9/FzjnoAY3tS7ay6Z5niLZ14gQjqA2VdCxvpqhtM6VKgoDIgmOgr15OSW4LaiEFuqMqxNQUAT8XKbrn4qAQQMfAJkgOD7AJUNLuoLdDpdkGQRuBP80iHAVPEUQTvtXCsHwLhFUQAo4OqnBJFUFbtW/FEIqfCl0Rfo6OEWuhOOVbM4Y2+gJE4OfucHXf2hFJ+fuUtYFrFFaqtUDNKxiKQM0U6jrgBgu5PUwP8gJFCMKkMTwXfcsK3HSO5vv/jv33+WiNG1FzGWw9iHA97LYumu9+gq43VpLZnkRkLfTSGMGRtX3um0Syv9ib4qOhoaFX+fXXX88NN9yww/2uueaanmkUVVU588wzueuuu3Z6rEsuuYTly5dz7733cv/99wO+1eSuu+7i61//+p6fxCAgxYfkY4+dzvPyZQ+z/fUNhGuKOCpsUntM/06LRlCnZFgJAPmmzWTeWkBq1XYS3kiiR02l4XOHoT3wGwTgfOlCVm0K8v7/rSRcHaNr+VbExhbI51FKTbIJi+q2zeipToJuGkUBYdtYnouOQx6TOFFc1cM005iWiy4cFBQUVFQ8dGwMXHRsbEwEAlW10bFxCvkzhFdYwUWBsg4X0/GzkKZivgDRBISTvoWjs9RPEKa6hTVcor5zqOb4WUkj6cKUiQ265YfkWiH/b6H4wsLTwQkWfFEUUFQgAI4opGp3QHd18pqL0ASqrSCEgoeCiYNJGsPzyAU1nI4M5LKouQyK6yBMDXXoEJxkjtyGJtxEBvIW5oSRVH3xWIpnHLSPRo1Esm9pbGykqKio5++dWT0A5s2bx1lnncW2bdv485//jOu6WJa10300TWPUqFGcdNJJnH322QSDQR5++GGuvPJKampqOOOMM/bGqewVpPiQfOzJNMVJb+vCzdvkOtJ4jrdb+1mLX8PeuB5r+VqymS4yTRlqSi3Upe9gbWomtaSRbdnRFG/YgOdCuu4IjEgJhpakrsqhxlxB0u5Ac9IEnBSup2ChkXV0WqlEwyWtmcSrMpQELKIJQW27iobwLQ5AQPHDahXhv+mVQM5XDa7vn+EBrqWhmKArHq7nR56kC9MmCiAcP1+HK2DjcEgW+2u11G32xUk64vtraK4fhqu4/kxTNupbQaAQ1WIXQnELicIU189givAtIB4qwlPAMv2VcVMaqB5CKDgaOK6BQPWFkm6gqoKqr5zKxqZORDyJKly02hpKvnY2kcMmUHTUOvTSGFp9DZHJo6k8YTJKYfpLIjkQ2JuWj6Kiol7iY1eMHz+e8ePHA3DhhRdy4okn8tnPfpY33nhjh9+Tn/zkJ9x+++2sWbOGaNT3qfrCF77Acccdx+WXX86pp56Krh8Yr/0DoxcSyUcg2lDKsM8ewrYXV1N1xEhqjh69W/uZh0zHWrkcZ3knVqYIz1Kwq+sxikuxnO3kc4KS5vdx25pQEQQrY7xfdwhBM8k48Qqx+FYy6e2QtwiRIUOIDL6HeZYgJjZhI4EW6ATVxQpqxClCw8NFI0Sm0BOBqjioioqiuv7TSgVbgVUTwNFdRqxRKE75IsKwIBvwq4mCZSIThc4GWD/GFyLpiF+vqxQQEE75AsJVfafSUNbPZOoV/EUMB2KdfvtKIWLGEb5/iaMXxIml4Hl+YjMTFxUPhIcazIHq4TiCLq2BiOHgagbG2lWk3mmgKR6h3CjBLIuhn3oyjeowxqBT/83Pg+uiHCAPQ4nkwxwoDqcAZ511FnPnzmX16tWMGzeu3zp33303c+bM6REe3Zx22mlcffXVbNy4kdGjd+/5ONjIb73kY48WMJjy7ROZdOUcjLC52/sFjjwW6kbQWf8Gnf/vNbIUs2xbGdN/chOZXzxMbuUWQvWC7LZmAKJBm+pSh/J17+E2LcPKdaIKBR2nZ7E3Dw0bk3WMYBpLKc+nyCQdvKCNh0LrMDA7o5QmfEuHi+avUCtUTGHhOAqepuAoHluHQnOt//CKxQWxLOTCvqNpNvgvy4gT8nN5OFphjZXCdE1LNaSKwDL9aZVcIXeHovnZBYvifn3DgdIOf5rFCYLm+avV2mHIFBXCdxWBkTYQjo5AJYeOgsBRVMKKg8CjQy0loxQTCDsYxSH0TRtw/vxnhqxrRnfiWF6IN1YW4axejvAEk04d4edUkUgkuySbzQIQj8d3WGf79u39JhOzbd9x3XGcwencHiC/+ZJBx845CE9gho1dV95DFFXtIzyyqzaRXbWZ8MGjCI6o67NP/LXlNP/unzibtlKS2UY43Yr1uz+SLToahg4lv2wbXa0W6UgDhi7Qw5XUrHyRYdteJeQlEGi0UkmQPAoCCxMVmxI6KaGTGEmCwiLa5mGbgpWHOGQiNkaZRdE7RX46cxEEFAxsfzE2WyHjQara983QHX+6JJKBeAlsr4F4cbcg8YWBp/tTJCVdcNA7fr3KNt8Z1Qr4sziRlB/J4qmQD4PrQHGHn+VUE75AyYcKfh+qn9lU92dV8Ao+JMLV8dCgsCaNgYPq6WTsGKrqIpwgQvNIqxHKJ45ByWcxiwKUDolirWxB5FJoiU6ckppBGwcSyd6kez2kj9rGQGhpaaGqqqpXmW3b/Pa3vyUUCjFx4kQAmpqaiMfjjBo1CsPwn61jx47ln//8J+3t7ZSX+w7zruvy5z//mVgsxqhRoz7ayexFpPiQ7BLR0YGz8FWU0hK0Y2agqLuflb9zQydv/PItXNtj+iWHUj2pasd1l21hyxNLiDSUM/ycI1CN/oent7kR68GHwdQxv3wBanXfNvMtHay6+BbspjaKj5vK6HuuJb6hg6U/fw7DzjDpwkOJv7GS+KLVBDatpjigQzxBUddislf9A6WiFrvDIJcwWCdGo5sKVdtyVFt5VM+3dGTRKFa7MBSbnBsijEsRScKk0fHIoaPhqwdV+NMUKhDyLExhY5sujunh5nSijgeFdV4yJQ7xEv+hNXQDlMT9dObx0sJ6LYVPPuBbKzwVjIKbS3Ur1LT5ogUB1c1+PQVwAr5Q6Z7Z0T1fbCRivgXEVXyxoeVBz2sYjkux54fWGjkNR1XIeyYCFQMbBYGBS9aOYGOgKhpmREEb1kDgC6cTMEGtrqTzrbWkHnySXKiUcYeXEDlmImPmNPS5ZxLJgcb+mHaZO3cuiUSCY489lvr6epqbm/n973/PypUr+Z//+Z+eKZXrrruOhx56iA0bNjB8+HAAvvvd73LBBRdwxBFHcOmllxIKhXj44YdZvHgxN910U49IORCQ4kOyS+w//x/OP+ajxKIoRTG0Qyfv9r7bl7XSuqIdz/Vofmf7TsXH5r8uov2tDXRGGik9pIHSQ4b2W895bRHO64tQNBX3oAmonz25T52W//0n9tvvY7vQ+c/FNP/hOdb/YxW559+iKL2B5tefRMSKyazpxPUUikrDBAwHfVsTwvJQ2Y4aGoGHStoNUZ1pQl/bRlbLkVFNdC0NwiNCClXxV53NuxEMrIIlBITisrUBMkUOJZ3QsBnSUShuVUB1iFfm8EwXLwvR7QJHA9fTSJf41g2hQEmn72+RD/gCoazFz1TabaGwggW/j4JTqKsXpkmEv5+mQi7qr+Wi4Ee4BCzf5yOYgeY6SEX8dsw8xFo1ylpDWCjo5DBsD00IHHR/4TrH6PFZUQAHjTwmoOEKlbRlEJ58ENGxdWiTJuIJhXBxJe0bkgRcl2Ffmk7soGG7PX4kkn83zjnnHP7f//t//OpXv6K9vZ1YLMa0adP46U9/ymmnnbbTfc8//3wqKiq45ZZb+NnPfkYikWDcuHHcc889zJ07dx+dwe4hxYdkUKmcUEHZ6FJc26PqoMqd1g3Xl9K1bAuB8ihmWZR0Yztbn1yKWR6l4YzpaKY/XNX6WtTqStA01PreeSEyKzeRXdMIz71ATMSx0YiLSlr/shBas2hWDs3JYzc2YRlxXEpJl9WjHHwQ+fZtmG3bAIeubBAnl0SNVnNU5ytUu9uw0XBcjRKzHVPNowsbz1NQhIKNhoWGjv9CVhEkAyZdpRaOoWKXw8hNgkgWlBwINY+uWr61QQMR8DOOqp6HXsg22u0gahu+T4cCxMv9ENviuD/NYpvQVgHbq31RUtaOn/I843/sQoIxRfjWkGAOylv9KRih+EYU1/CPoQjIFnsEt9m4GDgYaMLCc1UsAnS6ZZgoaDjYmGRRC0HCAVz8KZlwvovIY3/A2b6E/IxjWNlSjmfZjDz/eIrH16JHQ4MwyiSSQWIvWD4Y4P7nnnsu55577i7rPfjggzz44IN9yk866SROOumkgR10PyDFh2SXGGefgVJTjVJSjDp5YMufl48u44SbZuO5glBJcKd1R14wg7IpQwlWFREZUsaqO59h2/z30IIm0aEVVBzpe2lrM48kUFONomvYpVUsu+NFrM40dYdWk/r7i1ibmihq3U54TD2O0FGHDkek49TMPoTVVWPYvuRNgsk2RKgIRVHxyipoXrKNsW2vEEx3IBQVVwmjOnFCGY9Srx3Dlx5+cjBh9SQQS7pFZAnheipBLFRULIK+VcAyMFICL2oTSXmojkBxNXRHQRUepZ0KVkAQLqyRIvD/LWmDtjLfudQyfQGhC8ibfmr1vAm5gC8iwik/vDYbgnzQj3AJZ31R0u0vYhXCa0s7wHD9PB14fqaR6iYPMydIFftWk7JOgabaqJ6H55iono4QBjmKQQRJoSPIYaOSIIaJP9+TIkqxkiKsZAjkPURXnK6nX6c5M5ZA1CS+sony6SMHOvQkkv3KgRTt8klDig/JLlHKyzHOOHWP9w/Edp5MpxstaPZ6QRklETRTx4gFMYr+9YtZURS00X691udXseW5VVjrNtP5uE2xmiJYHsEbM46yg2oxDplA4tF/4qxrx0xsYeq8s3nnZ1kyi99BGCHyZpRck4NIZVCy6UJGL5Uipw0VQcZLEaeYAFm6s4cIV0URfnyLisDTHaJOHtMT5DEKnh2CIi9L2QabfNhB8/zaqqPiqeBpgkBWI5QCB2iv9MhFPcIZP7S1e8E5KwjxMt9SoTr+1Itd8KttrfCThumO76vRnadDK+QIUT0/cqW8Bf8XHL4IwdWx0FGAYD5P3XZwWv3IGaFDJiZQbIGSAcVTCOKSw8HCxSNAkhgeCgFcVAQ5AuQx8VDIEyAdieFUjGBVUznJljx6cRhd9Whf8B4lh41BC+9chEokkk8+UnxIDliGnnU40RGVmCVhiib0jVYBCFUXESoLobzXQV16LcGojjbtDIJHH0b0hEPwGrei/fVp3Eya/HOvoLd1UL96PTk7h5Lz2Fp2EGY2h6PrrAlPRssuRcPBIO3n9iBLgiCalsMQHnkvhO0FC4nCBG7UX3fedgSBThVFaGQJYQQSGKqFYXmYGYFlUjDhCvJBgaf5VhAtrSKCDplSj0wINowqpET3CgnEKDiaKmAWpky6V7HtKvctIqWd/nRKIA9FiYL46E6E6GsprCA9icNUV0Up+OALRQHFFyl4KrmQh6uCZ6h4apCYl8NBL8gMgYLARkOg4SoQElkEKiV0EaMLyzNZFa8kn5tEtjiIEnYpP6yKjn++RWsiQ+y4aahTD6VmXDHR8r4ixE7lUDQVPbT7IdMSyWAhLR+DhxQfkgMG4Tgkn38LN5UhNucw9JIYVUf3n0ynm/KDapn2g5Npy75D5IWNqMJk00vvsvGFBKN+/SQ1QzTM+lrUphZsoWO89Qq1qXbUbIK8G6FkeytZESDoZWh1S4gTpIgkBgouoCAYom0lqGVBQBqB5QXQPIGKg2s6CFXg6gJPU3AdDU/z0HU/94WtCwKWb4kAgYfXvUAtAoGuW1i6QPFgyxDoqPBFxJDN/nosnuqHwIK/9kowB2bWz07anSU1lvJ9QIIZP/upa/hRMWohmZgVAItuHxIFCv4ZGl4h/EWAp+B5GpplIUzAUsl7BmkUHHRARQWC2NgEaKOCCFmEqpFXQzSItcSUOI4w0PIbURY/Qseo6SSmn0DdEZU0vb8cO2Oz7PF1bH1WZ8ghpXz2B4eiG/+KnOp6bzNr73se1dQZe8WJREfs2DlZItkXSPExeEjxIdkt3HQWRddQA4P3izT95nLaHngcL5PDS2Yov+hUsm0pNj72NlrAYMTnJmNE+/5aDgVBs208NNxUnux763BUQW7FOtK1JvaEUVTe8SPeu+ROyrZtptR1MVQH3CyGlaMYDQ2HGJ0kiaLjoOJi4mBgg3BQhcBDQREereEQAaFRkrUxUjnUcA7dUnEcA1BQPQ/hCTxVxfEEftJx325gKyq25qEqgoDlYIf8aZZYvDB1UkhvHsoCCnSW+3k2irr8aRUUP/9HPuhnIzWzvrXDU31hojp+AjGEgm4p6MKDvC9cXFXBtH3Z46GQJozieaieL4RUChEyOQVbaJQoKTTFISeCtIkIHgYuKjktSpooLgFyUZMgacycg+lZeEaQUJGJ5+ZhyxYSZW1oX5tK3bnHktzcyepFGm7cI9WWx8m7vcRH5zubSa1pBk0lvnyLFB+S/Y4UH4OHFB8fI7oaE2x/v52q8WWUDiveZ8fNvLWcjt88jlYUoeKb52HU7jxqZY9RVX/REVX1Y0SBrfOXs/Hxd1A0lVBVlCEnTsTZ1oIaDaMVxxBC0PLrx+lc04mWimK6OUpFC46qEM5vJ5/08DrjNN38IMFtm+g0h6CoKqWhIpTtbTiFnBV+vlFR+L/Ss9ibisDz/CkGT+i0VQk2jusAT2XCMpWaLoFugap4WIpLTnVxiiyypothC3RUHEdHxSVn6CRiHm7Ew9MgGPQTfKH4fhsj1sPWBj/5V+V22FbvO5wKCkvc+64kKOq/1mpB8f81bD+pmNDBtBRcz0B3/akhhMDM6HiKfzxRkBFxzMISd/6kip9VXcMWvt2niCSKEOg4CFTSBHCMCJmyIaS7YmSxiWXT2IqJa5u4Rghz9Egqv/ElNjz0MsamBKOX/hnlwW1UzfsSNWdW4TzfxMZFbYw5pppgtHfOgZJJQ2gbVYVqGhRNqB+cMSaRSA4IpPjYx6SXriK/YRuR6RMIDN39TI92zuHlO5fQsqKDyrGlnHTjTMzIvpkXz7y5DGv9VjA0cu+v3y3xISwLb/6zJF54i9YteTLvb0CUVzL8tm9SPL4eNeRbMLpWbGPZ/y4l4wYYd8Z4ys77NPnl6wmObcBa/C7mX/5AZWOa9qGTSW5Pk3hyAam/PAOxGFXfuwS9pgLhumhBE1uPEct1UOR1YpIiTRhTZIm2dcJj2xBKBCMPLW6MjOIS8YoxyJPDIIBF94SEi4qDRqiwfomraCiFLKROkY0XcVA88IpU9C6BqvgLxSmKh2sKCFh4hsBRQHH9spwJuZCNHRL+tIgCmZCfSdR0/CmRbhtAJgbaFoglfH8PhD8Vozv+Qm9FXX7EilGwcjgqWGFYNxo8FOpWRgm3hcnhESONorh4iiikcfdXyLXQsDAxcPFQcVChMMWSJEKAPAhBQMnjCBMTP/zWxKEqsZ50ZAJe3sazoEspJa+EiIg8dhqC46ZQds0YlP++j/C2tWhP/52cnif8o/9g4vF1TDy+f/+d0inDmfxf56Joar8WLolkXyMtH4OHFB/7EKupjZZ7/ord2EJmyUrqb5y729lCPcfDzjh4joeVcXDtf63camdtVvx9A07eYfzJIwiX7d1cCsaEUWSfeBNFD6IP7f/F8WHEm4uwf/FLnNeXY2YULCLYRoRNX0tQdsQYSs44jtgJR7D8VwtZ/fhKApkOYo//L/pIg0xeo+uNFZQPCRHMdVEZztORSbP87xuxcu+hLl+F6wqciQcz7LLPYh57FJ0LGyHQSWViLeD/Wk8TopiuQnrwDE40iaeYRJJ5woWU6HGilBNHw0PFQ6CgQSGyxZ+ecNAwhJ8ytKbFI1XqO26Wtfl+IY5noCgCVxgEbEFOCD8TKf4iba4u8AzwjEJkivBDY7sqfatFZStEctBR6i/2pnh+ivTiLrAD/pSK6vn7aQ5EslDV6vtyKMLPbtoVgVwIPAH5qEtRm0ueEF3omOQIkCskBdNxCJAijFKYDlIQuOi0U4wKxEgTIodFkJypYmh5sByCTpawY2M7OsPy7+JgENdKUYtiNGkHk29fQ65Jp+XBVxh53TmUf+ZI3Cc7USMhRDoDrrvLtVzM4vAejVGJZDCQ4mPwkOJjXyIE3W8l4Q1sRAaiJod95WC2LtlO3eTKXjkzNr3WxNKHV+BaLigw9byJu9cdz0PYzi79ONoyUdbq4xCuRnBdhpFjem9vfXklba+upvzwUVTNPsgv1HWEqiFQ8BQNIRRc28VavhHFthCaQUsySLY1haKqlNvNhLri2CttkukAGbMU1xhLdXkJapFBarOKaF5Bixcn0pHHC0Vwt9rUbGqi45FnSa7Yip0NU6aWERVJUsTIKwae4aCLBO1lgngJaE6OEscjlvXDQbyCC6gCqHi+EyaKbyVA88Nphf+C1vAoSzhMe0sl7wV9iaP5JgnhqQjNwos4aK7oiTIRamGaxPGzi2oKaDl/YThXK2Qjxff1iCWho8x/WFkhSBWmYxTFFx1VTRCwC86kXmEqxvX9QyoFdBb5C9WVthacSQvTK7oQ4GrklCCWZ+Bi+BE5hQXxCiMSDx0TC7VblGg2IpDGUTQcxSHvRNBJkxUhbKGjKw7hgEfd+YeRSgi2/FXB8RRSrydo/NECao+YzsG3HoVYvRbjiKkogd0LuZZIJJ98pPjYh5h1lVTNPbNn2mUga6QADJlazZCp1X3K9aCGHtRQFDBCu3dLnVSWxrseJ7ellZovzKL02EN2Xl8PQjJFZsN2hBiLovhvTTuZZdPvXyazuY3U2maKDx5KoDyGcth0At//NvGHn6frxZVY29pJpBUidgZr9WY6Ro9m20NvgApjvzAZ54Uk2rb3yJjFdAbrsF2NnDEUceSx2B0pjLcXEtq0Hk+4pGwXkclS9v5bbL3gcexl6ylNCuJqKVuNYZRbzSjCoVprIqBmMLDQNA9DUXCVAJ7i9fziV4FOigiTJ0IKDT8SxUYnTZggFmEy6MLFUHzrhyL8dV2UgsOFqgjQXDJRB8csWCNyvvAQCuQNX3iYOV+IIArZSQvvYiMH2TBEk1C93bd0WIV06mbeX4MlmINozm+nOwQ3aIGDioeCmdQYt9TP3eGikjddckVJsD3MuIoiVIRQyRAiX57GCyVxE2GURKDHIgICG508AQLk0YSf58PTNHJeBE/V6fDKyBBCUzwIhhCjxrFtZZJwfSn2tBmkW5J4mk6uK0fLO03Y53ya2LFH9hpLIpXCefFZFFVFO+5TKCGZ9VRyYCItH4OHFB/7mMi0CUSmTdgrbVnbO+h6eRlFZUXMuGwKruUx7KjdmxbJrN5CYvEavGye9meX7lR8DJ0zisR7G2ibv4XEy+/Qdkg1gdoyVt75T/RoAC0aRDE0zPIoWth/oyqahnLsMRRVDCHR9RsS4Qjm+1vQLQdN01BTKaJtKzDTnRRVTqFrSAXJphjBrMXQ8Gay27toerqVRSuOJFgaocTLoQgbzc5R6nVQmu9E/GM1im1RJxLkMFntjiZOMSZZf+Ezr7DqmgLF7TpYKslcOV5GJ0uKoD+xgI2OQMHBQMEPKfEdUbsdMf3gWE8oPTYSE9tfKM5zcRUPR1HBUxBCoBSmR9LFgOILCFvznUQVz7dWRNOQyMLm4ZCKQn2j7wwaykI24k/7ODqUt/uixLD9qR634Jeh9ziIKrjouAXZ5KDhoZApzuNGXHKeIGgZKFm/jmbmEUVp0D08VeAko35/EUTJ0EExDjoxEmgeuJkw7WolnWIIKCphkpTQRYcoY2X0CGoCYUpRMK0Uh180DrW+hqY1KZoXN1F1SA2Rqkif8eQseA77fx9E0TQwTPRPfXpgA18i2UdI8TF4SPHxMaNtWRPNr2+kbEI1zptL6Hp+CXppjGH/cS6Rg0bsdjvBoVWERtZitXQSm7LzZZY1U8NqS5LZ2gmOjdWeZN3/vkr7Yy8jFJW6L5/I+G+fRmx0da/kUEIIhGESnDgCvayI2KFjyD/7EhoCJZOgLL4dr7mV3CONiOIaRFeSsNJONJHGyLkkMMlvbceImJijhyLcPNbWFqL5jZjkUa0MJnkCWBhYlNJJruAmqqGgeQq5fBGaqmAoNm6uHM2LQsH/Iehnv8DExsZAQeDhZy0N4KFgY+LgAHlMVAyC2HiFnBcBbBTH9f0+Qi5eIQRWKNBV4k+raB4Uu/8Kk0UFXH/bxhF+Xo+uUihv8308itzConG6bykJZfxUHMkQqK5CKGHg2iGygImDi0qWIAoKbiHDaAAb4XogBJrnorhawZE0hnA8NCuNozioOQNXUJAtAgOHCHm6iBZCjS3SXpiEV04LlQQ0i1JaiJDBxCYTX06nehwHHVGG9fTzbH3/PcqOn8Lkm7/GhHMsAsXBfq17iqaj6Jq/qM0ufEAkEsknE/nN/wgIIcivbUQNBzHrd52TwLFcOrekKa4NY+7m9MgHcW2X9x94nY4V24kOKWFEg+NvUBRQ/F/dme1JRCZL4tVl6MURKj49vd+l6c2KYkZ+/zyceJpAXflOj7v15fVsfms7nhJE1yOUHzWG5ueWIxwXO2uxacFGqk8/imB1iS84UmmUSJjOV95ny4P/RFEV6mdPwCuvxDt+Ku1/e4Xklk7MjAWeh+spOLaHVlmFlcjhqg6O6pGsGEFxkYEZbyK1pQsdg06vlBgV6DSjYwNeQTzoqAhK6ETFKYgSP2zW8kJkiZIlRoRMT1ipiosCGIVQUt++4Vs7QGAoeVTVxTU8VM/AskMkRci3MygWhuqhisLUShDykX85gTqFKFLF9f05dLsQzeL5xhhX8zOZai6EM1DZ8gGn0g5wTH86RnfB0nwrCBqohoJtB8kRQOmZOnL9EFkMHEyyhFA6w2i5DBEnh25BDoMuYniehtJcTNhIQN7AQyNJkCjZnvsdKgi67hBbB4MwcXQXHAyEquMJDdXOQ1cnmRUJ8uu2o2uCXGMbdksnwbodR0Rps48H0wRNQzvq6N3/Akgk+xhp+Rg8pPj4CMTnv0Hb759BDQeonXcuofHDd1jX8wQv3P0+m95qo3ZCCSdeewhGQBvQ8RRVQQ+bqLqGHtSpOvdYcpNHYFYWE54wjE3zV7Lmz2+jbd5AVElhRIN0Ll6PWVNKKCjQwwFKTz4SLeabwvVYGD32r+gCIQT5R5/EeXURxqwZmJ89iWxjG+3fu5WG99bSVDSGsoljaHvoHww5Zjjp5mk0v9uKEyqla30H9YcPIfvoP8jPX4g+fhSZ6BBSKxoxVi2j9ZEu8pFSumadTtmYCTjx1ah1GXTbwo1UUH7B6aS3p8mnumhbs5z8xmZKstupVLtIb08i8r7FIeAVsY6RpIhQQwtRkjjo5AmiY1NDa0/eip5rj4KGR4w4IWzA94vwBYuHVZjEUAr7FBKP+22oHooiUFUXTbUxXBUND13P46l+VIviFdZRcQrhsEAk6WvCUNpfwh7hLxvTWeHn7ogmYcxqX3SUdEFpXCFnKriqn/TLtP19PN0XIHkK+T4UA1ALlhoIaBkMYWN4eSxMkmikiRAkRygPlhckj0aKEEFsMuh0uuUI1yRIDlQXS9FpcisLIbgG1bSiIsgSJEWYCBlKiZMnSFIpxgkVk8ZEUwUiEad5mcDwgsSCLkpXJ1tvuJ+qS04nelj/js9KMIg+51MDGvsSyf5Aio/BQ4qPj0B+UzNuexw3rmFtbd2p+LDSNs0rush05mlZmyDdkaekdmBhhaqmMvmKY2h7dxvFI8uJja4kNvZfPh6tS7aQaU6gd2QIRV2EmyGzYDlqOkWQDKG6UtSgSdlpx/Ts42zeSu6ZF3H0IIGjDsX+x3N4zS14qTTGrBnYi9+laN07RPNdGEkbZVWYrg0KZt1mDvruOXiPrkUkU1RWgpfPk3/+VdwtTdjtCdrrVdJbuyhPJxBOGj1nk1u+jvdFNThVTGxaSJHSRS4QJKx0EVr9Jo5m0rRsG6aVIICDSIYwXRXXc7HxxZqDyWaGUk0LxSQQqOQJFhKDOSiFkNluOWFio+Fh9HhvCCx00kRQccmrGm/OtLGiLke9pFKa8uWKLUxMz0Vx8ff3cn4cjCJQCrk9hJ+ZnHDSFx/BDFg6oPsPHTPvi5lcwPftSMV8R1TwnUsjGTCy4KBgWApRS8VRIR8ReIZAsRVUR0PP+VE5qqP6/iDouNEsyZoEAc+hbGsQPe/0rL9SprVjqjk8VSNul6Oj4OIRJY2NQTtllCrt1JvrKVcEG+yRLHZmUEkLpXTRQjVpQmxgGHU00+3mmhcGXZkAtdFGSgJJyrU0qzMzqFddwrku8u8mwLLIrWnsER9uNo/dkSRQWzZgJ2uJRPLJRIqPj0DxcVOxNjejlcSIHDp2p3UDUYMJn6pn1QtNDD+skqLq3fPwt5vaQAGjpgKASE0RkZqifuvWzxpNaksXwcm1DJtegd0aZ/uCFYitFppwUUwDNdA7q2T2kSdJPPIM6ZY06cOOZXhdCWo6jTa8ASUSJjR2CEZVCVY6g1JThWIaKLogtTVB569fZOQxI9EXrSH3mzdoe2sUWlk5aipN0gqxZXmcYD6LrYfJa2AJA68rgbV+C4qh42oGKhqmIWj7zZNo7S04qo5u6ei4gIebt0mJGHZBYLRSiaeaVHrNxEgBFOI9wEInVPDnyFGYpwDCOAVrhl/Xn5ywyBJEx+W9wzI8PNclHVZoKw1wzh8M9MJUhuEaqK6LhouCb+JQAc/zE35lw/9avj6UhXzAnyLx8P02XN2fNkkXgVvohFrwAfHUQlhtGJSMh+6oqAoYqsDLauSzBq6roQiB6frn59lBXBRMbFKRnJ+0TEAg6lGs5IgJB9Vy/QMJEELB1hTixS6RhJ/QrBg/FDmkx9FiXXgaRJMdqI4gTglJYqSJ0KKW0eJVE8RGx6WdEjx0NGwiIkkkCm4IrAQY+QyKksfqypHHpDqVIP/7R2D4cDbNX0lucyvln5pK/Xmz+x27ohCC3h1FJZEcCEjLx+AhxcdHIDhmKA03fX236iqKwvSzRjLl9OFourJbD9n04hW03vsobjaPW16NVl/DkAvnEKgu7bd+3YwRVB1aj2poqLqGcF1iU0bh5S10218tNDbj4F77uHqAfCJPPuPS/PpmMjMmccilpxA+4iBQVdqfehOrbhh2rJrICSdQc/oRpJdtYMP/vkx23XaU9jaqnCbUDetwn/4bdqwEvnQe3qEzCNzxJAHNxWyogeII1ppmQm1bGZHYih4N41ZUk5syA6ushtT//oOYJ1Bdi4Diz1E46GSEWchGoZImRL3ajO7l0bBJEyJEFg0XFRetEPWhKTYRLYlApcspQcEk0OMoahMkj1LwktAUF01zUXQPTzPI6xoWBlrBl0SoDigC4Skoir8uvVdwCBX4vhmeBnbhdnYnBHMKfh35gL9d4Pt8FHX4uToCed8Z1dELgkWDWFz0hNHqCFTPwxGGb2GxVZTC19U0UxhKGicTws6aOJ5OLh8karbiBXOYWZdOYqiuST4XY/mMFE31HlXbFaa9FEUXFkoghWPY5IL+qrZu0KYqvZ04JbzOEYwNvUdNaC2V9ha2psbhRstIJW1MbEpEloRTTbgkxKrOsXRkI8RDVYTSaWzPRInnyfzqIczqIG5pOVmrFjsnSCxa3a/4yHTlWXDvStLteY66cDT1k8p26zslkQw2UnwMHlJ87GM+uJDWrrDWb8Xesp389k4ySgtKbRuRMXXUnHHUjtv/QLSJommUHdHbIpNZu5Xs+iaih4wkl/F4d2UAyg/B1jNk0yZqe56ujEksEsHLW+Q3NuFqAYyRVdR/+TjM2grSjz5DuHE1mhEhPOezREM1OOvfR8skIBVn+0NPsnjTGCrqhlPfspRArhMlFUdJNJF1dMJ5C9UyyHq1LH53HImOJqrbPcKuR5AcJhmyBEgSRgBhMghUIqQo9bowsElSRIJiQFBOO2V0IFDooghFdQipGd95UxVkvChJwnTLGK+QxdTEReBxxCKX7G+gK+Jx2PN+MrEAFqZigeqybgy0lMOI9Qo1zSAU4a+xokAgB3nTn3JBKSQVE4Ul6gvpz42cP2mhCIh1QSCjgepimwq5iMAKgW2AlzOI5ASK8C05eEphCXsDA8dfRVezEHoedEEkp5PbUI8jAmhKF+laFzsocIpzuI7AtYMk4ybxKgslZBOvMOkKa2jFnejhNImcTtgJoSiCoCU4iPfZyFDWMpLyQBNRNQGBFIpRhZnZhqc6xEUEoQrUUJqm9iit1FJlbyFaHcQ4+FAib75CzG0lmIxAzVA/yqliKM7771M6tbbfMdv4TgfrX9uOY3msfKFJig/JAYMUH4OHFB8HMOHpEwgtWYmytR07o6LEogRq+rd6dCOEIP7mKlKrtlJ6zCQiI/6VlMzuSNB4+6NkN24nNnkU2ozD6WxM4qWChAMqRVURgg0lmGEN4XmoAZOys45n6/3/oH1FK51X/IoRXzuB5LJNWFkHRfPIRsrpGjaauhvKSXzlGuxkjlRbjqJ//JlAtpUYKzEDYGViaDoEXQvPE6hWHsdT8No7Kd2ynmK3vZCxwk+bpRamOcroBBRaKUPHFycCBRUHhwBZIhi0EMRCAEWkSIgoiDRCCFThLxan4pIlgCikVI+RBkARHkHb5aRn/EwfFmlyBNCx0YRLRzEsnQLJGLSXqXzmSRfN8SNcPD87F24QhOGvCNs9v2Nk/akXzfVXnvU0yEb9iBhXc7ECvmXEFSo4fkZU3RPowsPzoDvfah4DtZDbw0ZD4CLCGYTm4aoWwS6bCDmKSJBydRwPHM23FHkqBGyXhjVBto90CTfGaM3VE61KoWg2nqHT1TKSsMhRms/gkqaeJsYqG+jIVxJWklhOiGi6hVq2EVIydOnltJSYBEJx8maWkZ06Q1PrCK1zCBrDCE0qQ8sFCYyoRT/9VPSjDqP+hadxVq9FeyeH96npqDW9RUhZQ4SSIRHySZuq0f1PKUokkk8WUnwcAAghyG7tQAuZBMpjPeWBEfXU3/QNBJBZ24SiKoRH+w6mmZYk2ZYkJWP/P3vvHSfZVZ75f8/NlUPnONM9OWlmNMooISGSkMhIYKK9WDZgGwfwYnsxiw3Yu7YXfl4W4zVGZPASTRYSSihrpNHk3D2dY+Wqm+/5/VGlFmMhoYAQMvX9fCR11a0bSnWq6qlz3vd5ulGNR17G8h0HOPQHn8CZL5HYtZFtn3gnsf7mL8nI9QkdDxmEhA2Hrs095NfmqIwdw0yZxHIaanWJQ3/5FWauOIe1v3URk4cqNI7PYp06Rn0yzXxcUDF7qLPI3GwC833/l2IyQvzJyyk9/4249z1EpSqw7BJZfwEFF9XQUFIJolgavxagOnWiVIxoZC3DB/ahhUsIInw0IpRmbQWCDNWWFwd0s4SLSYiKRBKjgUaAi0mN5EoLbYhKI4qhyiy6DFe6WDQiYngE6PhYBLgto7CwtRwjW7HyzVwYtVVHYjigu6DEBDE7Qo1AQaBIiWtCPdlcekG2rM4brZC4sOlgGmhN4aFGAqlIIgWcRHPZRkjZdDAtGuhhSMINm4WsqiBEUgxTRNIEJB46vlBIWouoqkQKBV14pJknQkUgSS2b+HETN0zhqBpKoJF0JLl9cdYesChGWSbIkCzmEZkStfIABaeHbpbRWMTEx0UnJaos2UMEbgoRwRBTCCVCUSWpdd2UjWYyXiKbxVmsoUsP4ft4kwtkrrkMI2ygnrkD/Tdei1BV/C/NIoIAWSggS0X4D+KjazTNVe8/E7fm0zmSok2bXxXaMx/PHG3x8SvA4i0HmPj8rahxk3V/eBXJ0UdmK4SqIoDYUCeEIUIIGgtVdn/kBupzVYav2MDm32wuw0Sux/xnvk9wfByBirdUwS/WV8SH2ddB/1tfRPmhMUp+golbxtjxR8/nWGOJ+olZwnKNwr1HCALB8jLM7FvGvOk7jNYfwlQ8ih0bia/qRu66kMmwn8qP9zLijqFG4O0+QGXXCzg+2UXfFo/ecAp/LEbJy+AbcfbbawjMFOmLV7Gz9hOqdx7AuOPmVpZIiI/OAp3USZBWbBw1iemXMHFbokJrBb41LdF1PEx8NAIqJAGBiY1EkqJOIJsSQmstoTTNxCQBKj5Gy1TLb/XDSBpYK16mCkEzkwYVwwvZeBiqGcn6Q/Bw9mygSKKHvdibpSBEGoQGGF5zZsQ3mrMjrgXxMpgNqKdYaQLWArAaCkpd4+HFskg0jc4cTAKhEUiDAJUSGfLmNDG1ThRIQqGg2ToaEge1GRTngeuliTCpkyFJA0EZhRAZCUw8BpglVlCJCl0s0cMYq1ikh0Em6WUBt2WdXiFLMnIQRJTIkY+KhIFOadHE2Xk+qWwFL7CoKQtUtSop3UUfGYFXvBzrvC2QSq10tuiveh1BIoGyehRl7c8uzE53x6C7bbPe5leLtvh45miLj18BqkemcWZLKLpKY2z+NPEB4I7PMP+P/0bkeHS//RU01CT12Qp+zaV8x14WnUliZ6xD7e8hrNQwuzMEvqT3DZeS3HC63Xr2eVs5ejRi///6DqrbYOF7AyRVG4TAcwNCzUL6Hm5HL0rZRq/XMf0aQgGlK0ffe96Ans+QtEIOHboX3VcwOjMkLj+HiRsKeFqc0FAYfOuVnPjCvRx8cI75eopwsYSi1Uj3LSLDOtTqxPBOC3PTCGmQpBLlUGVEvLXMEsfGR8cl1nIdbXp1yFbj7BId1EnSyxydFAGJi4lNDAOfODYKzcLRCAVXWiuzHmqrOVUlxMFCo2ncprSMy+upZmpsrkireaaZZKuECmoYYTnNYlFoLrE0r4tmsFwAGECkEEkDrR6ixHzQQPUgXYQo0GkQIyRoLg1FJiFKs1E4ar49l+kgREUnQkoFJZQ4fpKy00kKmxJpimRJ0EAANRLEcNCFi5A+KaoEqBRJY2Fj4uJjEMdhgEXKJAENW2u6wQoURsMxIgS2kkRRNSJfpRElsGsQkKSh9+M5Nvn0LMR7Udb3kr32BSSftwORPL2FXN16BurWx7bvD/2QqXtnUDSFgbP6UNR2O26bNv/Z+U8hPqJqjWByFm31IEr8uffrqfN5G6kdnUXPxMmcsepR2+1D4zhHJpBBQOOho+Re/2KGXrCB8uFZOiYfpPztfdh7jtD7395Oasda1ESMzCU76Hnzi35mV4292EA6LlEQ4s6XiXcIVMsgNtiJ2tuNp8Y54w+vJpqY4t4H9rFYnAVFo1aPMaIYKKqCUS/S1acRZNcy+PYX47iQuveHDMwdI5mCUrEfjhXI1wMceimoaXQ1xIwLhJYhbMkIjYioNdNg4uFiIZDEZZ00NdLUUFsioU6cLA5pqvioLNJJgzg6TVHxsJBozmU0HUyblReP/PRoptP6NBc2QCIJW3bpzfM0W2mV1n91r+lSumKL/rAFWSjQ7QglBCtqGo09PAviWYJAtM4cCnwUDEWgRAqGKwgiEJ5C5JkEGFSIYxERoRCg4kYWJg5xGhh4xKlTJ0HF7UJRXRTDxlMEU0EXgZvCwCeGjUTDQ8PEo0+bQBM+YaTjhTogmrb2QBybCBeLHCYuXbgkEstk4rOU3G7SlQViODhYzEYmVRmnIrKYlkCecy4DrzwbI5ug/J1b8XEwhzowR/rJvuL5qD8lPKJqDffgCfShXrT+RwciPszxG8d54NMPoegK5/7Omay+aPhJvX/atHmmeLhQ/Okeo82jec6LD+m6VP7hX/APHcfYsZn0e65rBlY9h0iPdLD1r16HEvvZWRixTauxNgxTPT7H7N5F5OZJtvyXC5C+z+wHZrH31VCScdRsioE/vpagWEXvyj5mO++ON23FnV4gWiqy7TfPQRYK+GWb3pfspFrw2PPjAot//zk67vke6xHMxdZgxFQyL7gQK9/8ckluGiaxth+h62TP28jYJ35AkjoWNkYA1GvE4mAqIbGNnagLcZInHyJ15wFKSh0QREQ4qKioSBR0ESEUDdfMoTsRStQsNn046M3CwcJu2X7TEjB6qxQzoE6cCIGGh0GI2ZpZ8dDwaYauGHitD4NWiykKrtTxMNCJgIfD2tRmxosr6Sg0l1EMH4QaIGiGyHm6ILCanS+xOmiegq0p+EpL8KiAVJCi6RKiqBLdFxAqeF6Cequ3x1g5p4KLDkTEabREgkqWMioRdRlHDXPE8ZECYsKhSA6dgBCdgKjpfCoCNOGjiAhfCGySNIgxQw99LKx8GFq46HggIrLWNEJxsIwlQlUnDLVWy3GILnyW4sMMXnMBm3/vZZz4zmFqX/oBqeWTJPuTGMNdZK++GK0zuzLGpJQU/+nLOHc9hLaqj87/9g7U/CPbfxqv5uHbAYqv4NX9J/XeadPmmaS97PLM8ZwXH1GpQjAxQ1StE4xNIusNRPqXV7QWuAGHvnGYxrLNhpetI7sq+6T29x+4F+crn0Gk0sTe/vvIZA4hQI1bK48xV/fT8a7XM/GX36RxqEThH2+i+7It5Db20vV71+IcPIm5dmjFNt3oeXSr4k+bOGX6krzwY1f/zOvZe+cp9v9wmkvu/j4486S9EKk7xIZXseqaM1YEjdWXI7uxm3rRp/65r5NdnKLWnyCkB81bJtGh0xObRU7OEFkZYqZJxV3ECmqghujSIUuNCJUK6WayrBQYoYOuQ3JVH/6hJcqkUAloECNHmYfTV3x0HGIr/hk6/orTaXPWwkeluQ4SoGMTJ0AjRp0UDZSW0GjWdohWqWuzDddDxUchSQQyxHCbhmKKpDW70fx/KVVJJJofLqFQAA0lUBB+044dV8ETKlqoEUQCVIGUgihUiaSBj4UuXOJqnUgKlsMuaiTJUm3N4DSvTWn2riBR2e9uZVQ5ikbEstuHTZJmQapBRLJZOCthJhogJmymwyFqZFpdMyFLBOgEQESOAnkKTMs+Gn6KmCJxggTHovUIFFxMcmodPWuQHulk9ZsuwervYHH/PLWjBURpAdkZo+ulzyd39cWnD6QoIphZRLoeUaFMWK49pvhYc/lq/LqPoiusunDo57xj2rRp85+B57z4ULo7ib34Etw7H8C67HyUX6LwAJjbM8fBrx0icAKiMOL83z/3Se0fPHgf4akxhK5TveEWxr4/gZSw/i/fQHJj84NY+j5KvYqRS+CUXConl6jM309yKMfZH7iS1GXn/MxjT+wtcuyuRbriDbQDe9AzCQbfdjnu/hPNvJcta1bEROj6yCAkkTMwMxa1rlHyy2WiwCYZLpI+OYb7/lmUD34I85wzKX/pu8xcfzP2TImq4dK5sYuNb3oRteMLeLffg9i3B8EyqgwJZifQG50oUTOwRCoqybBOgjoBGjWSeGiAghSCIe8kMTdLVVHQo+ZCR9MYrOl54aHjYKICDioaPhKVkICmFGmKg6a8EK2WVbXl66G2Zj9CQimI0GnKBg8hZLPBVyZI0EBDIgOBdGRTfPi0emcUpGhmrkgPZKSA1zIDQ0FtgN5aoFEF+FJBQSDD5rV4mDhhHIGCpnioio+QgkhKGlGiVQsTEqDTwMLHwMXCxSCQceYaa4hhY+KTZBGdgDoxqmRI4ACwNzyTSqsLSMdjFZMYBHhojDFKN/NkmUEQ0cUS91d3EdgCN4hTkVlUIgaYxgpd6gXBoqKSHIOdFyaomzkWwjy60kFoxNFmHYalxHngIPVb7sPcspbki55H+g0vo3HjnRib1qCvOr326KeJ52Oc+dbHrglp0+ZZ4xcw80F75uNn8pwXH0IIEq+9ksRrr3xWzm+mTcyMCRLiuSdfb6Jt24l/aC9KMs3cwRLLtx5ARpJTI7ew5cNvQkYR5U9+Cffevazq6yN81wsZv+EIxUMLVBcaHPr+GBuuMkj3Jk47buCF3PavxynvPk6xfITejgA9ZeLcv5fowX2ouRSdb34pQcXGXL+KxQcmCRsug2+5nCuuNHAzZ6DHN1D89l3k5h5Ekw5y7CSlv/pfGDt2ou25n+zkOLbopyaTZMwk5voRRG8v89+/maDUjHvTTJUwULEuOhvj+L+jRAEEgsiw8PyAUKosk0WiYBIQEw6aCAjnF3GkhYVBnAYqClUSxHFaVR3NuQ0Xs+V+AVorfs1oeYVEKDhNuzBirUJVrdX58nD1R4iKhY0iQgIVNKmgRS5CRkRIQq1ZJ6H5QKQSNBttQYQokUD3JY4qkErT+CNEoAsfRY8I1YBIFQgZEDXiIFX8sDkL46G3lnwyCBkQolGTaUAwQy8pGjwsnwIM6liEqORFAU1GGIQoeBh4KzUfFh6LdLSWkFy6sFmii07qmPgtGdb8/+jSTxdLmDhoBAyJeU7KNQihEVN9/FBFlSERgoaMM97oxbxtARGzmJ0TLOfWk+yKkxmG3FlrIQgoff7beEdO4ew/jrVlDbGztxE7+3RH3TZtnku0l12eOZ7z4uPZpnNjJxf80fk4RZu+x3BwfDz0cy5AXbcRYZgoX7oLaT7Y9IxIN82WpO3g7T9GtFxCUQTdW7rIbB3i6Df2c+D7kyx+a5xGNeKSPzrrtOMqqiBVnyU3dgsxr4j0M6j9GwlOzECtgXRdSt+4FRJxyncfxC00MBcmqdRnMDI5wqkp7FyKrje9FP/HFtHMXgLHw6mEqPsOYuGT7E8TJTbg6CkaHSZ+zwB1r0ixphOzFULyEOik+kdRRlahaYJY4OBLnZrViZ/IMmF3UnQs+pkjSa1pY25LQqHhy2atgoWNIMIhhUBBJcTGYlobxQjqSJozI0priQJawWst8ZHAxmgtNYQIHIymwBEKIooQImJ6sOnZkStEZBcbCCmxraYnhwASdVB9iRfqGISostnNUuqAWjJE86BjTkcPIxQ1IlJk04JdkSgywNUkFT+Di4lsGcGH6Eglwlc1vMjAkU0fkxLpVnFoRJkUHhZxaqzVjmGJOjWZYCnobzmRNB+ntDp2muIsYj0nWtk3UasbKIGCyoLSx75oBxmKpKjTy2yzTkRTSHeaeNKkqmXxY53Mz2lYjTIlssQ6E6y/bJCpPYtoKnSOpDjjba9g3Vlp4sNdoAi0zhz+2AxqNkkkVOyZAlZfrp3X0qZNm0fRFh9PEyEE3Zu7ntYxlFyzRmPo9RcRhoKg4bH69U3vDhGPEX/BBTR+fBfWzs2ovV0kVJX+yzZx5L4KXsFBUR/94e4VavSWDuN7C8gowgl1RPcwA7tWs/yvdWKru7HWDeCdmsMc7MWYuwslqKFPjyN78riWgdaRoed3Xknw6ucz8zefwttzGMVTyV/9ItSxw6SBjZvP4dTXH6CxZFO++zCur1CvRpituowwNFDi3Rh9vYT5LsIlB2EYFPo2Y+STLMxaFMarpKi2lhI8hJSEiiCpNCCKWm2xzXaSOboxcdEI6AjmqLQEid5qkY3QKJFuFWsKDIJW+2xzBiNExRc6iuq3ClcVHFNQyUh8DYp5yJSaf3tG04VU0Pxv5Ckr5mMSARLcGISaQAqJr4MMFfRIrJiONataVbRA4BLHwcTEQyKIYZNSm86upiLpEktUZIYaiVZ/j4ZNnCopTNHAEg3iepWYVkIGITP2KIFU8Wku+XjozTyallFaigpxbBLY7GcLJ5W1VEliWAo1upgLhmkECSIU5sJBRratJpcMmNlXojS3gIyn6P3dazhjNMf6i7rp3dTBsVuncas+HatTbHnZCEb8kaDC/DuuxTlwAtJpjn78Btz5Mv2vOIf+q89+Wu+PNm2eLdozH88cbfHxK4SeMFl33eWn3SeEIPmal5C46jIwjJVfkd0b85z/OzuoL9qsOv/0GRcpJdOfvZHG3uMosSQ+GrXcIN6pEkHUQXXtxWQ39jD6jnMJ5xbRO9KUavOERyNiG0dIXPcaMotljIEujO48aiKG1tOLP+IR27Sa1G+9jod/zIYTS8QenCZyfMy+PEvfug8Pk4aaQg19bCOL372G7S/dQfCNtciDPv5iEevkYdyTJv2ZHCKRYd4ZxCRqzn7IZvCe6MhhLkyh0Mxb0VvdKz46OcpkKTXPRQwdHwMPF4MqKfSWVXtIU3BAhI+KhkdMNJrGWwg0AiJXYNUFJCSpSjMcDtHMZ5FhS0Q4TatSkxB4uDZEJV6OCDKg2AaumyBCEkUaoQceCgk8pASbBD4aLjqCiDgBKWpoYQRqhBfFUGVElgoNEhTJ4aNTJI1AoSjzFKM8plIhFCqW1iBQVQh0QgwaWC3hIVCIWmZqGi4mEQIdDyNyQCSbJmZ9I0xaPbhjs1QclQvDu8ncvJ8IiLw8BiZu3aF+fJ6X//V5qFqzC2vdJQOMnN+LqiuPmtFQcxkSF55J8f7j1I7NEjk+pQdOrogPd2qB6t0HMAa6SJ23pT0j0uZXnrb4eOZoi49fISLPxzk6gd6VRe/pOG2bMM3TbwvBqvMeKeKTUlI8WSQMJKk02LsPoQUuMhGn561X49wyjrdUpXJ8EZFJw1iJyIyRPGcLhX/5OvZ8BSWVQ3/J5RirBzBWD6wcW03E6PuD12EfmSC2aTWKZVI5VcAt2eRWpenbkkcIcOo29qlF1FyGKK00rbTRady9n9n3LxDNzuIvVXDKPipes0S0atDdm6ZaiagwyIyj0fB1okyW/u6A3sVFajKOhYeN1cp2ebiMNCRHkTQVHCwCtFZniCBGgyQNXDSqJNAJUQlJixqaDJBRM6JeiwJ0ETE4Cb6qYrkQGCGRAqoPWgO0UENGKkJESCKQLUGjRcRcgT6n4PlxPGmiEBKiEcqm5bndeost0IGHSYo6PhoF0sRoIIKQKIIKWbTWMzNx0PGokKKHIhJwMZgMRwhclYy5SDVKUQ/TBDRnHny0lmMr9DFDmiohKrN04xLDwUASUSRHFEDP0kFkzCIMHF7K7Qwwje81C1sNks2k4FBS23uS41+8h6ErNhHvyzbHWiSxyx7xrEn5tj0sfPse1NVDDP3mC9BjBsn1/WR3juLMFOi67JGaj/l//S61ew6id2cx5ifRRYBy3jmInsf2AGnT5tmkLT6eOdri41eI5c9/n/IN96D35On/s7c+SoA8HjO7Z7n3E7uJgoidr9+INdRJutYgvmkVw2+/lNLkdygfW8QPFZaLEU5CpbzokuhJgSJAVXGdgLnvPUh8ukpsdQ9OoBLaPl0Xb8Ic6sEcan5JlE4scf/f/gh3sUKvWcK8+1Y0QyX5Gy/DxMHsFHRd80oKu09SuOMQ6vwcxS/uRvoRMopWfDRsEniJPLGYgVJ1CP0AJZGkrzaHVZ+gcchgVnYTI0kSu7VXhCDAJkZEs9ZDJUTDJ2otzkSwElBntfJclJZb6sM1IVIKpCrxVDCkRJUKwm9G24WeBr5CVZokhIcifBQ1QLRabH00GjKOqdSbduwKKCKiIWMEqK08GtmqM2m2zGao4+K3TMwibOLM082QegpddUnLIhNyhIR0yVMm0SqsDdGRrWA5icK8P0Ax6MKVBgpNUaMiSWBTII9NnCRVAHQCYjiAoItl5uhlTnaxKpzCrLsoNZ9hucBqTmHg4xFSId2cDUJBIyS5eJI9fzrByY/nOOfjb8YY7uXH/2sv9aLDOReZGP/zw/inlphJjVLzTc549+Uohkb+zNXIHcN0nLduZYwKu0Zsfgy9YcEXDhHadeThI2h/+idP963Tpk2b5xht8fErhHtymqjWwEfiLxSflPiozdWpLzSIoohaKWDjH70We2yO+IYh9FyCzW9/Hsv7Zpg8ZlO8v4yvCkonizi7DxJUDdIvuoTq9+7DufcohR/cg9nfQS20CLOdTZFx4VqCQoXkmeupz5Swf/IgUaFEwfDpKNUIfI/il+7Ckg1Eo0Hjhp8w9D/eQ/1//jvKj36EJw0IHTxpEAkTx0hRX72FWG0J+8Rs04wrlWPAPknCXyYKJZI0VdJM00G8I05nY5Iuexwdv+XzYWHiY+E021DREa0v/WXyKCy3vriNljhRacjmEo2i+kRm03LdCwSGL1ZmK0wihGxWXTTQ0VSHSG3WeghfIZIaDhYikKiajYhUoqhpbFciR5I6KiFVFBKtbpIQgdG6BqC1fGTgYqLjohEStQpRFaLWFhcNmwgIEK1eHQshm74kKnWGmUYQkcChC4NJ+plmgA6W6WMeA48OingYVEkyw0mEUEkYLp3uNHkWW6F6Cr6RwDG6kTUXr7U8pDaqSFtQt+sc+8cfMH/G5dz33TnSGYUNlaMMLM+SaFSoWZ00ijYAizftZeJfb0QoCoqh033FDgA6Ew6+KKBEFooXb/qlhOEv8i3Ups0vlPbMxzNHW3z8CpF75aUgwRztx1r/iMV0YazE+O0TZIczjFwy/DPXygfP7Wfh8BKRF7LqwiGMnvRpZmMdZwzSccYg+ZNlfOUwZlIn5paZ+OZuoiBEe/XZ6BvX4Ny9H0VVkEEIYYAQ4M8vM/X3uwmKVTquuoD4GRtQy8tQr+PrKWYT61BrZYKySoddQVcClh8cZ/FDX0fvyuEmshAIwv61aIuz6JFP3JKYjSlqc1WEjJCaTk6vEXdqzVZa0aypCNAQqoba00nesNH2nUKEtNptRSuDRRLDoYKORkSCMioBRdIruTFVYojWckIChxxLCNFsJQ2kShiazaWGltkYgNYqLhVK0+cjAggFjTBGhEYQmYSevjIfoxOumJ0FKNSJUyDfKqb1WqKpGWwXoaLj44Ux6hIqpHBlnCV0chSxieFgkaMCSLJUAKWVw9Jccupmng6WiVCZZBBBgn7mEECZNEkaZCkhAZWADBWyVJiUqzAsk9HUEsqySjHKoZo69b41yKVmjk4EdFACT+BaGczuDnxhcP89kkLdwiMi8/JRgv1duA2NcOMW1l/T7LiSYdT8Rzb/fhg1nUD0dkAmjfKiyxCxGMr5T84Xp02bXyZt8fHM0RYfv0Ikdm0isWvTo+5/8Pq9TN0/S6IrTmYwRcfaRzuYxjtiXPQn5//cc3SOZnjx+5sf+It3HkVLmMhaHV2H/j9+NfWDZ+NPziBUhSiTJ0LFSijM7T1A5Pr4yxWSmTjx/iyuIpGpJNXsIGatQCwGfpCkPr2Ivdwg/PZdiM48yqadzRj4bAZuv5OcM4sfQLC8SBBZSM3E2jRK74BPfXcdtySoWx042UGyI71kHRsl8HDmqpjJOFQDwqhpuf5wEJxNbMWzI0MZQUQacDBWTMSUWB1V85GeBq5AdwW+UPB8E6VVLyJb7bgSBQ+dSOqEYbM7Blgx/AppVqVGrUUfASu+Iu5KZo2CCpTI4uKSoAE0O2VCRMtpVRJEFgEmOh5F8hTIIojIU0LHI0Btia2IOA4qAV3KHHmKmJHf8izVWKADE484DiEG0/SzIPoY5hSmdGmQxkenJNNMlDJkehxWp11CxybMd6HUaqiuQ44GOQqtoL8Yfkyn88pNeGaSrTd+i7H8KOlLziR1lsPJH5+Pm2hgrNtAfmM3AF2XnwFSIhRB5yVbVsae/vrXEg4NIjryKBc9r11w2qbNrzFt8fE4NKaWOfWF21F0jdVvvhizM/2sXIcW01BUgWqoqObpL1nk+RQ+9Q3cI+NkXnkZyUvOeoyjPJrO89YSTEyz9NHPU/3EURLpt9Bx1YXAzkedIyyU8BfLdFx5HuZwN2v+6OXM/HAfE+MRdTVFYCSRpsfErAcyRlqOowURMoRaKaK/O6B4010U/Az1TJa8N4uj1KiQQ189yDl/dw3ut2+gcLxEQRmgJhN0bBxkuM+nevNh5PQ0iaCEIRxUGaBgoBNSJ4FKRJkMCRqohESAQYSElu8F6IpNqLtNczBDoLkQ+RpKS3YorbwYH506Oj4aPk3fDSfQScgaCIkfxPGwWKIDHY90q74CwMaiQZwAkxgNLGz6mCNEYZp+ynSTptHqyImTprpiAa8RYLaERYYaWVEghkNDJggwaRAnhkORNIPKJJ3KIjo+SJWGjDNHDwfZSDeLDDFFHKdZ2CqzVEhh4LJMnjuUi2lEKj0scrwxQD5vY8gFrMIiIoowoog4zewdHQ8LBcNepvKjuwkKVfo0lTXrl9GdIqf+vyUqszVqNcjOV/BKDcx8Ei1h0ffyR89oiK4utFf+bFv/Nm1+FWnPfDxztMXH47B0+yGWbjuEUBXSG/rpu/LM07Y3jk8z+6Vb0HMJ+t98BVo68RhHenqc9Vvb6dvRQ3ogRXbodAHknZyifvsDhOUa5W/d8qTEh1AUgukFvPFZolqdo+//HNvO2EBi1em+JYqh0/26y067b+j1F2MOdrP0e59FlMZwYjmmlgIaJY/AiKOk+kjnFJz+USIrhnnsdnrtGUwvzlj2Aoxd6zh1/yKuLYkNrGfuW/cS3nEIv1SHhoqlOMRknvpdhwhmFsgEBTrUBXTh40UWYaS1PD71lRwUB4MYNjZxQjxEq+BUIFEiSRQoCC1C8QWhkKCFKIQogYIixYorarOpVGsurbRSX+Khj0ASoOO2bM9tMiSp46MiEPiY0MqF0dDpZZ4sJQx8EtS5l7OYIYuFzQgTJKkBEpsYfsrF7ypiOjU65qBPmUUhpBzlqUQpUlTRCKmS4hTDDDKJiqREngrNMWHgoRGSpkYP8zgtkXSCDUSozNHLWdHdrOcoEkGjGqOjOkvZ6sYJW3UxisGi2k1fOI0aNi3eVUKSU0cRgUdgJEj0bGDhgSPUxxYI7QBr7VqEoVGfKmLmk09+gLdp8ytKW3w8c7TFx+Ng9eUwOpIomorZk3nU9uUbdlO55xBC10huGyV/yTOTT5HoSrD+xWt+5ja9twN9uA+m5rG2/OzHPB7m9o348QxBNcBzVBZv3k/irc9/QvvWDpzCwiaWV5CDKZbnioSaiR2Z1EMLo9ZAtWuQSaPFDazBDJViDK2ng2U3TpQT2NLD8KF0026UmQWk56GqCRRdpzG1jOqBJw2SokpC1JFCIVAkNgmqZCAKSFIjQR2FgAAFWqFozUWU5tKMQKI0VELFQInAVwJU0Uq4FRIpH27SbRKiUCPeSpUtrCzv6C2b9l4WyFAhQQO79SX/8J46Ph0sEcNGb6XRJKmxlYMcZkNrlsNtLdWo1ElQyy0TxQNUq4CsWqh2q1ZCRISoK7byGSrISDAnBxCEBNJAopKiwpk8iEFAnmUMPCIUNnGEnezhMBtJUmcr+8lRIC5qJGhgSo+Ks8it6avpSDgs1Uzmo25KSp7R+BQppU56TR6rMI1XUzHXDxN74fOwP/AVWC5g6QKlvkj+rPNJr+1+0uOvTZs2v560xcfj0HXJZqyeDIqukVjzaC8Cc7ALNZNAS1iYPdlf/gUCajZNz/t+k2ChgLH6scO7Houuy8+g/qHfY/Jzt5DIxIgNPLqe5GcRhRFjeyqUKwIzY3LWn7yYxoZZjt82RzRdIL48DoFPPKgy+LwOCl8yqdXj1NaeQawji5lQCcpVlGKZjlqNhq+huApCTRAqBoSSyPVpdAwRpftQjo4hvaY4KIo8nplCkyqGU10JWQPREh+szIZ4WC0jc58QiRfpTddT6SGiZoptVaYAQRyXALXlMNoMsCuRpof5VjdKM2VWJSJquaY2w+SgQRwXE5s4aWoksH8q3i5Cb6Xs9jPLEnkqpIhjUyVBmTRBI8KIh+Cp1N0shahpl+5EceLUKZLDaeW79LCIK2M4mM3cGTy6Kay0GAeoOJjUMRlmGgsHC7e1RBXSL6ZJKZVmTUfYmqnwXARVOvwiuuJipHT0iy5l4399EfLe+6j/8xextAbxVz2fmh1i9uUIlhbQMxb5nYNseMclaPFHvGiCsQlkrY62eT1CVR9zHIW1Bs6BE+gD3RiDbb+PNr9atGc+njna4uNxEEKQ3jT4mNu7rjyH+Jo+1IRFbHXvL/HKTkfNpFAzTy3NVwjByOsvoOucUSLXJ7Vx4OfvRNNoKowncdZuRR9IE183wEs/sp7F42UevH4P059fQJE18meuxgrqBEtVZCjpGTIZete5NKaL3PSuvUTLZeqVCGt1Gq1nkFjaxIqrEAboi7MYBw9QjvVCfz/M1nBtH1vLIEOJCD1cLOI0HnbvaP1baS6niAhfGkTQqqeIcDDw0UFKwlDFUwVVMugE+MTwUQGl5QvSNC5vdq80v0A9DBo0v/glTWvzWXqZZHDFfVUlok686ciqhERC4EU6NRlvGaNVCNFYoAsTjzR1qkt5qvUu4r6HDFwmSGHhk6VMkgYOcRboRKNZ+BqhYhMDJJmWpXqOMmarQLVCigADHxUTQYEcRbIMMg2iKc08NOrEOMRGYk6RmFdEMXWUWBx9IE9mQy9z+5aJvnwbSkNlTtnA9J0pdp4Tkd05ghzKYqYMOq48Dy31yJKjf+gY9f/1z8haHevaVxC7+oWPOY6W//lr1H/yIMZgDz3/7e1oXU9M/LZp88ugLT6eOdri42kgVJXkltXP9mX8QkiueUQ8edMLABgDjz2NruoqO35rF9N3T9K5sZNUX1P89G7M8eKPXEr13WdTvO84cTPAW66SXNtN6AaMvHIHgxcM8OC/zuPVm7MPTqCS2T6MXk7jzi6RGukkuboT7/p9iKBGonyYxTCNQgJfSFQVPMvCa/iUZAceFpmogIJkWh0iG/cZdA5gSBsnsqhFjzicJrCpkMJBR8TrCMPHDApQS6LJZs1HgGxZr/t0s4jdck+tE6NEBlCRQA2FOkl8DDooYeJRb4mEGfoYESdJUUIjZE70sCi7SVNptQdHGCg/1TIMNbuDEQ7QJ2aRAsajYUJUFCKSVBlmkkW6KJBDQVIkRwg4xMixTJYyINEIMfGAOst0MEM/3zFfwwu879Ej57CjGKqIcITJrNUBwkf1JFLRkIaBsnUTWtTg1D3zuJ+9m2SxRMLSOdK/FW3vMZYmlhg4d5BV//gOjHwKof2HIuj5RaLFZaTvE03PNu9r2ESVGmpP50qXi5SSYGYR6XoExQphudYWH23a/JrQFh//iQkXl3Hv24s60Iu5/dEtvD+L+u7DzH/yGwD0XPdKErs2PuZju7d0073l0QIlLNeY/cj1LHzzLupFj9BKwvZtrLr2TPpfdR4Aqy8bJbVlkPqxOdIjeda/7kxOfvo2NM/B3XsEC4fUZbsIvncjZrVMVK9TiWKEio5QQ3r9g+iqQ0V0UdGHKNQ6KJKmHuXQgwUM2ay3QIFGlGgtj4hWO62gTgzD9JGqhioDVEXih00XUZs4tILfmss1BqXO9dgNSayxSIDER0dBrri1mrgoyJVaiyQNukUBXxrUMClGHVh4KICKR44yLgYLdONhMkMPNiYJ6iSUGgLoV2ZZiPrQCVCJSNLAprrS5hsiKJPFRyeGTYFcq4gVAlRiNAhRKdDBJmuMVe4p4tQJaRqqmWaVbsvG0l3G3CRL0QC1qiB3670McJyGSDIverA1g5rajTOykaGpe4jFIag5RA0X0Z3DnVqgcmye3Xd7NOpw/qtWk77iIqJSBfOFl1C68wBz7/k7tNCj691vIHPtlUBz1i37Gy+l+sM7Mdevwhh97FnGNm2eDdozH88cbfHxn5jqv/4/nJ/cj9rbRfYv3oW+6ucvqbjjMyszH+74DIldGwn9kNKRecxcnORA9uceo/Kju6l86xbU2SXUwMCtRxR2T+N1DdH/4jL5NXlyq7O85ivXsnysQP+ZPcztmadU04jbHka9RPXuOtk/eCUJYSO/+e/gOUS6TtnsIc4CiaCKKgJUZQk/zOKpCeKhQ0zO0mnPNEWKkNhRggppwlYnTIjAwiOBjV8HJ66w5PTQCDvJUcQwVFzPpEySDCU6KBKiUKiZZMNFEq20XJtYS3w0rckEKgYuDjoGDr0skojq+MRYkl3USBCPL+MEKsKLk6GKTkCIziJ54jToZxYbC18aQNRyQ1VwMVqzJZCl3Ko5USmT4RQjdLJMiM4CPRxmHX0s0skihrmIqgUofgelsmhZnz1cDSObjq4SbOJMWmtxlyRa1GA9h+ikQCALVESa4/2XkbtoK6986wDGoQpBqUry7E1Yq3rwZpeY+pvPs7xvmkKpi4WBM8kPxbn0HW9bGQ+LH/8/hCcniGRE9Qd3rIgPgPjOjcR3PrbAbdPm2aQtPp452uLjPzHScSGKkL4Pvv+E9kmcvZnEg0dX/gY4/tUHGfv3/Vj5OLv+9AWkhh9/alxNxLB6c/hVh6ChYytZRDaD1RHHTD9SlJhfnSG/OkMYROz9yiG0iRNoeGjpGFoyhl+1WZwIyfo6mqYSu+x8NHM1tRtuwo9MhKog8r2YHWuIpjzyS9PEZAOFgGqURiGiToKAGAvJAQLFhEqRTRxGI8BwJa6bJ0NESMii6Cel+gQ4LNGBh8HDRmJ1VyWJoDl/Img26QpqJAnQGWAGCxcDjz4WWn4jAheDOjGqXQ5azwzC12icWkvMyaDj46KRpUwcG4tmDct4tAqEwJc6opXrYmOSpo5K0OqSES2fkSIOBhoWGhEOFmXSCMUnqc0TKBo5fQHTsznBCKOcQiKoEsd3DaaiPqa1TSx4XezkTrqZI0kDjZBQGMTTKpdtmKZzWyfad+/HOTaJtXE1qbM2MvfADMrUKfz9hzFrASk1TqPTpGNViqhQxP/XzyFrDRLDq3C6e9FCl/gVF542ViLPx95/Ai2fxnwKBdNt2jyTtMXHM0dbfPwnwCnZ1KbLZNd0oFn6yv3Jt7wabc0qtKE+tDWrntCxzOFeBv/qOoCVtfnqqSJ+zSXyQxrz1Z8rPlIvOJdhVaF2eIpo1QiuK9C6c2RHO0h0Jagv21Rm63SuzaJbGiDpPHkveukYWtwgtWsLoruLaHiEuZn7KMc2EkuorPrt32bu72/GcGKMs4lcf4L4297AktdL9G/fJLF4uDWbIAha/h82cYRlkKgvIIVKWUtQjQkS0kNpmKhR06UDIVA1hTBqdrMMMk2ASp04CpJe5rBkgwCNCkl8TOrEmGaAVZwi3vI2TdAgwCBEo0gcjYA4Dm6sjKJ5CMXHMGtMOAPEcYnQsHAAUAjoYQEhIo7JtXjEMPBbyzo2MWqtWDqVOHU62ccqprifHURoSDySOEwwxHTUjxLajHCSXFDhXO6lQooH2M4SHXRRIEED6RtklhfIqEt0x+okbRdHJPHiXbjxDBk9Qr3nLsoP7Sa2eRWKYRBWGxz4lztZ+OZd5Crj5EURXdPY+buvQrt0B91r04Q33kxw213IRoPcFRaJz/81etwgvub02bflL99A+WvfRs3n6X//OzFHnljBc5s2bZ7btMXHcxyv6nDv/7iF0skC/eevYtfvP2Jbra8eRF/95NfR/6Pt9cjLthA0PBIDGTq29v38/VWF+oPHsB88grW4zOifvw0UhWBuifq8yk1/9yDFySqjFw1w0Tt3MP+tu0nai+iGT3LbKvr+9BqczkG+/+EHqWuDpOOCwZdtJ332BuLxHyNFiO3H8JxOZm8OqB69j5wDHajNdlo0RGtxIVJaYkyCEJJMt0fN6iCyQQkUcIymM6mSRI9pmI0iJnVAEkEr5C0AScvvM8LCpUYaF5MRTmHiUqY50zJHL2YrSdbDJEsJlQhtOY2iV1E9FbOmYFJDoiLwW54iSbJiiZReQCgRg8Ek9wQXkKZGkiqDYoqUqBJInQXZSbyV0NvJEmfyEHXiFMm3EnTLxHGoOt24SoFY5GHh4mOiElGkgwwNDF0h4VebWS6hhqMliKU8PD1G7NxtrP3Ny5n7n1/Ae3AG6QXQ2Uni3K2IoQHsL99L6vgDaF4FMZwlvmGI9LouoqVTBIle1P5esAzCw0cJ//2HKF19RKOjuLqCf/gkzp7DJC4+C+euHyEmbiWcjeEcfH5bfLT5laI98/HM0RYfz3Hs5QbVqTJ+1aV0bJEoiFD1x/ZVeCp0bO2nY+vjT4nLKKJ0aBbV0kn0pvBOzRLVbbyZRfzFEpUvfRf3wHHCodVUZgbxaj5Lx8uUHhrj5Ie+hFeskxndRN9brsbYuQVnroFSXKJj4TB65IDtcPKGY3TPPIQpplhW0lQXy+SWvk0Mi2p6gKXcWmKNAp6RxK/7WFGDopLHSKWI6UWEqSPjGmlnDtUPEJFFBBTIc0pby1p9BpSmc6qCRMcjRQ2VEB+NOnFSeBh41EkRIuhnGpWQOXqRQIDCHMOU6CSX8glqpzCkDXUV9cTqVrKtgkqIi0qaCoKQpBaQEBUUJUQCmtIMoms6lwRN91WpthJeFDwMdHwiBElqxHBxieFgkKGKgY+BRznK0cAnQKVBghgOO3kIWyQQimCRLiqkyIgaRTvONDk8L0GqOkz/2s3k3noV09MFwhDi6zYydtihcf23SC6PY7hl1HSCxEsuJHnJ2ZRu30tj92FUVRLfuApzcJTgngMERyZxPvh/CNduxFw7iNKoEy6XCCZmMEyb0JQoWQM91/44avOrxa+z+JiYmODDH/4wN998M4uLi3zzm9/k4osvZmlpiQ9+8IO87W1vY+fOnT//QI9B+93+HCc1lGX1FetYeGiW0ZdufNrCQ0r5lAK/Zm48yPHP3olq6Wz+vcvJvuISqjfdR+KcLSiGintkjHC5hGrMsOGiXcyNOWy5aoTpv/00YnwczY8Id66nlhtCPVUiuzrHlrUeC99dgEhi7z/J3KxkdL6ALjRiWkBF09EjD1166KvW0/G2d1O88whjd87hOAvowqMR76QzJUi7IR3LE4ilkLqRRUYaZhARotHQO9FTJrZIEGkZFE8houlmmqHaKtJstrT61NAJ0NWIWOjSKZbQCEhToSET+BitTBSPZLVBiKRGjHhraeVho7JmcqxCJ8toVhUZt5FSpW7HUCNJMciTZ4kUNiBZkh0kRJ2qTBG1rN/DVv5uHI8I0QzCQyFAEKeOSsQC3dSJs0yeOHXWMYaCxJQOMopRURMU6GY0PEXCq1EhxTgjlCcrVH6ylw49IBpdi110mb/tMP6hMSgXCCIbsztBbOsarFddyfgPDxDetBdT2gRHjtO4cy9SQMwTKL6C62uwUCCo1In15RCaihp4KJMF9EDB3HwG1rZdT2vstmnT5hfDwYMHueiii4iiiHPPPZfjx48TBE2X587OTn7yk59Qr9f51Kc+9ZTP0RYfz3EUVWHLm3ax5U1P7zhREHL8M3dQ2DvJ0JXbGXjh1ie1f2OmhFdqIFQFe77CwIvOJ/PC81i+4X5Offw7GNk8mmmQuHgXZ127a0XgHPp4gEqImjCwk53c+/F7SfWned6fX0o6JamkTIKGR3xzP4X8FpamDtIhJUt+BtvqIC+WidwQ6+QhZv5wH+Uoia9k0DUFkcyRW9WFM79MV20ZXbpNcy0vgUsSKXwCxaQn79IZm2TM6cN068QIcYWB1zPMkF1Hlot4mPiqxXzYiy5C6t1rSMV93PGTIJ3mLyRAIIlhE2cajQAbiyrJlq9H087dazmharhoBKiqj6cAMsKXMULPIE8NvSVSmrUnKeoyhdbyXgUFiUaNOA0iXAwiFFI00HEZYBoBHGcNXSyxkaMEaDiYRK3UXsKQvF6hZtbRKgFJqhi4eJiU02uw7r6F6vwiRtljbimGcnQaM6hjhM3W5MAJMLetZ3nfDIV7T6DIJLFVXbhTC0S1BoFUcIe3o0qfzNnr8Q+dIPJDgkSarjdcgViYp/ahHyMbFuFSGiX17AQ3tmnzWPy6zny8973vJZvNcvfddyOEoLv7dEuFK6+8kq985StP6xxt8dEGgPrEMrO3HMEr1Jj49z30XbaJ2gNHaRyZInX2BhIbhx93/77LNtGYLaPFDTrPHgEgKNVY/PpPcKeXMPryrPngOzD7Ok/bL3P+Zuw9R1CScWwvJPRCnJKNW3aIbx0lc+FW1LjJ4B+/gtHOPk6MKEx/9gdU903iV13cTAcjO3P4t99NwmsQx8CJb8boSNJ17igBGo2FCTwRwxYmUlOgq4+MN4fj6EQYpL0l1NokmphjWuaRgE5IqkfDC9cQlI/gYhKLqxRkB74wiXV2o1y6nWNfcDGry4RCJeUt4aOjIUlQbbqsElAniWhJE5AEqJRIAUnKZNBdg4YqiUUuuqe1fFabYiBAo0yGGHZLuBh46AggQCNEpUEM2fL1sHDpZIkcZRrE0PHIU8DCIUJhkQ5cLKqkyMkKSijpVReIU28ZwSvEaWBu70fVlpGqgjk6QKVhoS018DSdhOFgiBqelsDNdJOeOEzfzP24A2vofs9bqL7gAha+fgf6yACdW3qJbxwmfd4mZj74Key9x9D7uqh0jLLvy1MMuUkSqQRRLPsLH9Nt2jxdBL8A8fELuZJfLrfddhvvf//76erqYnl5+VHbh4eHmZ6eflrnaIuPNgBY3WmSqzqoRhHZTX34SyVmPvU9nFML1B46zuhH3o6iP/ZwSQ53sP19V552n5qwMHvz+MsVzL4O9Pyjf9kaQz3ENo2gmDq5F2/EWtTJjebIr+tArMtjDnWjxk204T7ihsrIxcOMfwL8EEIiCjWd9Rediz52hGDCQdc01r1mJ9YZ61mYsAnufoCkauMkY3imS2gIunts0tnVJEKJk+9H7NmDZks6urIsj2vEKvXm7ET3MPVkjvqBJTTpEYSCYHg19bk6C3Y3S5MWhY5LqQmXakOwnbtaFucOceEgZIhGiETiYBKgkMTGwmaYKarEmWCIKBBEFcEw00R4+K0QuzQ1DHxcDGyaRmkOBhVSGC1b9hgOKiFZKsSp46Nh4KISYOBh4VMii0+DcVYxzmp8dFYzRodcRgaCVHEcCwcHHY8IiWDhxr1Ef/8ickqN/Ib1jH1hkuNfS4FpslY9SWLsDrxIQV2eJ/79z5EsLKF0uMQ6NLJveQH911yMYmgIRVl5rbvf9Vrsh45hbRrhzn+bZmI5Sa37YjZl58lFHo3b7yd+0RNPZW7Tps0zQxRFxOPxx9y+uLiIaZqPuf2J0BYfbQDQkxbb3vsS7LkyydWdRNU6iq4hNAVh6PAU6kAUQ2foD1+NfWKG2GgfimkAzbqSuf1LOFWfgeefhZaMI0yd9AVbWfUfrLqT29fy0L+Pc/CjdzJwRgcX/OZGclfsYnoWcrUpusN5yjfcy5a/eDOV79yOtX4VmXddyx2/9U8oP7mNMIrjZ3OY6QgNGyOm48UkXmc/2Qs20f9frsG5+yHK//JvyHpAJnJQDk9jEpLflKP3ZZdz3w8OYNklim4n9bLOctRLrZpj2NfY+uYdHLxpDvO+vUhUSmSZo5sRZYr+cBoPjQiFBnE6KCKRze6ZVvJKhSRV0qiE1Ilh4v5UiJ3SComL4WK0gvIMYq35j2aInNZa0nFRCdEJsDGokKbR2i8ixhJd7FXPxA5NDFxGGKOHxVZPUIhKhIKBgiTEoGvhID/43C6yI1lqXznAppev54I/uo5iEcy3vwWfMlHkotxxB8FiCVORUK2y8E9fY6F3O9kLNjO0s2vldYxcj+qXv4d79BSKfD6d6/qYemgRrWcziXqJcHaByr/9AOucM04bJ97B44SlKtaZm1Fi1lMf4G3aPBV+AcsuPAeXXc4880y++93v8o53vONR24Ig4Mtf/jLnnXfe0zpHW3y0WcFIxzDSMQDUjgwD73ol9okZktvXoGhPrZBVzybRd60/7b7ZvUvc+tHdeDWf7a9dz47Xnf2Y+wdeyJ4fPcCMexvz+/JsnHwnZ7/vCmK9GQr/8FkUO8Adn8XpHGLoE3+BmknizBfJP/BDLHeaukwyVjsTVVpgptCImAl3cJALOGfDVjLxOEJTKO+dwC3bKOkeZDpLYMRYmvDgYIlE3iA+16Av3Es0d4A5pZ+D3S+md0Cls0enr8Mlii2g1t1WjYbJPZkXcoa3m5w/R8atkaKGh9pyLQ2hZfjerNwImss62CSpt4zTwUejSJ55uhEILBxCVOLYLbHhARFVsizSRY4iUavJWMPGwKODJYrk0VEZDsc5wkYyLBPDBSQ+GgoKSqseRVUkqhA48Tz1xRqNBw6h+B4PHThKdmEdolBATMyhhD6iEVJdsIkyq4ipPuGsS/Wjn6eq/YBjO16I85pNpM9YTcdZI4Snpmjcs5eoXKP2/dvZ9D/+mP6JH6Me3YMfBDjSRBvowZ9dpPHdW4jGJ1CH+qnfux8mp4hfeRm59779KY3BNm2eKr+uNR/ve9/7eNnLXsbv/u7vcu211wIwPz/PjTfeyIc//GEOHTrE//7f//tpnaMtPto8JomNwz+31gOgUfZw6wHZvtgT6pRxqh5u1SN0IxpF53Efq+oKct0DOMt3I+JJKuJyugefx86rhjj8VYE94eINdmH05FdCyTQRYqoRQoAbmSi1KmEkKNRGceJZ/J5hqIc4FQ+AyS/9BG98hiiUNIw+ogsuZ35JZe6eIiduu4ktik9cdUiFNRTZ7DWJqfuoTcBD37wZpVYh6RdBSBTpsJ4jeOVJ9PN2kN03TtxdQiApkqFBAhcd0bJm9zCpkiJBdcW6XUHBR6NAnqOs4yhrGGIGhZCUusxgfIxE5OA1sgSymdJ7kKZF+RrG6GKZCBWViAQOVQJqGEzTj6Mm6A4L2Fitdt9mnkzTkVUBoSJedAWJ1TvIH1vGHq9jNZbJjBc59t93o3oOeUUhJZP4wsApOLhCEoUa2cYCWhSSxCZ5141MHrkXObKGVde9iJFX7MBYM4w/MUts5yaUuRli+29HFpbRu3pJvOt3UNIp5j70L4Q/vh0taaEP9cLJcURhCT+wCd9wJepg2wW1TZtnmpe85CVcf/31/MEf/AH//M//DMAb3/hGpJSk02k++9nPcvHFFz+tc7TFR5unRWG6wff+4TCNksd51wxzxgt//pfD0Fk9bHvVOtyyy5aXjT7uY4UQbLp0DY2H9lA4Bd//uzFe/Mb15PYfINUdx7S6Sb7uHDp3rQZAhiH2p75MIp9iqRoRuCZrg+NUSDGjDBEf7CZ/4SDxjcOsff4Qbt3jxLhGwughXp4hM3cEvVfD2HUZE/uOEzgRR7UeVlkSNfSxojqhZmEXG0ycPEq/P0EXCytZK0mqaASIsETxjgZQQSdYKWJttuzGcbBa3hsxUpQZ5SQqPj4aYwyToIFGRII6SeocZBP9zLIpfg+5xCyqlOihpOZ00s0CXSzjoZIVZUJUKjIDCGokOMUwR9nAQ7ELMHMJNpZOoDf2EaEikNgihSIhRKGidiFH17Lh4n7Gp8ewszX0wgRW2CB0FWwsClqKqprE9yETVFBEs/TVw0AQYGOieA6yEBFGY9T3nkR984V0/ulvMvvZHzG9ewbXSpLu60e6DtrmLRjnbsfec4SoVEcaBjKMMLatR+qS6FiI1p1D1upPd7i2afOk+HWd+QB405vexKte9Sp+9KMfcezYMaIoYs2aNbzoRS8ilUo97eO3xUebp8XiWI2FE1UCL2JyX/kJiQ/d0tj1hieWsguwY9PrOPRdyaFvFJhfjBMLx3j929Zj338QzQlI71r3SE2K7xMtFYn3Zkg3fBLzBRQCNMsj9rIddFx9Eauu3oEWbxZLPfDNccaqnfTIPMPaIomgBrMTbHpHhj3fVOieOYImBQ8ZZ3HC3MxgOIYVNCguScyoQh/TxHGIFA073oWsiZ+qxZBUSDedVlFwMHEwCFCwaDBPLw4m29hHprXcEqDRzQKgYOKTpsog09zO8wgwCCITpIBIEkYaPhp5is0EGtE0I/MwOMEID3AmAQYH2EKFHGvMSdTlBjVpIRAIIkCQETU0NWBCX4tqqiS/9jmmb+wjV5qht7SAF4bUSDbrQ3QdhEQGIUoU4asqiqFjhyq2mUELbAphBtXQMLNxtHyG/Pamy25Q9yjcc5xgao6FWgPrjFHo1NAvfjFCCKzNo2Suuhh3ywiJbWtIXH4ecmER70e3oqwaQl2/5skOzzZtnhbPhvg4cOAAH/jAB9i9ezdzc3PE43E2b97Me97zHq666qondIyHl0d2795NFEWsX7+e9773vVxzzTVP6loSiQSveMUrntwTeIK0xUebp8XA5gyrz8xTXXLZdEn3z9/hCSKlZH73FPZSnb7zVpF0dqGWxgmJyHRbJM7dRmOuwsyXb6Py2ZtZlUyQ2bUOYVlY176cU3/wf1iYM0mFMdLSQyWkqzFJV0e4IjxksUjiR99i2F7G6+8jshsId4HUxTuYmYY13mE6xCncwEJU76ehZ9CDGgQumSgkS9j0KCGgoaTxAqCVQBsoYGpVbD9JXcZJUiNDhRgNJIIYLiYeM/SSotZ0NSVERTLAPKrigiJpyDhRqGDhsESKyfp68mEFGQnGvHWkmw4gmDjM0kOGMiEadVLoBDjEWc8JphjAqIZokYeLRknNkwmLaHjEohpCKOSTHqEXoC9WSC/M06xL8VE1jRATkU6R6+uA2VkcXyXwVKItm5HrhpC33IUSNoiNDjGYiFG3FeaibvKb+ul5WbOmR40bpGaOEJ48iRYs0FgyCCs2Ue5mjG2bUEyD/JtftjIGIs+ncHyZqG89+Yt2ntY506bNL4NnQ3ycOnWKarXKW97yFvr7+2k0Gnzta1/j6quv5pOf/CS//du//bj7f/rTn+a3fuu3uOKKK/jwhz+MqqocOXKEycnJJ3wNo6Oj9PT0cP3117Nhw4ZHbf/Wt77FH/7hH3Ly5Mkn9+R+irb4aPO0SOZNXvHnWwgDiW7+4mzdC0cW2fPxO3AKNqWTy1z4xm0omoJhqbzgHesA8Bs+fsWBuoc7V1zZV92xlcPeKKGiUXEMGqpF2rdRTs3jTcyuPM773g30PfQDkqHg4OrLKQ2dSdfOJHMzDoc/9wCpQgWiiBxL6J5DzU0hFEGPnCVEwUUlhoOLxWRsA0YmBrNjhKFCNjmJptt4fgKn0kmWCgpNR1UdH5WIAWawMQiFgqVXQEqiwESTPrrqNj+1pGQ+6mVZZggRCBRmnDWYuKhAiQwSBQ+NsswSp46BTycFOigyTxd1kqzlGNPhIFMMME83D/S8mP7aUczKIknqqEJhvhIjHZbQAx+XGBXSmHgsp1Yx8MrzGb1kkOBTn8GrVpgvGlT6VzPwinNIX3Im4/fdh15yicsGMT3CPV4i6OhiTFvDrlBv5gNXq6R7YgReHpE3mTth4xdryH11di4soiTiiERi5fUp3XWImU//kMjziVyPvtdf9gsbX23a/Kry0pe+lJe+9KWn3feud72LXbt28Q//8A+PKz7Gx8d55zvfye/93u/xsY997Clfw/j4ONPT05xzzjl85jOfedTsR61W49SpU0/5+NAWH21+ASiqgvKLjZMh8gJCLyQKQ0I7oHddmlf9t20A2HMlqnMu0jAxR/pIjHSRPfcRda7FTfQzNlGaKCONgLqqYqgaeroD89wdQCuL5qYHUE7NITSLhWSM8agL/+i9mIVZlGWJr1n4oU6OAt1yngI5alGaHrGAIKJKHIc46AbZLX0MvmATsw+OUPzRXSTVKTQhiKk1siIkJl0CNApkidCJ4wKQpUqkRkRqhJDgRDoiBCXyQYkIpI6UCts4hIeBhYNCSIhClCvB4BxeXcUc7yUeORhEJLAxcQFBH/NkOEocmxpJbuJSEopP0Mgy7+YRRpaK2oM11EX3zEOEbkADCw+DOgn2cAaRm6TsrGbo5EnUk8dQl6uYQZqam2fqq/ew7bwNOHqKQK2hmiWUmNrsckrH6d2QIZ5tts4qPV1YF52N9+ABgs3bOImPv1Ckqxbg/M67iZaLKNe8lvjb34jQdYSqNFu9QwWh/oIHWJs2T4BflZoPVVUZGhrivvvue9zH/dM//RNhGPLBD34QaIqERCLxlCIz/uEf/oEf/OAHvPrVr+bP/uzP+Ku/+qundO2PRVt8tPmVpGNLL1vechaNhRpDz1+7cn9p3wRHP34DteNzEEXEBzsYuGQHRmcGgPLecfb+3Q9xj9ZodA1jJXoJarMsGgaz+jDcscC2Tasp/+Bulk+WMbrWECRz1HrXYTmS3omHSJRmMDJrqZxzGYlbv0iyXMPAwcJmUQVdRCBBkSolmccOLRoHT1F0SyhuRCG1hkKYZdA7QNL1GZDLLW9TgYVLhEqVZg5MhEpDJshJFSEjqjLDA6xFhgr90RSdsohBQC9zBOgYeEgEPgalgUXIVbFTgljBIl+KaDqoajRN6zU8NGLY6HgkqbGLB/AiC7dsccjcgaUGjJ7Xy5qL+6n8zx+gtIzKGoqFEfmkaOCgU5uvUejV6c7nCJcb+FIj5lfxC2Ue+vsfUZl1iacroM2i9/fR9aJLGLzszWRXZ1FkiJQCoarEf/uNxOoNZCzGcOcRpnfPsa56C9HNB4iqdfyvfQfj4vPRt24kc94mZBASOR65i56Y3b90HIJjh1C6elB7250xbZ4ez6b4qNfr2LZNuVzm3//93/n+97//c2s2brzxRjZu3Mj3vvc93vOe9zA9PU0ul+Od73wn//2//3eUJ7F0mcvl+Pa3v80HP/hBPvjBD/LAAw/wxS9+kUwm89Se0H+gLT7aPG0CN2D5RIl0X5JY7hdjBCX9gHS3Rfe2HuJ9jwz22tgijckCznwFVVcI80mCuruyffqrd1HefRyl6JPqXcvgy3bRvTbF4c/vpnZslhNfuZ+kUkfcfjuy4eDGciSvvZpLzzgDMTlJ4l+gPGuTrR+i64w+kmuz8ABIqTT9MwIbH4VQ0ZhRh5jzOxBEmHaVYKKBnorTnTY41XM5h9UXkrnje8BRchSJY5OmQp0ky+SpkcDEpxpmmIsGieFSlJ0cYTMnGGWTPMQL+RFpqqSoUiVNiIpChEMM6inCtI3qCGJORIISChHL5HBUHUOrkwgdykGKJHXqJIhQmiF0UqcYZXhp30OcoR0jONSJ3Z3DnW3WmTS0PLaRIReGKLEGonyM5BVXoXYFFP/Hl2lIHUNXIHKx9xxsZuhGzaqVUDOI7dxEfn2e+v/7LuVb78U8dwfGZc8jqjvNZFtFcOYbNnHmGzYR3hXHOXIf4cIyYnCQ+sl59D0H0RtlMuefg7ptO/7UHPYdD2BuWI2+auAxx43z/z6Hd+uPULp7SfzBn6H09P5CxmObNk+XSqVy2m3TNB/XJfSP//iP+eQnPwmAoii86lWv+rneGseOHUNVVd72trfx3ve+l+3bt/P1r3+dv/7rvyYIAj7ykY886et+//vfzznnnMMb3/hGzj77bL7xjW886WP8LNrio83TQkrJvf/yEKd+MkVuVZpL33c+VubpC5ATn/0JY1++hyiQbPmvL2P4pWcAkN81Qn7XCMk13ST6cyRGu+k4dy0yivDKNrGBPKmBDE7QQAD2fJn4eT307OiBahXdVKiOLZGMJEZvB3bXILvvk1h7fsK62kMU7jkK9QYNkojb9pAZ1amkV6GX5wmkhtsKq3cik7moA10NMCMXIVRqsS4KUTdGT5bXf/RsDvzFl1m0Qo46m+hgkTPYi4VLkSwH2MJqJkhRxUdnTg5SI840A0wxQIoGc/RQIU2eAhKFCglskkQIZunFPqWzunAQy/WJO3UMXCQCDR/TKhJXqygRePUstoxTJEeVBElsZsQAR+PbuKp6K/O3nyKMjqHs2E5nIiS5WMOIQWFwGCu08WcX8Q4/yL2/XyY/GCMmkmiqg9mTIsokiUoBVjIJ+jaEOURi3Q6yO5+PrFSxb7yTcHqOYH6ZpZv2EFYbmAbofR2k3nA1ibO3oJ5/LrGvfgbt2Dil+09Q/OS3yB2/j3h3EnHzHQQvvRr7rj34k7OY60fQXvdKZm46RGJ1J6tfe85ptv/h5DjSbhAtLRIVltrio83T4hc58zE0NHTa/X/5l3/JBz7wgcfc793vfjevec1rmJmZ4d/+7d8IwxDP8x73XLVajSiK+Ju/+Rv+9E//FIBXv/rVFAoFPvaxj/Fnf/ZnT6lN9sUvfjH33Xcfr3rVqzjvvPN4yUte8qSP8R9pi4/nIJHbHIAP21A/m8hIsnS0gFtxKU9VqS/ZT1h8VI9Ms3DzfhIjPfS8cPtp65Llg7NUji8S+SHHP3sXfRevR09axAfybPvAqwFWuh9kFHH8U7eydO9JcmcMsu2vr2HsrlkOf3+cwr4Z9pyYJtEdp/usIXTPRo6douErdF5xPnMLSer3LaEduJP60gMIx8EmRoEshmugXnge+mUXcfDbx5AP7aWbRSIkZbK4GKhhgKIrqJbBTHINM+oQjc5NXPjFr7Fh9xcZCOCexEUseEO4/lFAYYwRulgkzxJpKpTIcpIR4jTYyR46WeYBdqIhKZMijo1CRByb/ZzBPF08yC7Oju7heeUasZbzaYiCg4VExZcGATpC0sqFUVsuqCVUAX3aIjuce5kPLUxfbYbJ3XsnZtZEjafQsj6drz6Dxr5jLD34IKEjUceOM1/sYyiQ6IpA2A1UQye3rp/ubRuoHp0lufMcul54CYpugmZgbBzFbdjIeJJgvo5/cpLGzBwikpT3jDP40T8hsX0dSlcXZlcXwX3jRH5IGEJoe3iHxqkvfxtZrqLl00QNm8mv3kPh8ALFfZPkzhgmt3VwZdyYV70GoRsoq0ZQ1z66Sr9NmyfDL1J8TE5Okk4/km/187JRNm7cyMaNTfPAN7/5zbzwhS/kqquu4p577nnMGo5YLEa9Xuf1r3/9afe//vWv5wc/+AEPPvjgUzYHGxkZ4a677uK6667jc5/73FOqI/lp2uLjOYZ3/BTFf2pGGed+5xqMtaue1etRVIWtr9rA4e8cp3tLJ9lVT3w98NRnbqW8ZwyjK01yTQ/JtX0r24ZfezYL947hOwHJ1Z0oxiND9WHRsbhnivm7x0ityrF070nsmRIyjFh1zfl0N2DmS7eRn9iDbiosL49inrWWnm1dFG44ThhKKuMFjDtupftUlcZyDT8I0YRKSXRS0HrJDPdT23o+a990PqfiP2T8WIV6o1mrMamuxlMsdrCHAatAo2c1GXseZXmSqjOPPXkHyVqVWKSQcpeYC0Y5wVp0PMpkyFNAp+nL8XAQ3Hb2kqVMH/NESEpKL8mo0XQeRWDirTiXQkQXi2gEKEggokIKlQATj0Wnk8PaFvzQIi9sPAzKMkUCGyFdRBSyOjyKEdnUSWLhgvSplkM8qVAdGsL+9I30N04wGE1Qw+AEayh1rGEoHyNWn8GvuWjZBNKp4nzzi8QbNRJ7dE7dcCPjv/FGdrzrItLvfBPB9DwkEsgv/pCZZR//1DKa28Cbq+LcvYfYqm6UbHPcdFz9PAC0YBdGTqN24wOIio1x5hbiOzdg7dhIdc8S5bECZkcSM/9IdwyAvm0n+radT20wt2nzDJJOp08TH0+W17zmNVx33XUcPXr0Z7a/AvT393Ps2DF6enpOu7+7u2mDUCwWf9Zuj+Lmm29m06ZHezFZlsVnPvMZXve617G0tPQkn8HptMXHcwznoSO4B0+s/P1siw+A0UuGGb3k59uw/0f0TAyhq6hxAzV++q+Anuet54Lr387MT8YYuGQNqqEx+aNDTP3oEF27hll11TYOf/puSkcXSAxm6FrTgwwjcjuGMTuSyKVD9EYzdAQTCKkQTtvMLtvYE73071xNWHUo33cY9+AJDDfECSzm6EW1dNJXXYyy+zCKXyEsl9l33ceo7p2luvkcKgePsE49Tko5xZKbYq1zBC2KaIwJ/EjBQKDOTTPr1+gPDOoyzolomACVk4yQpopCgINFhIKPjgA6WG5Zq4cIFNYyzqwG494qulnEwuFBtqMQsIYxBpilQJY5euhkGQ+DRTrJUUYlIB01GPNSTNPHXtHL5swkO/z7cRzBMTmKFTnkZQFDDXDUDNOeQTdLeJHGdH2AxcMGvcyi6QXMrjiiIUmtHqX/TRew9aXD2LfdQ+PIFFGkEBy5BW/yEJaoIQoZ4rbP7LdvpXjBILldo+ijzbHR+4dvYKlnMxN/+n+Jl6bpDWy44Qaqxw+R+tN3EklBNDlD92svQe/vJqw3yA6tIqjaJM47A72/+QE6us2j48zVWD0Z4v25pz1+27R5LH5Vul0AbNsGoFwuP+Zjdu3axbFjx5ienmZ09BH36JmZGQC6uroea9fTuOSSSx53+5VXXvm4258IbfHxHMPYMIIxOrjy93OZkd++gtzZa4kNdmB0ZTh+0zihHzFy8RCqJnjoSwdZPLDI0pTDeX9wDmPf2EN1ooC9UKX73NXoKRNFV9ATJmt/+/kQhJgdSRRVwepOo3Z3oBQzxLoSuJMJPDeiuBSQ7xuhWpvFLQQIJ2zmuloJPKGjasAdB4ilVLSUzuwnv415/CBxGbFqTZX4cIPYbA3CMqbaQCFECQMMaiySxcBHrZdRcFikg2n6sZUkrjQ5rG3lQv9WulnCxaRAnhQVAlQylCiSJUBDIUIlIuaVOMR2xlmFpDnbcxa76WaRGklcTG7nIoaYWGmlnaebTRwlQnAmD7ANgwXZw4BXpNuqUs90UpAGfh1CkcMasHACnYVjJQzpAQrFME25quIZPcRzFttykyh2wGi/i74lR+EH91B4aJJiejW9l2+hZ12duYkH8UKfhBKhNYrExw4w8w9fQnv3q0mf88gvqKGdXcxvGyGs92K5hxGuQzgxTXBqmtK3bsF96AjG+lXk33EtjU9+nmi5SOzal68IDwAtZtBx1uPb8rdp84vg2RAfCwsLKzMVD+P7Pp/97GeJxWJs3rwZgNnZWcrlMmvWrEHXdQCuueYavvzlL/OpT32KD33oQwBEUcSnP/1p8vk8u3bt+pnn/OxnPws0LdWFECu3H/d5CcGb3vSmJ/fkfoq2+HiOYW1dR9df/T4Aau4X0/L0bGHkknRf1vTuOHnLKe795z2EXoTf8Flz6RCVqSp+w6cyVSEMJKmRDpzlOonBHLGuFNvedQmFA7Nk1nQS+w/T710XbcTovA5x6kUYmRjeFycQeyfoyLjUPv9N7MCgNl1BM3MIU6fjqufjzy5iP3CYqOHgaxY13YK5IrofoiAxM3EO2RtYXZ/CUeLUUz2kgwK6X2ch6iJJg1l66KBIlRQCSUOkwDCwtQ60WJKNhaN0h7Ms0Mks/djEMFpupxEKi3Sj46G1vDwGmKFKijQV+plllHFiNHAxsTGBkDTNzJMFutEI6GaRDpboYgkPg5geEkqDegPcNatRdr6Y3vIkQ2d20nv+CAf+8F/wtRqeb1JTMizoA5RkCgKF0nQGvbpEyvAp3jHB/r3fYlViGc2pUDUWmSuanL9rhCi/lUajjEyBqUREC8tMfHc/C7UYZ/32AkbKxLxgF6n1faz7zYuoHpsj37sdde/9qCOrUFcPES6XkX5AWKrhHzxGcOQE0vPx79uDdfmFv+zh2abNs8J1111HpVLh4osvZmBggLm5Ob7whS9w+PBh/v7v/55kMgk0k2c/85nPMDY2xurVqwF4+ctfzuWXX85HPvIRlpaW2L59O9/85jf5yU9+wic/+cnHrDN561vfihCCa6+9FsMweOtb3/pzr7MtPn4Nea6KjtAPmT+4TCxrEpMNaruPYI32k9y5HhlJAiegOl1h6p4p1r9klA0v38DkbWMMn91LLB9n6zsvpXJyiXjeJBqfQGTzDF62/mcWPgkhyG4ehM3NWaKLt2xh+WOfI/rmjdjHZ6jEeogSvXhhmiidYqycxVB08t0LaCIkdekOxmbieNkh/P0CDJ25+DlMzPicVF/ISHiCNXoJd3gds9M20naI4aDpGtP+ICYeRkJHs0x6qvPomoabGECpqlihSzeL1Enh0vzFEqARoXJKWcPeaDMXcht5SmSokKdIhgpJKsRpzrZo+PTQdCf1MaiSxsShn3lSVMhTaHa94IIvkb5ggtUc3JOhsX8308Pncdb5Z9O3f5mR4TTVo7OofoghXQbkFJ1aAs2rY4Q+tarAikp4ooMlNUbGjNMVCwgTWeIJqP3kEO5cAjOeJrsjS2OuyuK+OpUgQfrgKYr/cw9Jr4A/1IuzYRvJndsZ/JMrUXQNGb0MhGi+Xm++msYdD2KduRlz61r8ex4gWipgXHjOL3WctmnzMM/GzMc111zDpz71KT7xiU+wvLxMKpVi165d/O3f/i1XX331459LCL75zW/yF3/xF3zlK19ZsUf//Oc/z2/8xm885n5jY2MAGIZx2u1nkrb4aPNLY983jrH/68ew0jpblMNEE1OYQ90Mf/C/sOp5gxz74UnqM2WWDy8xddcU654/RNf+W/BvvIN6vETyykvJb+ym8JF/Yv5rd1DVc2T++O1svPbnFxhaGYuk6tBQwUzoZAbSxAZ7aAQGjTPOZWZviKvl2HTdKxg+I0ty+yiJH53CLtqMT5zH2L4qytwsOa2O05Ojv1rB8qrI5ZDI6sB2VRTdYNN5OZbuGyftNcgrNo6SpRqkCB2PWscwB5fOIEaRBnF0AtyWcFiigxopHpI7IR7Da1h4mGj41IkTxybAYIGulmFYnR7mqZFkjl4gQsMnLmoMK5NkRRkntJBS0MEyIRo282wI9kMgiGYMvv3/tmN193Pdi9+Kd+qzmA/eR0w2SIaniEsHI2ygEiAijUAxyFBhS/wk1itfyVmXGDTKPsHMAqVbjxFNzyK7ssRe9XpO7fcZm9hPYHskomXciTlS7gz+1CTBPfso3HsCNI381RedltcSO3c7sXO3r9xO/7d3I10PJZn4Ga9omzbPPM+G+Lj22mu59tprf+7jrr/+eq6//vpH3Z9MJvnoRz/KRz/60Sd8zlWrVj3u7WeCtvho80ujMlXDq/mEro+XCk4bfJqpMXRuH8Vjy6imiqKr+OPTuHsOEVXr2DffTfLKS5t/7zuBv1BEqC6TNx5iw+u2P6HQsfgrXwRRhF5pIF2dhe/sIQoiMutGWPf87eiWyoY3rCfeMkrb+trm2urWWsD+b49x4Ivz1CINww6QfeuRJ3ajhAGdfTpLukGYztIXK5HWJzEaCyg1EI068bCfVKSxI9jNRDiAJbaRNhxqaooZO0dB5pFCoVvO8nr5RXw/Tk1PUvYzFMkQoaLhk6FIiTQRCgnGkQgMPDKUUQmpkMHGwkclkAqRUPGk0XJXBQ+DhOYRaSajq3xOpkPM8jgn91RZv66X6ISJcGyUZAytUsPAQ9MFSkLFUwyEH7AhNkmudAvGt2vYe8aok0GqGlI3qHs64w8sU6/odG3qpLFQI1M4gliax7EkpuIgG1XC2m5mPpPFGBkgue2xazeErjdTdNu0eZb4VSo4fbaRUnLzzTfjui4XXnjhU/IL+Wna4qPNL42NV47iNXySPXFGLzwb9+AJrDUDGD15ANa/ZC1mykQzVYbOH0TYDfQNowRTs1jnNX8RK9k0qVdeTnGyhmP1MXD55scUHuH8Iug6aj4LgL55PZnN6wGo/v3XCN37CIWOUw+5/I+bsydSSk7dO0dlts6q8/qIVU6hFJcZ7M1yammMytEytUQvUz0b6XntAMru+wkrddI5k6g3hdWXwu3KEZSWUaTEiwR1YggZoZw4RiIymDDWIPp6UOdnWc1hhtQZ6lGM1Zygj3k832BCjLDP2MHR9VdhHN3Hld73yFOgQYwbuAwFyLOMh44CWLgIJMflWjbJQ3iYTEXDTKhrscIKCeqMs4p+uczAzn4uOD/N0N0fY3GsxsShAcZiNqtyOYjSiL5uIrcXp7hAIqGgbN9EpWKh3P4T5OQC1e/dTpQzqU8VcbIC/9znUdV7KYcpqjcs0i9nyGowPJKn78ReDLeEH1oIEwQKca9MsebgTi+R2DrC/PcfoHjvMTov3UrXpU0b9ahaQwbhk1pilHffjfzRjbBtG+Lqq9opuG3aPEX+/M//nDvvvJObb74ZaH4uvvCFL+THP/4xUkqGh4e56aabWLNmzVM+R1t8tPml0b0hzwv+4vyV26lNpzv+6TGdtVf81C/hVJL8+64jKldRuzuA5ppm5vUvY9OrXoRXcYl1/uwpeffuB6j/61cQpkHy938Tfd0jnUHB/BKx8UPkMxG17gEG3/hIW9nyyTJ3/NM+aos2hbv3ckbwPaLiMnWxGkN0YEgXxXWpNlT6XncxJ45MEZ7Yj6o7ZPpSDF53LYX+rcx8+HqsqIpLDJ0AmzgNEuh6hJCC2PRxOv0pepgnEgYOGmbLoVQhpCzjJGnwijclOPSNDOIeEDJCANP08SA7Wc8xdrKXDGU8NGbVITaHB/EjizJ5luhmMbsWUSkz7B9ngBkOBxu5e/kCXnPPrTQOniTbWKYUEyxmt5JOqBimgrlphLXvfiknv3Q/kw9NMDsVxwqqrPY1dBlSdXXmy1mo+8xag5z16ouRpxyOf2MM48RhHFmlazTFhlduwT/egzxWIzDjGCkdRQYonkLMr2H253AXysx8/W6cuSLOfJnc2WuRc/NU/7/rkb5P8r9ci3nmz891kUGA/NKXkSdOwokTiJ074JcwddzmPze/rjMfX/va13j5y1++cvurX/0qN910Ex/60IfYvn071113HR/4wAf43Oc+95TP0RYfbZ51ZBQR2h5a4tHOqIploliPrtDWTB2t65EpeSkl9XsPECwWSZ6/Df/wCYLJWYSmEhwfP018+GNTRFMz5FZn6T1vmM6LHwmui6Kma6uMJMKpETkVpO+jeEXUBZ9MTKE+OsDGV27Cysex9TShq5Colak/eJQ97/kC4ryzUYRAAVLUUIlw1ARLXSNsOzvG3N3jpCdOYuHio5JUXAIpkKGggUWJDEt04+V7Ke6dJKF63B97Hpsbu6mQ5Pnc2XweNJNeqyQpkEUP63RQaEXKhRQ61hIrz9MRzJCjiErIALOcKMC+yYAtwRQ5Y4F4KoA3XYmV2MDynUfJbF/FF/6vy8ytJqlGlqxRRaksUhdJ1Ein6HbzkL0NIV0sR+PcbJoLXr6VKJvnwOcF2eNj9IYVYv050l/53xQ+/33inV2kUwL7h7cR3bUP/dA+Kh+7nu5/fD9mdwavWMfqy6GYOs7hE/gnxiEI8fcfeULiA1WF/n6YmkZ0dMIvKPyqza83v67iY3p6mrVrH/lc/PrXv87mzZt53/veB8Dv/u7v8olPfOJpnaMtPto8qwQNl+Mf/wH1kwv0X30WfS95au6UzpFTLHzia4SFCs7JGTpesBN/7yFEzMLYfrpTn7FxFLW/G++BgwhFIMNwJbK9a22G8/7LViqzdVaf04m5P060OMfiAw6ZVWWSisbWN61n/Ws2YlgKvZdv4uRMEXPqEJ4X4B2dpRIrgGx24IQoKKpA0TV641VyHTH8cJ44FRxMDDVJh7qE4S+j4JHApkaKmc5tjA5GrPva/0CJQsaCAY6zljh1ullCQRIBdRIta3UdnYAyKQI0ZuNrKJRUdoUHsXAASZ0ktUQPg8kisiYIFUGkanT0aeRXu+z+ynHE0iLuYYtqcYDAShH6ZXYaB+iYu52Gp7Ff2cY+63ziso5qgRbXkEePouxI8bw3r2GgwyHxie+RlHXkV7+K/MN30f2hd690JHnxLNH9R8Bx8acWkBLWvvtluF//NrGMRNSqGFvXY2xah3Q9jJ1bntDrL4SAd/wu4rLnw9AQIpt9SuOoTZs2oGkartsM7JRSctNNN/HmN795ZXtPT0/b4bTNc5v62ALF3WMEVZuFG/c9ZfEhgxAZhsgoAj9A37ye7N/8V1AUhHb6MFezaZR0EiWXxjt0Av/YOMbG5tqlEII1Fzaj2CfvnuLB25N0nHUFnZcuY9fuw+rNsfZl61A0wdK/3YR264/pySl46y7Gvv8QNZLsXR5gQOkijCQqoK8bYc1wDnX5JIs3TmPaZQxdYqsJarEMYVAhUiLioY2LhdaV5w1/s4P9f/5l0t4ihvRYEinKpKmSRiEiRYMGMYSqImRIT7RAnjIHtG3ILVtZnrQZauyhk0UEkjl6OKZuRNmxk5dcmqTwOZdKaRjTNJC5Dez59DTyljsxpEdUb3DpOy9ibMsQz1OmyP3fe4i8Gaokm62/lk2sN4ddctgQPoT851sp7/0xh3dcQ3m6Rs90gNsok1zaj/zrj5P8jZcTf3FzaSvz6svx/3/2zjtOtrq8/+9TpveZndnZ3ndv7416uZdepQliEFssmPyiBktiomg0MVETosFEYsGGqDQBQfoFLrf3snvv9l6n95kzp/z+WL2IgFyaJcz79eLF3XO+bfZ8d+Yzz/N9nqenn+gvdzCrVZO+9THaanJYH/wZoknEKOWR3/Ne3B9/H3oihbyw46T3gOBywdq1r2n/VKjwUrxVLR9Lliw5EZ573333EYvFXpDVdHR0lKqqqtc1R0V8VPijYm8I4OqsIT8ew7f2tR9esi1qIfi+y+bdLmfMCxjB/PKF90x11ZT7RpB8bkTvC+stGIbB7IEJuj/8Xwhzc4w91UL4jr9h4YYuTB47pYLOczdvxXLXTzGlImC2YF+zgrTuIHdoGsdkLzlXGGu6gCGbcXiqWWY5TCkzgjnuZEavohyqI7/wNPbHmsllnsKUjaMnktQa05Sq2jh2zxhZI8CsqR5XOUYCH3NCEM2QGBC6sEolPGRoYJSwEMVGlrgUpGVDLeF3rabnE98lxCQi8+dEitgoCA5CAQv14zvweKKMZS1sEy7FMuvDK2WwG2AYYOgCm9/dgCCKFO8oMK3KiLKVLB6MzgUsXRpgZlYgEyvjKkVRk1nmdg+z98ARpjJu6m1nsVx9hkZjFnMsTnl4grmeCId/cgRnyEHXu64lMWWnFMkgbztAPD+Ae3gEa30VMqBNz5L76n+jxxJYL78A65WvP5VzhQqvBYE3QHy8ISv5w/K5z32OSy+99ITAOO2009i0adOJ+w899BBrX6fQr4iPCn9UTG47C//+CpREFmvY+5rHEUQR96Y1r9jOMOY/Yd3vvQrr2mVINUHk8AvrHUwfmGHvv27BNDaBpCs4ClGsFgHbr+uIjB+YYKYnhkv34FUTSH4vZoeT4vgo8vQYVbqVSc9C8rZOFNGGN+tE8+ok4gZkMuQdTYRWdLDxny5i+CsRjmbfTr0wSU22n0i5zNSxFKWhIyjuKmLBBTROPcRqYx/7hDXsN6+jVpvAJeWRzTI2zcCQbKi6yEzDqexynk/ga3tpzKcoI5PGjYKFrOChxhJnQWwb1n1PYcoXiciLKDr8lP0NrLomzNitOdCLyOtX89RND9H68K2YRZVcdQuT7lVE/F20rPLjWthA8Zk4qZkCQ8YCguEJRsU6esecSLKBr7pAUJjDbkTIRU0oupOxh/uZOTCDbJGpWRWm7uIVxPcO45WzlA7MkalZgLhxNabLr0DrH0Ybm4RiEbWnD34tPtJHRpi6ZwfWugAN7zoLJidRd+1DamtGXj//7A1NA1VFeIWKoRUqVHh5zj33XPbv38/jjz+O1+vl2muvPXEvkUhw5plnvuBA6muhIj4qvOFoZQ0lU8Lqs51U2WXJZsZm87/565qLkvufH2Hkctjffx3WXye0MgyD/ME+yjMxJEMl8+2HsO+ZpizL2Gq8NP2/i/A0eslPxtly5zQ9E27smoUp0xLCC7tYdcNSGi9YSN8duxFVBauh4XPr9FiWIIjgzo2w/ZiXQlogozsRnNU0XbAAf42VRctk+rbOMV1wUHAtpT51FE9iFNWQyCXyLNYew20k0ZGot8fodjvxRtNYtQKURHL+Grz6GHIigX/kAM4RB05lFk03iBJgiBbiBKi1JGhotVKVGcJIJhAKJbyOafxnNFC7sZMF57gpzm5kbjDD4TE/G3f9G1JmGEMW8Hd0YLrpJmr2HSWzs5vkdITll5xCbi5Herqevb6FFB0+AmNDmGSJVed5qT1sI7ajyFg8y9yXHqP2fRdg9Vqxeq2469xYl9eit3XisxVQpTzClBP59FNBEJEWdmJatwJt/2GkmhBqIkXhsW3M/GInyaSA6LTjWdaE5b470Q51I9bXItbXItislG+9DSMaQ37XdUhrX7qORYUKJ80b4Hbhz9DtArBo0aITdWR+G5/Pxy233PK6x6+IjwpvKEpOYd9/biU1kqD1wi46r1z6B51fy+YxiiXkqhdXOy0fOIqy9xCoGspzezB1zbt5SkOTzNx6N+pcAktqFimTJ5CNkaxqp/bGt9Hwl+ejJHNs/8wvOXDfFKN6A8lgJ+taRFIOM6bOFpBkSpIdWbZgWO34ljXQ6WuhMD5H3VSK6ISZab2VlDnEotPbSUkefnnqtylmFBR/I/miGdVnp6FvL15jPgNqyeShpJopI6NiYjK0nDMDA6ioZOJgooRQ34YaSyHGx6lWxlkj7iQruCiKZsb05vmkY4KVhM9PV32eklpPsf8ool7GlZ3l/MH/oeEdN9C9rY2RXXPk0hqibCXtrkMtHsdkFrGdspzQaWF23PUMEwfipFIGqbFhtKk4hUQRTdNpXimjSHnsTjM0LEbwXcDMM1kiSgA1XcATNNNx/QYsHiuOaif3/WsvwweT1LVauaQ0hz54nNKnd6AuW4TlL2/AtHwx2r5DlJ94BmU6Sm7PMaTJOBZHGLGtFkvYiyCbQBLnI11kGf1YL/r+QxhlBe2Z5yrio8Lr5q165uMPQUV8VHhDyYwliB6dQUmXGH92+A8qPsoTM8Ru+RFaJof3XZfiOOOFHz5ScwNSQw1GUUHuaD5x3VDK8//pGnjcmEwSFkXAv6wF75L52jBqrkQpnkPQNOx6limrj6qOMk6/hdqFHtIDc4jhaiyFKA2tJlZ8pg3b6i6md1o5/o0eonOjuPUUaqOJzX9Zw2Nv+29qsnGyOCmoFlwNTXgix/CoUWRBoWh2Y7/8HA4+otGaOsCQYzGhqV5qpybRnS5SVSFkrUQxPsW+8lJWGlOIJgFzWwt+TSOJh2KkBiGTxWS1UAgESaeGENwhIlVrsUyP4NdjOBNz8PVv0Frbxoy4kkxnK4uWBJg7cCFTuWY6L+nA++6L2feLCQ4PO0lGnaTKdtK7Y3jIIksG2kycue1JnHaB8CIf9sYgWuM1qAdt6A8fwlXno+WdG7CH5sNfizmV2EQBpaCRnFMoO0XkQgEjmcKYmkHduRexvRWjWAJRQFA1MJuxtYTxnL8Jx4VnYqsLoN/4XqT9h5FaGhGrQ+iqitDWAskk4tKTi5KpUKHCH4eK+KjwhuJq9FG1JExqJE7DmS2v3OF3MAyD2J4h0senKOXK2Gt91J2/BNn6ymm2lYExSgOjUFYpHDj2IvFh6mrDffPfYpQUpIZayrEU6e1HKCgS1gs3YdELZG1VDDzQjXWFnSXXr8azYv412Gp9rPjIKUTkEdJqO3/9gXqazCYEAbR0jpEn+rEJRRqFSdwTOYb/6muY/9+HabtuHfbPXsKR6CylSAp3OySf64ZSCRkVDRlqqgm1udAHI5R0MyWzg4mF53LapQvIahNMjTZSSoM8OoGpkCWfFkl5gjikEumZPIqa5YC8Et3qpNobZMNfreLAoJv8d8YxCQk8YobyTITIbApLhxXrmlWMp06jfPARpOgQmdwc2SkdxV5F4O2X4lETjMfy9ItNOPRaXJEsxWyZkslFvHYJiZkijvIchiBgGAYmi0C5qOGu89J1xSJGH+8jM5GicdNiln3qIvLRHIf+82lcjX4WvHs90b4kTj2N5jRY/bZmPCv/Eu2ZhSiPzGdPlNetQlq+BD2bQxBFTOdvRj7ShyBJWE9ZcSLlulhXi7mu9sTzFetqMX/u7zByeYSa8KveexUq/C4Vy8ebx5siPo4ePcr+/ftfEBdc4a2B2WFm3afOOnHm49WSH48x8L9PEds/ipJTcC5uQnZYqDtnEYZhoMVTSG7HS9b8sCxsxbqkAy2VwXHK8pcYHaTq5w+XRu54jMmfbiU6XiCz9FRO/eeLGfhFL5MxO6aCjLc3y+zgEapX1+Nt8VN34Qrec+EKAPqeGmf7//agawZVHgVlJkEhr5HVLIjJGFo5T+5Xxwid2o5nYR2N164jueM4vvULsHY2oDf1MTaUoltahqduAab9u3EUiiREL7O+pYyFT8d0xMZ5Z7Rg909TXx2i+/t55MkCOUuAhBBgxluDO3YQj5bBLuWJ4GJuJM+cHqBmsQudCToy+6lXR0maq4jULCewPkjLZUtpDLZyaPM+nMoU5nKe8ZyZHeZGkt/L8bFPOrB7Tdh6DxK9/TBPP9VOzFaP1QZdK21MHy1QmBQRcOBrclLbZEaJpll41UL8HQGO/+wQkaE0iZhO21UrOP6NbUT2j2KyjoPDzt77p8inyrjrnLSvcCE3udE2bCD5+CEy/dMITwzTsX4dtnddc+JZ2TdtOKn9I3g8CJUEYxXeICri483jTREf999/P5/73Ocq4uMtimSSsPntr62zIMyXWBcFBFFENEmI5vltmrznCdKP7MDSUkfo4+9EtL9Q3MjVVYQ+/xGMsvqie7+LoaoYSpnsZIpipERk3yjT+6YJdvqJDSSwOiVGHu6hGM0xs3eCM750PqIsneivKRpqScPQDCSLCckio1qcHKs7G/9sL7awm1DYS2wkzZ5bd1L4+S+RCxnyJg+daxfiqXcxPm0iqlWTOF7CkStgF0USQoBpRzuyTabKXaLQ3AXhLrZ9p5d4NojF1IrdLpF3hsg0LEEcGyHozmHvamVwdxk9K3Ds3l7ar1mJLTtHu3IMCyWcepHWD7yLVTeuInt8EutYH6HiOKKuM2tv4kH/X3K01MFir0THec34p46S2reH8nSJ/pks0WorQsBLaiKJaWqM+vwgeDyUOzZRv1DCaguw8MoF2EIuNJeXRCJD0mbl2W/3MrV7Fq17BKxWSv90DyXdTc5aTfWiAFbXvIhUJ2ZId4+TnUiQv3c7lnXLab30xS47o1SCchnB6Xxt+6tChVdBRXy8eVTcLhX+pHA0BOj48NlkBmbRdLDX+qg+tW0+ffrWA6jTUfRcAWVsBuuCF7t1TqYSqto7QOG7P8Gp6mihMIm5DNmCRHwwyjlf3ETdmjCGpnHwG1spvswYbWfWUcqV0VWDjjNrmDswSd/D/Yz3FzGdeSltSy34mr0cuquP5M+eIhwdREYl+qNH0S027FoOp1jCL6ZJuxsp2huZUwSKJYm5mAwHJ9gzVOC5RIFMXsBViLC43IcuCoiZJFWJZ9FGxpmr7cKolllw9SrUiQNIk6PM7p8knzMwFTMomDCjYJjM7H8iRu/3vkHImgFJwmFzYTVpONcs5vIPnMnK3iJnvaOackFDUBXcQSuJbIFMxmAgVSZcE8chl7DkJnCqKShppPoHmIrIOEwKztgYCz52AS1Xr2Y46SU/meTIXT3UDx2lKteHv5BEzEqonipGQmdQ5wyQH57FEWjGunIh4uKFlOcOoaeyJH/8EKVVYSx1z1uq9OkpSrf9F0Y2jfkv3ou88tfhtbOz6Pf9gnJ3H2p9C9a3X4rcWqnrUqHCnzInLT7e9773nfSghw4dek2LqVABILC6hcDqFwsLx5mr0PIlLK11mBtfu0+/vGs/6pFjaIqOXQ0gmGT8LgWloCPJIsGu+SJ2K248heRgjOpVdWi6wNSwQlVYQtmyjcKOg7SdsRrXeacBEDlgkB+LYi+peAwn/U+WEcRJRFlEEUwIGPMJv/J5+h4ZonmZF/8KG0aqhYBP5JxrF7Pr25A+nkIu5UjEHMjJPJ25gzRrBUximZAxhUNJYyMPgDmV54jgJ0qQuk4nzafWMHRfhFJeIjqkkzNc9AldVIlxSo5a5vZNUJubISEW0GUzM4EF+MIyy646jZqHv4vvUC/5/i6esZ9JJuZnha2L2cIERxM1SEKMfEnAVSch+LwI+SymGh/mxjCT+8dYkNqFPqaS0idZ8nd/TWamhv0/jmEqlfAnhqjVJ3DoWQS7C7Wqirw1Q+LACLuOzWE7dSUdmxtp/99PUfrY/2I60o9cylIcnX2h+Og7hn68G9Qy2r7dz4uPhx9Bv+NOjOFxtIZ2irKM86YPv+b9UaHCb3irWD42b978qvsIgsCTTz75muc8afHx/e9/H5PJhPn3ZI38DeVy+TUvqEKFl8N75dkICxZQKugUkkWyu4dxNAdxNgdfufNvIbW3INbXoGUVREsV7pKK5nLTdVEb+uQUykOPIXg9BN92EaHltWT7p7j7pm10z1XT3ily9uQT6HNRyrNxbOuWInvdWP12YlGD+FCOqWNHqDYlMXc00XzxYvTeGrKFGqR8GsUwo47NEPFbcVa7WbvvZxR0K4elU2jqMGEUzFiyGrOqG62UJeguYZR17OUMaBKoBgYgAhoSBUXEXNDIxouoLR2MBmR0DKoXB3C5hpmetVJ25AmEzUjDKrmSB5f663L12QyzKROPfnEXy3L7sJUSFJNFitXV6IaMpXsrjbkcEUPmKEvRypBNi/iDQYIzPXiUJAeHw0yUArSWRdJpCMwmMSbT7Hs8xsSxLD63geDzIMUMVNGGs60e/43XMXvEQO+LERnNky9MER8vcMVXT6Htg+cy9X0dyefCvmjeeqErZQSTjNjWidjeiZHNIi37rTT8bheC04lgs4HdjhgMvHGbrsJbmreK+NB1/aRyMv02hvH6XthJi4+GhgaWLFnCQw899Iptv/SlL3HzzTe/roVVqPC7ZKfS7Puf3eTmsjjKKUy6gqMpwJKbr8IScJ30OOZT1yI1N4Ak0bB/isBEnKrTu/AtrKX4P9+j/NBjCDYrUn0tWks7Q/92F8ITU/hs7QxbzkatCiDGkxhjE8Q//w1KG89nwGglVd1FcbyH5XPbCWkziNIglmI9ZklDWL0csmmKIykkVUBLZJAnxvEXYgiGxvR+E973nk6jahC2e0lNOEFvw+WIkdtzjLQYQpdcRBQPFqOIIYjMeLooFC3oGZW9Px9iMOpFtpugUOCMs20sWL2WbXcMIyolNlzXTCGpcODfyhQPZ7GXU1gzEzg0iGaDzMhOwqYiVm8Vqt2Fp28/LiOFIZdpdcXptofRywVmyxZM0Wmc+TmMjELQvBeEs+lzrsLSXMB+9ans/cUI8Se7KWt28iYXzo/+JcqDd2L1CHi/9P8QOtqptu7H0RIi2ytQmlZwBCyIsoiprYFp7wJy01mEndNYCz3MPX4YqSGMc/N66j7+OUyiiuh7PimdcMnFSNUhiMQRa+owrViMls6S23YQyePEvmEZgii+GVuyQoX/Ezz99NN/8DlPWnysX7+eLVu2nFTbV6ugKlQ4GQqRLPlIDjVXIjcXx1VloZwtouYVLK/yy65UO++2qbvwhVYTweNGsFrA6QCnEzVTQCgW8LpUCqU5mlabqb/+3eQf2Ur2rodR+kY5svsRnjXOxE4OT50DTzSHWTQw8mkmbr0PtaCSrevAs/k0POERSpMRHK0hKAXQpqM4tAwOBmisXU/PdD2GaGPNaRY8QTPa5FJ69+poGHS0SRjrAhzM1GA169TO7Mffd5Ry2Ulst4alLONIC+TKFh76fITi5S6EXUcYmbOzf0uK6766Gr2tg+ShGQxBwyIrGJpGHjs73OtZttqESy6QPjKHonvJ2kIE6gysZ1yM+QmDYryEJugkfT5yODDpEDHXUOMs4QpVYdrczPFJJ0N3b8Ol5RBFleqF9YRXhPFd9SW8XfO/8/5vP8XUQwcxuW1suP4sFKuHmsV+RFEgMZQgdiyKWiwz9swQntQYqeOzzD45zswTGp4FtZx+Qxvt64wT7zOCxYLatQhFGMHc0ohgtZK8837S929BdNkJ2qzYVy54/RuwwluOt4rl44/BSYuPTZs2sWfPHsbHx2loaPi9bZcvX16JdKnwhuNfWE3LhQsYfGyAfDGMKKi0vm0t9vqXTs1eGJ4m9tg+LGEfVZdsQJCkl2z325ivuBixoQ7B7UJaugi7YVB1xWnMzG7DobrwTvWAfROOc04h9cQecn2TpIsWfMPb8Bkxqk7pYKx6FXW5ATDLuKNj8xV3h4rMTcbRW9vwnnIqZ375dArxIlv+oozYd5CqJgepwTjRVCOgc9plJjZf5ePwFpX+x73oc3NI5TL14QIXfCJAzWIvz1z9GFGzQllJkki5EGUbprKBVjahZhSSv9qOqxTHFxeZSLu4/9+Os2xzFQfCa5BsJharh8lMZZi1t9G1sZa2tU5G7j0AsQgWLUGhNkCpJUDGWYNFSqJZRYSyRk16mIQpRNbkYtC7mpBHwe4UEHSNY09Nk0uVcfrMrLyqk1DYYOA7T2MOOAlftp7Qqjp0RUVXdZScwviuaewdAo2r5gtY+Vp9VC0OkZ3O0HBmC8IwpEZTFE1WpsY0xsdnKRQF3CEr1S0OAAxFIfH1H1I62od5YRtVn/srDEXBUDUoa1BxA1d4jbxVxMfY2Nhr6tfY2Pia5zxp8XHjjTdy4403nlTbSy65hEsuueQ1L6pChZdCtsgsec9aJo+lSacFsnYTlpb6l7W0zf7saZLPHUVy2bE2h3Etf+WquYLNhumMU37rgoDvnLUoTyTQRlOUUkW0kors8XDcuoyZvJeRGQsNuUO4jRT60zNMSQvZ77iU01eUCG27DyGXQxTAquaITyU4uL1A+qa9oBtI4Tbq7HEskop7dT2tjvkQ4c4Vdo7vTvLkvx8i5MxTvdCDli6ipEu47BreoAXf0joyIzFkm51yVZhMTMUVspGLW1FNVvzNATwFlTkFJFmic+Ah5ONJmrR6Jv1LiXeuQg8WqdfS2I/t58gOjVweZAyqXCUs+SRTBzSmsjN0vW05s7vHUIYnaZvtxl7MIdurMaklIv0ZCkEryz9QSyIfJ59sIdRi56ybN3Lsm09RyigM7xnh6fvTmOuCXPHFlbRc72KyJ8Wx3WmE/TlsHgsLL2zB6rVx+j9sRMmVsXqtGGobwXOWIz+bYvqnkxQVAVN0mslvHKO8rpnat5+GUVTQYkkoq+ixJEahiPfKs5G8biSvC9uqhW/E9qtQ4f8szc3Nr8ljoWnaa56zEmpb4c+OptMbKCQKeOrd+Fq8L9tO9jgQTTKS04rkfPUJz36D1WNl2btWMPTLbrz1TiR5PhcJDhfjaQ+pkoBXcOETU9jUJO1aDzabQOCSqxifjFKYy6CLIiaPg7S1DS9ZzL98BksuTk5wMunUCC4K4h8Y4cP/vIGhXpXHHi4z9tQw2oExRK2MzxOg85xmHNVOalZUIwgCG/71cvwburAEXeB0su+eEQKNTpZf3kwupREKraU0OElwzkLLr44iPTiHKRNho3aYSX2AvvbrWXJxI/qefUR3pTGSZTRnGCnsJl6WsBaLZM0Bxm1dXHBhB5f/41IevfZ7OCIFTFqZgEfDyOUo5jUKowX2PpZg4ekB8uky7gYLk0/1Ubt5AXt/0sf0rEBS1yEd55Gv93HD7ZsoeOaQj/cgSgIm+/Ph0ZJZxvbr3C6CScbdWcMZnTUsurCJgV1x1PseROmbY3ZuDs/KVlwL6nH/xaUUth/Atm4pkn9+T/iuPf81P/MKFeCtY/n43ve+9wc/LlERHxX+7Oi6pIOm0xswO81Ippd3pYSvPwfHwkZMQS/2tufTcBuKgjo5ixQOItqsL+qnFhQGb3+W/HiUprevx7+qBW+tHTEWZbZ7ALWnn6ZrN7DmI2vpGXNybFueomwnJKk4lSk8okDt22oQQ272pDoplRSKsoOypQmrFU437yWYUVDyRVTZimw1IcoSlpAHs0XigbtyHN1fRojbaLBaMYsCtauqOeWj6xEEgVJRB1Un0pfE3VFN/Zowo30l6s5oQYskiQymWXx2DYIg4Kz14jcMWhdZOHB0O/bCGLaSQpM+jOXoT0lMtZFxhDB0CcMi4l3SABhMHCwzIa5Dd/oxlQpYpTIOr5vV71/G2NEtiEoex9JmrENOtPgktcI0+UNODqUbSe/rR57ZR84O3o3LSRtuFCtIBQPdLJNPlOh/ZorVb2/F7DQjSgJN6185dDpQZyNwZR3D0w3Enk5irvJg/vVBY/vpq7GfXikkV+GN5a0iPt7znvf8weesiI8Kf3YIgoDtJFK3yy47YkcbmVgBW1lDMkkYuk7mW3dQ2nMI04J2PJ/4AIZsmg89tcx/+071TDK7pQetoCDZLPhXtVDOFFHSRYzePpJbp8k/sZ3Gz72HDe9ZwMjkEKa8QcG2iLJYhb/Jzcp/u4rhEQFncxX6dA4yBaz9BzHMFgoXd9K6QScXL0FLC6LdSiKmI6+fPxTpC4jIZoHgkiBLHU2UZ6K0nDHvXjrwXJZHfxrHWU7gTo4jYNByfidbtpmYfqIHMZ3EXW3l6q9tYNUl9SRnCjxx2yBKQePUf/sIjsM7ELdtJbpnGFM8g6P3IKIzQKaqGfOiNprOqGf24BRKQcesZllcPoQ9IzH0rQjLzrqO2rU1SNetJJcUSATa8GkSLdPD1DGFmM0wq2zEHunGW5xBL0nMbT1OYPUGrHYPgZUNTBxOUIxkGHp8gAWbamg7o+5VP//G952D75QFWGt8WIKVVOoVKrzZpFIpnE4n0kmcmztZKuKjwv9ZkuNpnvm3neSjeRZc0s7K65dgFIqUe/rR4ynU/mHy/ZMcv7eHQjRL5/XrCa1rwVbjxV7jpRjN4GqvBsC7sIbgucuZOXAYAdBSWbLHJ+i8cQ219hSpRAbTkiYaLlhH8+ZWzAEPHT6D6760hEyiTM+P9nP86RS6WGY258D7kb+go0bm8IOjPHVbPyVFYDQyjq/ZQ1dDDueZOp0LJfp+nKCcKXPsoSHazm5m71MZJo8kEMeGCNuzhFocZKJFCikdNV9Ez2koEyV2/WIGSgrJSJn+nTFmh3NM9GZ4579cRM3bNzPz30+S+c9HkYwMocIYwUyGuZyd5tWrcB95Doe6nzh+nGoKi25GGR/gyZufYtnET/FpSfL2pezerpGaTNNcbcWvgK4lycl5hGY3pV47gqaRyohweBB3U4DTbmjj4C/GmDksoCsavU9NEp/IY5ZUmteGaD6zEVF8ZdOvZLPgXfXK53cqVHi9vFUsHy/F3r17+cd//EeeffZZFEXhscceY/PmzUSjUd7//vfz8Y9/nLPOOus1j18RHxX+z5Kby5OdzVEuqiRG0wAIdhvWc0+n+NQOzKuXkI6Xie4fRyurTD07QGhdC/ZaH4v/4W0o8SyujjDlksbRh0Z54v4SeM6ko7SN8GI/ddeejiTp1DZK2E0WRgdVph6VWarkWHu2xOTRJLaAjZRq0HVhK6hlRo6kCQlRbKYyY/uS7PzxALPH4shOC9JSH4eeirHtvjlkk0BnRxhPnRNd1anq8CGKAp0rbBy7N4Kh6+QUGVNdkNXLFIJb72W0RuAJFlGyuBnZH6U8FcHqtTAzohAdzpKYyPFTAW665zRsV13CwZ9C3cQu6vVxJEUnN5MitrWbQP9uEKMIBqTddTQ2wMxoFvN37yXmOY59iYdUbx+RiXqMfIFZfxAlGiOj2piYjSIGa7DXu9HShflIk3gWVdHp/uF+urrM2KM5bGtb2XffKKZtW3ApcRIb1mBxX0rdqko12gp/OrxVxcf27dvZvHkzdXV1XH/99XznO985ca+qqopUKsVtt91WER8VKrwUocVVdJzXQnoyw6LL2oF5l43jqouwX3oOmEyI0yncbVWUkgUCy553AdiqPdiq5036A1sn2fXDXiKH0hheL5YLPsi5/9qBw2PCMAwWXdhIz2OTREoCuZhGz/Yk8SNTzPalSCYNynYv/vQI3vIc1TYTppKDme4YZofMzECWXNbAE7Rz+nvamezPU8xqxKaL7Hg4ztUfXwWKQlW7l/3P5dj/XJZwq4PEQIFIxkEpXsfaxx4npM/iq5fI1JRJ9R/HlNVRS60oihXZ50TU4+hFg/hAnOxcjvqFTgrtS9kr1lFOb8WSTzKcC5P9+RArk0UkA5KCh/3KqbRFZ3BHj1NEZ9TSSLizhaijg+KAit1QiU8VyBb8lA0JWcxgmU4jO8yYgj7EYgElKyJVeWBsjIntQ1g9VqwLayjvO0xb9CBmo0jhsIquXvxH2ScVKrwcb1Xx8ZnPfIaFCxeyc+dOMpnMC8QHzKfe+MEPfvC65njDxUe5XOahhx7ixz/+MXffffcbPXyFCieNySqz7gMrXvKeYDajazqy18nqmy+hnFOwh90v2VaUBcw2iVCTDVebhzNuqMXhmT8fIggCq65uZ9nbWrn/m5MMH83SucbJ7NZZ8pMJNMMKYgEiUSRHkZbIXtxlmYMfP4wpHaUuYhBXFzE346FUFlh9YYhjO5NkEmXmRouM9ZdYd1EQXTfY+vV9CHv3IXv9eJevIj5pRZWsaE1tSPFRzD4XoWMRhOwEqiYQl6uJletQNR2zTcam56jN9XPkn/Ms+NCZXP7hGnY9YsUXuIrYoXGskwUyM1McZDlma4ljpiVookw5mUfUyhiazt7EclLuqzAKEUoMUi6VMSsmFMNBESs+SwGbkkJOqegmEG0W/Ctr8Z22kJFfHMTamwYjRWF0G45MBgkNwSSjO11YvS8+/FuhQoU/PHv27OHLX/4yFouFbDb7ovt1dXXMzMy8rjneMPHxzDPPcMcdd3DPPfeQSCRwOBxv1NAVKrwksYE4x+7vxRF0sOSaRZisJ7eddU0nl1B48rYB4pN51r+9icWbql+2fcspYXTNQC1ptG4IIqgqhmG8IDTN0A2sVh2LpFJdI5FQ81i0PHaviG2ZB09tGPvQUZqdMbSMijI3QUZ34EPGJ1RT0LiF4ysAAQAASURBVOrIJxTsLg/rL60mFS0jm0R81fO1lAQBwsle0sU4lkKe1W8/lYF0CG9Apqp5JUd60whmBxnTLGVmyZYEctNphPhx7Is6aDk7jDw5SkApk+qbJXZwnNP+Yj2N1lmm7tlJe5sd6ZoVHH/UQvSojbKhUePyoLkDCN2TpOIuMHSyOYGRLcPUd9gxWUU02cVcqgaPOkeVGEMUzIgWGVWBUlrBIkjEe+comRwMZ6sw046Mgj0nYpOtTHkWYA55cV94Oq7wn8Z7hl5WSW3Zj15U8Jy1Etn9p7GuCn943qqWD5PJhK7rL3t/cnISp9P5uuZ4XeLj8OHD3HHHHdx5551MTk4SDoe5+uqrueyyyzj77LNf18IqVHgljt3fx/DTo8gWmeCCAPXrXjlyIh8v8NytB5k+lmR2DsqYOfjQ5MuKj2REoW93kkCdi9YOM/3/+TC5kTnCF6yg/qoNJ9pN9uXYds8ME315BvYkWLtIxOo2E42USQ/lSUsBnNZ2AtIwbnuatNVB2ZAwB1xYXc0sXllLTZsdgIWneHAHTFjs0olrgiCw5vouRu7O4m7xU7PAS/nJbpyazsSIhfFhFUlK03L2IjRPgOjBGO7pWbRsEikmcfY/nM3Ebjel3TqaCZ59rMiRg9tpMEbJT8QRzWkWX2uibeNpPPSpZ8ht3Y8jNo60pIvDSQs2w4cAZBULqa0TCOVqFl/QwPjhJInePMsKhwjqETKKnx7HasweMxZZo5QtoEmgzBQRJScRTzs+RwnUHEYpgeJwIdc00bGuEYvrxUUrf1O86g+ZgyCzs5vZ7z6IUSqj5wsE33HuH2zuCn9avFXFx4YNG7j77rv52Mc+9qJ7uVyO22+/nY0bN76uOV61+BgbG+MnP/kJd9xxBz09PQSDQTZt2sTPf/5z/uu//osrr7zydS2oQoWTxVntQLbK2Hy2kwq9BZjpiTOxfw4lV6YUM4jlrMh2E5GxPMFGO1MHZxnbPkH10hAtZzTw2Pcm6H4ugS9s5m3X2kgdHaOcLhDZeoy6K9ef+FD0VlvQDQFVMSjpMtWntVGzKse+Z3OUdBFBFMi7w/SHruDsa6toLHuRNIUFZ9exPm/F6pDw11iZ6o6z/Ts9yBaJjX+15AUfuq3Xn0b4zC4Ep50H/247hUefRRINgpsWI1gcFHIqriY/7/z4GrofGGDHF58gOZ5BEwUObUnSO+CknF9KeXiS4Ox2ChYFy0ov/novtmo3zvZqrFUu7C6RfLFAuVAitX+McjFAUQqiazo6Aka2zPCOGeqW+DjrQ1089ZUkllQJAR1JLSJ77MgymHwu1PpqxKJGOi+RnUpj89hpObeVqUGFeP8oUjwGeyfZqojY/HYWntdILlEiOZnDSKc59q1nsQUd1J63BEOUqVtXy9zBaYrxPPVntGCverOsEpX6VBXeunzhC19g48aNXHzxxVx33XUAHDp0iKGhIb72ta8RiUT47Gc/+7rmOGnxcdttt3HHHXewbds2PB4PV155JbfccgubN29maGiIn/3sZ69rIRUqvFqWvH0hVV0BbD4rgfaXru/yuwRa3ARaPRRSJSxNNvRhHUSRyEgOb8jMvtuPMHM0wtCzEwQ6fJRLOrpmoJUN8HnRgyEKqVlmJu3MfqOXM9/bht1twhuycM3ft/HwbeMI6RTpsRSGJGK3GnStcrHq4lqmelK4QxYazwzR9FuiwgYkJ7Ps+Wk/kwejzBxLIMkik0fi+Bqer9YrSBKOlmoysRLpmEIhoaErZfbflSFqdhKqsSI/FqPjrDraz2thovcUsk9MYAn5sXvNqIpKfmAGaXoak5JCEEQcYRfLvnA51ionknXe8uBb207vg72I+STxkhvJIuIMWkgmBbRsEQkNtWCw954Riqki5aJOD4uoZ5wZqinNZMAmUM6USMtu9LyCni0iaxJ6IcfsPTPYQ24km5miYaCrGnqxzPihGINH8/Q/NYHFYmDu64a5OUSTxNieOcSAj4nngqQHI5RSRTJTaVb/1alv6J4CcG1YjFFS0IsK7o0r3/DxK/z58Fa1fKxfv56HH36YG2+88USdtptuugmAtrY2Hn74YZYtW/a65nhVtV1aWlq45557uPjiizGZnk+HXKliW+GPgWyRqV9b+8oNfwtPnYvzbj4FJVcmNqPw7I/GcPjNNCzxgCigKhqJoSSZ6SzjOyc5592N1LbbCdRZmRnNs2uuhVTUjZSz4Hh6juZVfhacESIbL7FwnRuLWsWz/zPD0HNJclkNEEgNRqmpl1l3XfuJvxXDMBjcEycdKWEoZY4+OEx6KosggtVtRrBaKY9Po918O6LPC+99L4JnPvrG6TcTPquLx59OUCorjJXqsWslkmMZxndpzPY3c3CfxoF9NtyNHVz+wRANi5wEOMjUwW3ELSIxa5jG0wMs++jpOH6nMN/xbp2JYpBgKYOopPHLZcLpJDHVTRQHVUTI6w4SMYnxAzFycYWM1MSUVofFauBRE2hFlXJeJ62XsGt5BAxM6Fi0NP5EBFPJTLZpMXmbfV7gma0cey7K+PE8pWiWULMdX0HHZpJAEtEFCcoaakmbN0oIwpv2viOaZLznrH1Txq7w54XAGyA+3pCV/OHZvHkzvb29HDx4kP7+fnRdp62tjdWrV78hf3snLT7WrFnD3r17ufHGG3n729/OddddxymnnPLKHStU+BPD5rFg81jw1ELjUi+iJKDkyjxxy1FmRouYnGYcVVYyU1kWX26jumnepfPA54dQpyMoghWXRcIbtuKrtTG4K8Jzt/djssksv6AGZ8BCJqaQjmvo+RJVdVZ6n5pk0Xn1OKvmxxo9nOLBf+9l9ngKUS9DsYjLJ1O3xEfD5nYee8TA/Z07aBB3Eqi1wvLl7FOXMXY8z7Izvay4sI5921dzfF8OWzSDU89htwnYnBLTPTH6nkiT2TVC0mRl8mwXnWu9NKWPYK8rEpdKtJ+/jrO/eiGCAFu/c5zEZJ4VlzdRt8RPqM5EWJvCIpWwaQWc5QwmtYRPz+PAhI08ZTEL3hpQFMyyQdFuw1RIgWqgCGbUskoZGcMQ0AQZk6SjGzKylkbSy+h5nfR4khRBdCSUkSKmiE5utoQoi5gcZlZ9cDPG9By+jiokj4NiokjL5hZSQ7F5t8vpzaiKxo6fDDM3kGHV5Q20rKn6Y26tChX+z7FixQpWrFjxho970uJj9+7dDAwM8KMf/Yg777yTW2+9lcbGRt7xjnewdm3lW0KFP23iQwnGd0zgbfbSeOrzlXBlkwjA9PEUw7sjKKqMNeShfpWflo3Pl4vO9E3hOb6bhniM2gWLCK1vwekUsNvh+JEE0dEckiygGbWc+8kV3PuVfuzmEspkHHetmVCHB5tn3q1hFIvE9w3S8+Q0hXQZk2hg81uoXV3FGTc0MnssQjHhYEqvISu7CVT7GIx6+P7XRygXNKYH83zoax289wvNxCcL7Lq9m+keCcoGwVYnk4fjlJ/dgzeZwXA46XssxKZ31GBtCGIPu/CtbKbp708lEdWYOBjl6CMTJGZK7PzFDJ1n17PgtACxpSGyfWUKOZ1yScEmKBQkJyWTA4dgYPN78YashHqewqZnKckOcpiIqV4yOEGwoAsS9sYArRtC1C1w88TXDpHJlfGQQtNNZNIGXnEKSTbQSjKyvQap1om73sPmj3Sx5srml3yW7jo3uekUE08PkMsLHH4kQSmrouvGK4oPXTfQVR3Z/Malia5Q4f8ad955J48++ijf//73X/L+e9/7Xi688EKuueaa1zzHqzpw2t7ezhe+8AW+8IUvsGvXLn784x9z++2385WvfAVBELj77rsJh8OccsopFVdMhT8ZDMNg33cPMn1gBleNE0+9C2+T9wVtAo0Ogq0uMhGZ5ZctYuXlzYiiQCmvcviRKfJHhyCXwyzpTPdMM3okS3W9jJYrUrOmCSmfRpIEfCEz4QU+us4MM/ntQUxeGw3rQpg8Via6UzR22cj8+204Hu9mZdHDc6ynqAvYfF6q19Tj3vYrpL09nBcP8LR8Jvu73knwr5aw9X4rcxOTaGWNUtFAEAWaFjoIN1no/5UFJWXD3+hk00cWcsdfPomaLSKjIdtEwm120sfGyRwaJDZVIuZtJ37A4Jn7xlBSBWx5gYnB4nwY7cQMz/18ilAojFTjpZzMUNKK2KtVzI2tmL1elq1UMYX8PPnZLbjKcSx6AYeaQtGrcZAhhg9VMCHY7Cx9+1IWr7Sy+zuHcXgk7LkUImCg4yOOQ88jl3XyshsxqVO7rJnq5SaWXVCHpuqUCyrWl4iCOfbDPUxuHUJ2WnFZasEwEWz5/aF/pazC9m8eJDWZYfm1C2g57dXXlanw1sIAjNfpOPkzPPLBLbfcwsqVL3/eyWazccstt/zhxMdvs379etavX89//ud/8uijj/KTn/yE+++/n5/97GcEAgEuvvhibr/99te8sAoV3khks4QoiYiyiPgSlXDd1XYu/seVFFIKpkKKiR8/jaMtzETazbYfDYGisKSugVIuTTIbRJlLopVBlEW0bAG306CULfPU1w/TeWE7rctcHPCDkMzSe/cMcn0Nk90prvpIiPyhfkgkaLIU2YlAHifZgkT7IhPqA9NI5RJV2hxhd47BZBXjaS++sEF1pxtZMjjn3bUnaqBY7DILLmpF9EZZcUEYpaCRmclTFB24gk423nw6/pUN3P+3D+E9cIR8usyx7mM89qSEroO5ysXKcxvRxi3kC3nIlpCyReayIkvPC1PXWk+2fwZfk5PhniLF8STZU5oZ25ElqnnxmkI41RQlTUbBTBI/JdGBaJKwOmQmnx5g4udRlFQBUTCwWQwkxUAwNCS0X5/dMJBNoBk65USG4nSc9GSG3d/vIR8rsvTKdrrOawbmLRd7fjbE7jsGkDMpaldWs+mjXRgOJzVdL50k7jdEeuOM75mmXFTpe3ykIj4qVHgZent7ed/73vey95cvX86dd975uuZ43UnGJEnioosu4qKLLiKfz3Pvvfdyxx138JOf/KQiPir8SSAIAms+tIraNdN4Gj24a10v2c7uMWNzyXR/5l5Sh0ax1vqRzt2EbBbRJQvpluUoIQnXXJGQV6G53YStxouiqDiDNuLTCZJ9WdKFMc76y3Za/Emajv0ASiX6PRcg2M5Aqq9hzGgiHU0zaOqiLHkwSgZaPMOjt43xzstOw+Y7gs3ShHUshMNnIdTioHG5mfo2C26/TMey58OKE3MKj9+TZm7cIFFKY8zMkC+KmHxuWs8JU9Pm4OmfjnL4iJmFaQeoGindjDYxTcCSxSq5CNWGkV02rFUSsiIiKeByQdMiJ6de34q7agn3fuxZpp8dQJNM9FXbmBvNUYiX6HevxhUwkR+aQzbKlM0ObD4/RjaHoerMHk/iLKcRlRKaaCItu3CISUyiQNbmJVM2MJsNzD4nVpuZQqJIfCjJ/Z/ZzuS+OTzVNmx+ywnxER/PsePbh4gN5zGLIl5XkPoN9SdlafU2uvG3eMhG8tQuC74he6vC/20MhDfA8vHn5wUwDINkMvmy9xOJBOVy+XXN8YamV7fb7Vx//fVcf/31RCKRN3LoChVeF66wk66LO35vG62skRhLYwgyoiwhmiXaT6vGUhMgNlVk568SRMaLuL0yXYtsPP3DITKJQZo21HDWDcuwb5tj4EAGu9dMqM2FP9iHWelFspmQaqJMhBxEJsskz7qMZwYXMzcLZrsZKGEWIB8rEg0tZtX7z6fKMKidLmJ1ytjd85FlazY9/82+XFQRZRGlZKCUdDTVIJdQkFURW9iH2aRh17Ps+cYOUhGJiBEmYjobk11HTGeoIkK4NEOV7MI614Q/5MVqEehY5oZsllIiz/DeGMnpAhd8rIv8VBJZ1BH1MtUtFtRslqKSQNIgvKqBaNIEmoi3y0e6KBKflilMJXHrKYJCBEGAiFBNWTRjOJz4mxyEatzMmetBKeOosmLzWRh+eozoWA4lEkUQJVTVoGl9zYnXbfeakBJxTFoJQZJxNfhO2sXrDNo557OnUEiW8NS/tACtUOG3eauKj5UrV3LnnXfyt3/7t5jNL3R7lkolfvKTn/xet8zJcNLiI5VKce2113LmmWfymc985mXb/fM//zPbtm3j5z//+etaWIUKf0gMw2D37d0MbZ3AF6xiybuaMRczaAMjdJ26lFTSYN+WFImxLOlJyA9MoOVKFHMqcwNprFVOzvtEDV0HEzgDFvwNdsaSZQS7H0VRmDkQYfbQL3hqaCOX3bycdEzl8PYsI8dyCLk8mA1qO6toWOZDKahkYyW8NTZESXzRWkf2x3ju+wM4vCY2/9UCLnpPNRMDRZac4mSu10F/nZ2u9W5mf3WQUkQnVGNlYcjO2M4koqqgG2UEESRZxOo107TQwZjqYMcvo4z0i7zn8130PDTCyL4YhbSCUtJpOb2O2f40JVVG0UyEQwJxPYegGejZPK0bG5g4FEWdjePAoBjJIeoGPuKYUTBbJNJKkWjRT0pw4DZMdLxjPWLUQbJvjvASH31bZ4jPqphcdgSblZqlAdZd28biy1pOvHab28yyy1oYeFTDHnJxynsXvKrnbHVbsLotr3u/VHhr8FYVH3/3d3/HJZdcwqZNm/i7v/s7Fi9eDMDRo0f58pe/THd3Nw888MDrmuOkxcett97K9u3b+dGPfvR7233gAx/gK1/5Ct/85jf59Kc//boWV6HCHwpdM5g6HKEQL4JhRVDKZB5+loymYxRKGCtWYjEUzGIZu9eCw+1CVGRmhgukUgJP/nSWTdebad9QxXN3TXH/10fosiygZoNEIZKmcCiDNT+BPj7GyK4aMoOzuEUNPZJGK2komoS/xYMrYOaBf+0mNpJl0eYwZ7y77UVr7X9uhrm+JJJFZqonxfJNNSw/Yz4HSNMCB2vfVsfA/hS7Uj5ECZac20RH0MMz6ShzgyVKmkjJGiImOylKQZwJLyMH4qSm8qSTBsf3F9jwjmbsXjO+WiuHfnqcI/f1k8/oCH4bPY+MYlPTiCYJSRZxNPioWt/EsV1ppKlZZF1B1kHCRAEbVpT5Q7KGikyZiVKQdMRC/IEUyUIJk92KMFYmE1GgKoBDzuLNduOPVlFdvwBBENBUnX33jREZzrLwgsW0nN2Ku8GDt+Xlk8sZhkG0N4ah6QQXBSuH4CtUOEkuvPBCvvvd7/LRj36Uyy+//MR1wzBwuVx8+9vf5uKLX18V6pMWH/fddx/veMc7CAZ/v680FApx3XXXcc8991TER4U/GyRZZNHFrfQ8NETNkioc3iyFkoqhaeglhYnuFKmZAoFaKzWdLs7+YCvR4RyPf2+U0eMFdj8YIZcTecenGjn0RITIQIqMq5obvngaVZEZRm76BYVplZwUoPeJCSLbByhlytgEN4YhI2FglmHnXePsuHMU2QRWqci6axqx2J5P6Kemc3h6dtI8NUahfQlbvn6Ix796gPM+tQKvX8bkMBFo83FkS5TZhIn0qInerw1jYNC+zMGSzUFKCpTKEtNJG2mbld5nZimOxHCoGrgc1DbJBEIS539sIZHBFE989lniw0kMVUdPl9FEC5LdjMflx93qZlatIt2jgc1GyTBjqGXKghnNbKYoWIgZVszlAgAWiqiaTDZRZmr/NNisqGYn+SMxhHwel80gkB3HPDdJITbFsf8NEl7zTqZ70+y7b4x8SiE1kuTsj3TibvL93mc6uXuSPf+zF10zWPX+lbSc1YxWKJF4+hAIAr6zlp/I6lqhwkvxVrV8ALznPe/hyiuv5PHHH2dwcBCYz2563nnn4XK9frflSYuP48eP88EPfvCk2q5atYo77rjjNS+qQoU/JGpZR1V0Fl7YQue5TYiSgF4oYZQUUDXcZ6+lJgGhVge5hMJZ722mY62fcJuTiYE8yWQEwWpBFAXsbplAUGRqyywFm8DwwSDr37WCxOkq48cVZLufVnscSVew2w0a/RJTMTPeGhv+GhN9exIIkkDd7H7cz6b55QVHaPjry1h7dQuCIJA9OoJpZoz6kEK8OMnhg3401eCRm3dQUydhcpg47aNraVjoZPhQisyQRnImj0ktMqKW+LvnLsZTbaeUV9n1cJx0rIwR0SnHzdi9sPIyJ7anH6H7vgwN7zgDsaWRQqqEoerzIYOCiGiW0QyBhOYmMmZDTOSpWWhm9fUL6X1AIH5gFIuSRVVlFKsDm9eOUEhDKo9Dz2GhRFzxU4zlsDmKUIpRNlQEdEyKSj6TQyrriGZw1Hvp2Z4gMpLD4jSRGZhh4sgsd+/oYcl1S9nwkdVYnC8tIHJzOfLxIoZukI/kAYg/dZDJ7z6CIAogCFSdv+YPts8q/PnxVhYfAG63m6uuuupNGfukxcdvqkueLL+vHG+FCn8qZKJFHv1GL9lYkdPf1Ur7hnnLnmS3Erhq04l2blnF4ZbJRotEBrMsOLUKl9/M2z/TxYarGxg+nKFpsQOTWcDtEbA7BDwhM5mZHOWcwppL67DUl6lts7NocRVyOo5W1rC21XHw6STeWhsLN4UplUWKMwkaunOImSzFoVGOPTzCsgsbsDpNWBuC2BqrkZNZvA0tWAYLKEUNi02kmC5RLqgcfDzCru0qLpfEWe9u4Jl/2YFFT2EtWIkemqLq0i7Sc0WCAYOlp/oxmQPUdLpwBa1UmVMMf2MCXVGZ/fkWiuFmrBadsqiiGGY0h4eGU+uZPBKlMJFE00uUbRrhJVUEV9Ry5ocXcO8l32duZwyLXqRkaJj8tYyNOajSR3BQxEoJQRDICdUIhg6FIqqhYbabwG4nnXKhyDL2+lqcm9fx4DfHyEeytC8yE/BozA2WiEay7Pv+EQzZxKkfXo7JJjP+7DDJoTj1pzfj76ii/pQG4kNJdFWn8fSG+QdpGGCAoRvz/65QocIfhZMWH42Njezbt++k2u7bt4/GxsZXblihwh+ZqeNpxg8nyGdUHv3WMLrZSueqF5oUx44keeZ7g/TvimH3mBnYFeW0dzYiSiKlgkZqrkjPzgw9u7MsWG6hZ0eakm7C7LHTubGG7f/yNJnJNCvO72Dx25sAOOuLZ6OWVH51Sy+SCIJuIBgGm97TzJKNAXL3JRi8az9ZOUR4aQizff5P1doQovWz70RN57E2V+PaNEsmWqRluZvj9/dhdpp48skc47vmEAWD/MEifp+BkIFQiw2jWKZc0nj8v3qZ7EkS7nBz1ReXs+CcOh75ei+x41FaVRchc4LCoX4iDx2has6CWXcgCDpzogdzbRXB2QTT4woYErLPQr4kc99XBtjXKuKwWdFEGZNexKIXUEemUAtBUrhwkMUAzLKOud2P3SkR742ACPWrw/iX1HDktgKFkpOyuw5NFyklCxR6x5mIidQ3W7D6bWgIKKrIvp8NkE1qrLu2haM/2Ed2Jku8N8LGL1+Ao8rOKR9d/4Jn6T97JQjCCbdLhQq/j7e65ePN5KTFx8UXX8z//M//8IlPfIKOjpcPWezv7+fHP/4xN9544xuywAoVXiuGYVDIqFid8omkXL9LdZsTh1tk/HCGSEyi+D8TvOtzLYQarCfabP1eLyNPT6BkDby11SzeXI0oiRRzKg98rY/DW6LEY+Csd+N165hsMu72EMuubcTulEgMxokOpujbm2LnHpHz/qqDhnY7hmFg95qRTCIWpwmzw4RsEqnp9FD868spL19Li9tG65qqF6zfHPRiDnoBWHxOLbmkgpIrU72uieNPTqKMziKqZQQBktMFzIZMqDFA19s6aDyrBU01UAoqmgZKUUNVNB759252/XgATTajb1jC4ssFIt99EEPJIhsSdmm+mq3JmMCabcPhKaA4imh2FzWXNdP75CTGXJSRY2WsQglF8GCTzXi9MrLPgThuQipJ5DQXDrGIq97Nsr9eydLLmvnlx55ktidGYEEVK69fTN/OJLO9SbIpB9HhFGvP93JkTkRCxRYOcMXfrmWmJ8a+nw+h6QJz/SlysSKSRUb6dV2Yl0OyWQhevP5l71eo8NtUxMebx0mLj0996lP84Ac/YOPGjdxyyy1cddVVyPLz3VVV5Z577uGmm27CbrfzyU9+8k1ZcIUKJ4NhGGz90Qi9z0VoWu7l7A+1I8kvDltF17FI81EYpUwGXa9+kTU+NzBLeSaGy2PlwhtbWLB5PjNmcqbITH+GYjRLaaaENyix4rwWjI1eSnmVGnceI5nHWuNl9ukIczkTh384wsC4lZu+2UpVtcymGxfQcVocf6MTd/B5wbPl+2N0Px3BX2ejusOLJ/jStUj23z/K3q9vIzGcImvyoGsCgWYnwWYPgs3C+EERUdBY/bHFnP6+58NSN76/neF9cRqXebHYROK7+nHnZymbbASaW4iKViZMzRSaa5g1WXEkJnB4BKqXB+m4vIpt35zEWuXEXu9FKKtYZZWSoWGWNCQBkEwoooS13kldhw13vcbwLpVy3kQaM4K/gYNPRFF0mfhMmeREhuO/6MVqk7CaVAxFQS0o3P8Pe2gMFrCkUxQxk+4XiHW7WXBeO656H4cfGCHY7qFubS2uoJX0aAJvZxV7bz+CaBJZcFEbjoDtJX93FSpU+ONx0uIjFArx8MMPc8UVV/DOd74Tm81GZ2cnLpeLTCZDX18fhUKBcDjMQw89RHV19Zu57goVfi+lnErvtijxyQKqorPmihL+2hd/CBnGfKRLuNmGyefknA/WUd1o/a37Bg3LfJSTOTx1DgxVJzqcIdjqJtBgJ1wjMPWrcUKiSMDqxOsXCbcH2X/7QbZ98UmcHhHfxpWU61pIH8uhlgWSWYm5aQ2xXGLr7QMkpwtYXCaqO72svDiMp9pOZDSPUtBIR0qMbJ9CTaSpXhKifk3NC9bfe+d+9ENHsKZKZMxhHEYRR16j890byHpDRAfSWBwytUsCL+jXtMJP0wo/I4dT7Pz5GG6PAC12bCEnl3yik8f/eS9RUwMFiwbtTopSO0tPt7HmnR2UXT7i/z1JpADRAQ+ORBZzqoAzbGfp5ioyI3HGdk4iSGbS0RLKdAwwsFplhKKOaLNguNwUUgoH7uylcGgQX3qGYtrOoTt0ijkNq2qgTSexGCq52SJWlwmr106qv0j3nXlyUxnO/PxmOjbWIlvnLVtVC0MEFgT51See5MjdvQiyRGY2z1mfWPem7LEK//epWD7ePF5VhtO1a9fS3d3Nt771LR544AGOHz9OOp3G7XazfPlyLr30Uj784Q/j9XrfpOVWqHByWBwyLat8aIpG/WIP7uBLJ5by1Ts540OLiI1maV4bRNNgsidJzQIPggD77uwjPp6jdmU1rkYfW38wiMVh4uz/t4j6pT7aFlkYqRLJJ8s4bBqugIWx7jRPf28Qa28Kqw0WbSgioGG1i+S9YZac6iboLvHIF/cxsDNGPGZQKgGaxpZvudjwzjbWX1mHxSFR3Whl6P4jxLb2YPWYOffb11C9sv7E+usWeSjuMKGWNBxmA08phakEsw/vZ7bLiapCbYOdUkFj//2jBGosNK6tRhAEEjNFHvnvQaJjBUI2Hx3n+Gg5uxVP2InsczE1HEGUBbCpuJqdhM/soCDY8XhkQhtaGc36KadEBDGH3WIglYqYrDLv+NEF/PIzOxnfO4dJVCmP5Slni+hmCXvQQbDTh3OFl9hIhszILI254zi1BCASn42RLNoRBAcmUcVilCgJVty1XhTZjjIeITtYgE3zicfKRY3JI3GCbW6cVTa0sk56Oouu6qAZlLPKi555Oa8Q643iqnPjCP3+YnQV3tq8VcVHuVymr6+PqakpCoUCNpuN2tpaOjs7MZlMrzzASfCq06t7PB4+/elPV3J4VPiTRhAENv9lK6svq8NVZUE2Pe9y0TQDpagxuDeJUtBYeHqApjUhJo4mePQ/uolP5ll5eRMrLwyz7VuHKSRL1C6twlYvEBtKk59KEjk6w/Jrumha6kGQRARBoLbdhVIo8/g3jjE+KeHSQ5DRGPiPAcRSCa/ZRrirkbdd72LrbQcZfHYKJVtGxkJOETHKKlN9WR751ggXBvxce/Mi1JLKgw/twEhnUFWZ6J4R8gWJoW1TNK4JcconT6NusZdsvMSxvTkSdz2JZpTJaxbiKREcDmqWBvjpp/ehHerBYVZZ/VfrCW5op6zMl5c3DHB01XPOlxafOFuSKDvRXB4yk0n8zSKGorLt+/0IosDGv+zk7Tc1suocPyNDOqXZJCN3T1JKaEzun+Xezx4mX7Qg+LzIdhFsZlJHZ1HzChYd2pp9hEMqiR3jyFoJk1HCLCiYdBVJAwkXgq4TJIJN1hCam1jy5fN44B9248lNYy5quB2rUBWNLV8/zNSRGNULfFz42TWYbTLrb1yNZJKwBWy0rvUzs2uE0Jr5A8KGYXDgf3cz9uQA7kYfZ3zpPGy+ilumQgWAwcFBbr75Zu6//37y+fnwdMMwTiTos9vtXHbZZXz+85//vWc/T4ZXJT6KxSL3338/w8PDVFVVcfHFF1NTU/PKHStU+CMgSiK+mhd+sORSZR76r0GGD6bJpxSsDpnEVJHN720kNVNg/HCS+GSefNaAQpF8rEghrSBKAnXLAmy/dT/lmRTxRIpnZhScDR4i0wZqQWTXvRM0n91CIVki0OQkFWsnPZ3GGx9BElWcDomVZ9jQCgo9O1Jkkip2r4Wa9mpKfQpatohmiBhOJ5PD89/YZYvMyg+t4XAuhdkh42z0s+vHx0mMpon0J6lZWkXbVfMfxEf2bUfpWopoFAmet5SZIwb2GivJqErsyAzhYhKKGvtv3YHliIbNZWbJ+Q1IVjNta30IAhQno0hOGyFPkUh0CEcpj1SoIzpiQ1M0fLV2IsNZxo8myURLnHJNE+HOVp6xp+l7cozJvhzHj08iyQLekAmzw86GG1fy5KceQ0zFKEtOSrNJDv1yD+WSjmpxErfWoZUtuIUs9qCL1JyIWdGQ0RFtZoJdPpo2t2M3bUMWNWSzgElVUEsambk8akkjGymg5MqYbTItZzTQckYDY48fp+e7OxBEgcUfPI36szrAMJh+bpDkwRFyA9NEjyyh4cwXZ5GtUAHeWpaPAwcOcNZZZyFJEn/xF3/BunXrqKmpwWq1UiwWmZ6eZufOndx999089NBDbNmy5XXVdzlp8TE3N8epp57K8PDwiZwfdrudX/ziF5xzzjmveQEVKvwhmTyeYWh/isRMkUJaRVPyzA5myMRKnPuXTQRa3WQzGma3hYmeNIWSgCGZ0FweNF3EFbKhJzNoOpQVndhUgUJBRDQMSoIVs9fGkvNqiY1mCba5ePgzz4EsIcpgq/PT16eT++Uc1voA8RmFtG6QGVcJtrioagrjbfURjxmcfon3xJqbz+2iamEIXVGx1flwbEuRmsph91kwdJ3pnjhCqYjeP4CYzKM0NBCfyKMcm0IToeq8FuSAGy0vIWJQKgloszlsLjMNi920rKlCSeUZvPVXpHf2YA17aV22hHSjiKHb0YImhicEyjkNQZbo25tgpieJ2SphcZo4t9WFpy2Aa7RI6sgkhayGzS1Tu8iL1W1ifOcU9nIKXdawWsoUR2fRCipGWUc0aVjaG0jmahHrbSy4ppXIj3vJH4wiKQL+Wg+NH74Ii8PEaX9/Jr3/VcRfLVN/+WqsLjNr3tHBwNZpmtaFcASsL3jW5WyJck5BEAXK2RIAgijia3STPChicUhQVv+Q26/CnxlvJfFx00030djYyJYtW6iqqnrJNu973/v4l3/5FzZt2sQnPvEJnnzyydc830mLjy9+8YuMjIzw8Y9/nM2bNzMwMMAXv/hFPvShD51IvVqhwp8qhmEQG8thtQuE2xzY3DJ2j8y+e8cpxlW2/nCYje9q5C9uWcPeB6aw2EX6t86C00VqVmHouEKpOIbZ7yKwTKZxfZjZKY3hfQnMVS40Q2TB5Z00LXLRuXq+zopSUIntb2DqoAXZIhOz1VGc05AsRTZe38AvBuPkYwX0vIIz4GX928Ksvij8kuu313p59q5Z+r41xIJVDYQtVnJZg4e+sI9CLI9dz2FkcmiZArnROLOjBXKTaSx2mfxYnKu/uoGtn8+Tn4xjCXpYclEDHWfW0rTSj65q9Hz9cebuegaxkMO9sJaMWEcsbyVQaybQGWTwwDBWQUBRPAwfzFJKKtQvdBJosDO0O8r2O4aJjuYoFQxEWaB5oY1Whjl8X5TuvJ0arw2Hv4zFZyU3mUDXVEw1fqw2M6VEgbwjyOSkm+E7yoRdIUR3iaw9zMK/Po3Gi5YC0LDEQ/maNfTuy/HItyfZdKOTjo11dGyse9HvqzCXxmyGxrPbMftc1P2WdWPhu9Yg6BoWr42q5S/uW6HCb3griY/du3fz1a9+9WWFx2+oqqriIx/5CJ/61Kde13wnLT4ee+wxbrjhBr72ta+duFZdXc073/lOent76erqel0LqVDhzaT3mRke/lo3BgIXfnIJ4Q43skVgbG+MyGgWV8CMWctjPPwIC3qnUTacQW6Bi3SkRFkqzaf2nsxgMUvYvF6WXdHBrnsnkM1p3EErzWsCXPzhEDM7htnxeAZV0THrJYoJDUtdFZmShVJWxxmU6VrnZckZPp50CWQnVTy1Jt75TwsJt7kwDINyvozJbkIQBApZlYHdcRTFYPevoqQiZRLjOaxGgVysgDobwxsyMzmWxYgqCCYTOcWMyS0jmiQEk0Tb6TUsOsXLyIY6pg6ZaT2rkYs/swLZLM3nQonlKUwlwOPG0FXMrfX0zzjJBJyIASs1IYlArQUDAc0hgmGmcZmHs/6iDoukEp/NI0oCkgSSoGNYzYQKo4jb9tIYK1IUu8iYm1n6jqWM/ehZyOeRRInQqgam98+QncuTl0TSZhPJ2RK5OhvBxQsIL/LRdfZ8ZlIlU+Twfz/H6HNjxOMCRtcCxg7GCbW5TzzjYiLP1LMDyFaZ6NNHSfVM4u6qYfEHT0e2P3/gOLiyAf/iGgRJfMmqwRUqvBWx2+3EYrGTahuNRrHZXt9ZqZMWH2NjYy86ZHr66adjGAazs7MV8VHhT5rupyMMH0iia7D7F9O855b5UPD3/dcK+nbG6Dq1CunYUSI/fojUQJTZrbPU/O0NrP6P1WSTKsWcRmokTt+WKbw1dlJRhZmBLK6wg0C9jXPe18jQrY8yvnuSaMpL0tWASSvgqrIQj+qIASulZBGXE3z+KkwWifYNAWSTQN1iL74aG7qmc+S7u5nZP0nDGS0sfOdKtt81wd4Hp7E4ZKx2G4pTItxhRYtrqIpKuL6a5HCStGaj5GrC5pJpXuxEdtmY8TkwWyRazmwkPZOnmFZw17rwhCyIkkB0Rx/dvxplYsZEyFtDcLMH9+I6RotVZB6cRbYZ1LQ5sVdJuOpchDo8SA4bc4MZVl/RxNz+cYafHsMVdrDs3Ab23D6H15RHc0g4w06qLC6SswqGCioiqYk0allHFMDktRFe20j/lilUTcAwSXgbXORms8iGQte5bZz9/xZjsvxWfhPDwOIwYVMFbI0Oqjs9L3jGQ/cdZOi+w2QiBfRYEqdXxhrOoxUUZLuFsT0zDDw9Qc3SKhac31SpclvhFXkrWT4uv/xyvvKVr7B48WKuuOKKl21377338rWvfY1rr732dc130uKjVCphtb7Qp/qbn1W14jet8KfBzLE4B+4awB22s/b6rvl6IUDdUj9mtw1NE3CGnw+vbFnlp2XVfFl2ZZ8H7A5UMU1RtHFsyyzHjmisuayOxWdWoZ8eYOHZdYwfjrP9x8Okp3MEml0sO7eawlSC7EQcI1/Ermcwd3rQMxLTPQkcYTeSXSIzp6PkNQ4/OsPy88Kc99FFzPSmCLW7sdhlstNpJneMUpjLMf7sEO2XLaKUVdEUA0VQaesS6Fzu4LTrGlCyZUYPJ4mOZklN5UEr4vLKLFtQxq6NEhmUKGUDeGsd2L1mfDVuOjfXk5zMseiiZmI7++n9+iNM7p0l62tCXd7Fun85g7GeLHu/OYRS0FlyVhUL1nt44uvdJCZV5ICBNjRHbCTDg5+Zw+MSsJh18vEimd1R4sNp0DTCNQLrv3AhtvEO9n5mN9lBCXUqxZH7Z7CKNjzVDtZ98VzqzlnAroeiJI5EkMMBzv1IO0duP4Cu5LHpeQxdp1w0UOJZCjMpFr1vPXWDMWz1AbydIZz+F4dPzx9CLYIzgGgSaLhyHZaAi+kDU/zqIw9RzGtMr2qiZmkV3rpKmG2F389bSXx89atfpbu7m6uuuopwOMyqVauoqanBYrFQKpWYnp5m//79zM7Osn79er761a++rvleVbTLyMgI+/fvP/FzKpUC5lOqv1Ruj1WrVr2uxVWo8GrpfmiE0T1zyGaR2mVVtGyYP0Ox9m21iDYLmUSZVecEXrKvadVSgl/+OPmnBnGqQQZ3FynNJNHLOh2nBChly+y5o4/tPxokk9LAYoHpEvt+2ofbI2BJW8kXTMht9Zzx/ma+/+FdxEaLOHIiV72/k+lBFzP9WeoWujFZJSx2+QVZTW0BO4GF1cT0GYJLazA5zL/O9yEz05tkeHcUk1mkvsvB4s3VPPW9EXqfnSU/mSfUbKdxuYeq/DhjO2NMHMsxh4IkCnhCFiwOE2f+1bITc808MY1RVrHaRcp2geouL2aHzLFn54gOZ3CHbITbnQgCzPSnSU3l0XJ5Qn6NVH8CLFYsXUFCzXZaTqvhyJOzyFYTSqqMoCr0PzTAhhuXI9ZPYO4bRVA0DDWHRI5M3szjtxzB/asYCTzkA2aqmz0kxvNUNdjIzOocvqefo/cP4a+R8QtJZDRqz1nEwg9tfNln33rFCmSnDf2XI6SLZqrXVlN7ziIARh7rQ03nUNNlRFXB4nxjchVUqPBG093dzec//3n27dvHzMwMdrudRYsW8clPfpJLL730VY31gQ98gO985ztcfPHF/PKXv/y9bT0eD8899xx33XUX99xzDwcOHOCZZ545keejpqaG008/nauvvpqrr74aUXx9LstXJT4++9nP8tnPfvZF1z/ykY+84OffxAVrmva6FlehwqvF2+BCNgvk4kWG9sYILw5gc5mQZJF1FwV/b19BELCuWEjXioXUxUtMzPYQm8xT3e5EEASOPTLKnh8fJzOepSyYUAoSxUySjJKjeYUHi6sGra0W2Spx5NFpIn1JDFUjHy/iDVtZe2UjiekiVQ22F9Rq0XWDnqfnyESKdL5jNYtEDUfYhSCKBOpsnP2+ZvbcN85cXxpBFObLwQOaoiGaZQJdAdZeGmbReXXMPWmm58lpMpodBRFlcITkvgEi3iAHHhinqtnF+utaqTq1EyWepSZTZCpmQRPK9Dw6wfjRFFaHRLjVzqqLqsnFisgmA6FcQphKoRfBrimUVZBEOOOT65n55V4cQ93UOQXSHg/F2Sx7vn0QJVvEEzQR6nQz2x3DQRY7BQy1QKp7hORIChqbkGSZqsIEIcFPeZGXsedGKaYVdJMFISYimNL4m9zkxub90Uo8Q+zZbkweO4EzFzO5d5rBx4cILQnRdfUKGi9YRHIii7/ZfeJMh6+9ipplITRN4JSPr8HmeemkcxUq/DZ/DMvH6OgomUyGd7/73dTW1pLP57nnnnu47LLLuO222/jgBz94UuPs3buX73//+y/yWPw+BEHgmmuu4ZprrnlVa34tnLT4uP3229/MdVSo8Iaw7G3NHL2vj2hfnK3fOIhgNrH5g52vehyn38Jlf7+I1EyBcMd8lVtBFNDzRcRyCZNJICuaEYslLDYzFq+Nro019G+dpnapn3gKRAE0Adw1dhaeFZ5P4972YlP/RHeKp783RD5ZJjFV4KKPL3hRm9Y1fkb2xbC5TXScMm+5aV3moDSXwh5wMN2f5eizR3FW22n98Hkc+/IRagpTrHVNEP9ukkGpk5G4h+ljKRpXBgi2ubGfugJxLs3ov+1GySpY909jzkl4Ak46T/HT/eAQB+8aQIgncIl5pHIRQbBgcUjookwhb7D1X55D2LcHJZol2FaDK+yg99ksVqdMcjxDPGqQy4vYwy6MySSGXsIQRUSLCYtdwtNsZ024hH90EGFXH8OjVpS4jqHq+IpzNGuTBDr8mJZ04Du1i+3/tRdl90HMcxNYAk5mRots/d4AKCWm901RjGZp3tRCeNELrVudly+ialEIq9eKs8b9ot9vhQovxR9DfFx00UVcdNFFL7j213/916xevZr/+I//OCnxYRgGf/M3f8MNN9zwusJh30xOWny8+93vfjPXUaHCG4Khg6booINWUCilX5xe+zdoqs7On48x3Zdh5SV1tK3xn7iXjRURRYGGJV5g3jpRwoTJZcWNQKZkwht0ImlmmhbZWHJBNTv+9xi5WBGH30rnpkb2+0xoRYH1VzciySKTPUkGdkSo6XLTcVroxIFHSRaQZAFBBPElit9lptI8/o/PMdadwdFezcSRanw1VvoeGyUxkmF0ZwnNbCMVLRPoChC6OMQVf78AodegajaBlsrjadQxF2VcQSuSSeTuf+kjPlWga7UTm9dCMZqlEE/gcZqpXu1k8aYg377yEdKTacR8AUE3KOsyeUUGh51C2sAcyxA7mCNsNyFbZLwdQSbM1QiOLLpZwORzMfbcLKWsBW+tm1CLF4eYp2pRkHRapPWsBsw2mZEfbyV2PEIurhDPOlBxIQBBMYK1nMEpWfEuCfHkbd3MHI4QliOEXXlMPgcHfzVNfLYMmQylqTi5qSTR7jnO+udzMNmfr24rSiJVC0NvzCarUOEPjCRJNDQ0sGfPnpNq/6Mf/YijR49y7733vini4+jRo+zfv58bbrjhNY/xqtOrV6jwp4zZbuLUDy1BNEm46j2c9p72l207O5hl/y+niE3kiYzk+ND31iOKAuOHYjz9reMIosCmjyykbrGPsaNptt8XIS+7cYVKVHeEEGtChJx5+n52gGd3HCdTkFENidRMHm/YTNMSN+WCiqyXKKTmv6FPdCfx1dkJtrrw1doBqF3g5twbO0hHS3Se8uLzKMfv6yF2cBwtqqAF7AiigGyRkK0yJouE1W1GlWWcSFQ12kn0TJOdSOF02qhbtQRntZ3mi06jKQ6eGgfpWJnpgSylnMbseJmzb1zOzm/uI3ogjSgaBGqtJGdKlCULhigjOmwYhSIl1UQ5ZmAqq4iKArE8+JykRR9SW5iUt5G5+w5hySs4mhoILatBeHAGJVsmOVKiaIGqRgflSXCGLAQXBTnyw4MMdheRp0yoqokEbkQMRCAleqmyKpjbm8gYDtJTw5SSeeJ+Ny0bOmi6egnjz+pYs3bc3eN402MkxqopLA6RHoqgpgv4l9Vjcp682blChRfy+i0f/Lp/Op1+wVWLxYLF8vLuv1wuR6FQIJVK8cADD/CrX/3qpCJMMpkMn/70p/nMZz5DOPzSeYNeL/fffz+f+9znKuKjQoXfZsH5LSw4v+UV2zn9ZlTFIDKap1TUOf5clEVnBpnpTREdySKIArN9KeoW+5DNIrJZwFYXYNE5VVz81/Oi5hcff5rCTBpd1bG43Ug2B/7OIFUtHuqW+hnaMsKxBwdQkgUEtwdREkjPFfjVVw7TsMzP+utaMdtk2te/9CFYALPTgr/Rib1KZ9E72mha6UcUBc76m6V0/2qcyf4swwdT+DurOO8jHYw83kduKoXkduG++gwO39nD0Lsfp25NHWf//VrCbQ7a13iZG86z/NwQmeks6bkimmzBvyjMwqsXI1gtLLq4hUivF2F6nGR/gVTRwKLmMWI5MJvQZZl4RGPaV0+8N411VzdeNYErZKWuFiwuM+4aO7qmo6UyFJIac0WF1EQOySKRjZeIdc+Sn0ojaU50UULXJWzkcIoFJJsZ1wevoeUfzieb0pG/shtvaQ4pIjBx3I5rEs756wVMPTeE+rkjCOlJMuYk3vOvpPd/tpCbSlG7qYvFf1PJwFzhtWHw+qNVjF//v6Gh4QXXb775Zj7/+c+/bL+bbrqJ2267DQBRFLnyyiu59dZbX3G+f/qnf8Jms/Hxj3/8tS75D0JFfFR4y6DrBjvun2OsO8uq8wJ0rfOy/KJaEnMlbC4TuUQZANFmJhHVsDplqn6dxKquy8mFH2klMV2gqlpioieFzWOmfVMDI08OgWBg66hnNiozNaaQjJQ57cYlHH1wmGKsyNHHJvFtcJLISBSnk0wejjNzPEXdYi+t61/oDjAMg+xUGrPbisVlYeHVi/E0erB4rIRX1pxw18gWmdHDSQYf7kNN51GnYgxuc5Edz2K2m1j+9i6yUxmO/3KAzGyeUk5l4cUttG9q4G03dcwnQrNKDD1bwuI0Y7IGaD2/80Sl1yv+fiEjT4+w+2uD6C4QBZncNOg6lHQzhmoiOqGjjMwiGhqiQ6YkWqlt8FG9poEn//MQhXiehvxxzHqWuOQhbgQp5lUkXWBo+yxqpoAk2bBKCp4GN6JZRh8rYM0rCHmFwYf7WfzxC3DXOgmEZJLjBmpBYXbPONNjZeSAh0WnVJFY6KNoJKhaHELf8QizDx4lamvH3vzyrhYlU2R62xBmt5XwhmaE13l6v0KF38f4+Dhu9/PnjX6f1QPgYx/7GFdffTVTU1P8/Oc/R9M0FOXl3cgAfX19fP3rX+fOO+98xfF/l/e9730n3fbQoUOvauyXoiI+KvyfJzKW5+hTc+gG7N+SIhMvk44ptK/2sOayWpSCBgJ0neanmC0zeryAXOXDMAukEzo7fjJEfCJHy9oqMn0z7Lx1klhEI7iynos/2sE7fvo2osMZJoYVMk/OYTKJJMczmDrcFA0LZSWLVhApRSSyUR25LCCUDSSzhLPqxS6B/geO0feLHuwhBxs+cQb2oJPmTa0A6JpOdCiJzWedj3wRwFeawa5G0Itp0sfDRI8nkG0ymqLhrrZh9VjIRQuYnRZ23TVOz9YYm25cgKd6PkNh82l1CLKIADSsfd5MK0oingY3nkY3sk2iPFQgMVnAEEUUqxsDkVK2gICKIQqILieKy0++topju9JkR2KIc7NYjBmsdokqi4DQ0EIhlkcpayglHUQTsseMt9PLVbeeRTGWZ+unf0nhcA5D18nkRXofG8bpkmi7fDHDSoH4QJx0UqacLNP/yAALTltPweFH96exylDYugNvOkGEIHrLyxeNG7z3MEO/OITssCBZZEKrG9/YjVfhz5438sCp2+1+gfh4JRYsWMCCBfOHz2+44QbOO+88Lr30Unbt2vWyCfI++tGPcuqpp3LVVVe96nV+//vfx2QyYTabX7FtuVx+1eP/LhXxUeH/NIZhcPc/ddO3LYqnxoar3oPZIuKvtSCK4K6ycMFftaNpOlv/9xj9T46RT2tYbF68jW6UbIk994wyuHWKcr6M2yfh9JvJRTXE0RyzQ1lmu2OMHYoTanWy8T1NHHtohH0/7UPUyjiEPMWwB9+iMFLYjjcg47I5cXtFznpf6wvSg/+G2YPT5CM5SukSqdEk9uDzETKH7u6n58FBHEE7mz+1ho3v7+DosW0o0zKivUj86ARzg0Vs1W4MaT4zqavOhaaB2W1hbiRHbLLA2IEYSy+oxzAMdtw9SfezUTrX+2ncMP/tv1zSmDiWwWwxYe5sZmJ2gmyxDE4nOiIWv4v4eIZ5f7aBKItUt7sR7FaKufmCcWazgWq3o6guJFnHaGwk1OpGcekkJgsULTLWriY2f7CNRZtqcARszB6LUX/lWrqLJoy5KB6XzMH/2EIyJYLDjn/5MsIbbeR/1Y9F1alfUUV5KkKxKKC7QsiFMpLXie6XMRYso3rtywsKXSmjqzp6WUMvV9ICVHgxf0pJxq6++mo+9KEP0dfX95IZxZ966ikeeeQR7r33XkZGRk5cV1WVQqHAyMgIfr//ZQVQQ0MDS5Ys4aGHHnrFtXzpS1/i5ptvfs2vBSrio8KfMaWsgmGA1fXySj01W2SqJ0UuPl/V9Mp/XITFZaFhgYNipoxaVHEGbWz57hCP/+thlFgaq0OiqkslUSrx4J4xIkdm0fIFBASyRZFAUxi/14omanQ/NkExUaRc0MjGFOraHRzTdUpphfxYBIdTwC5qXHBjKzUrw0gSeEPm35vau/nsNgrRHM5aN/7O54s8ZSIFDv9ikNnuGPZAjvhYhpZTwihXLmH4pztJx8oUkyVUVaCEmWPbY4S73JhsJmSrRG46TTqbR7PYUYoaU8eSTB5Lse+Xs8RG0kR7otR32mjfEOLpH45y5Ik5spNJCpEsSl7F67ZSt9KFIZs5/GwcraQhICAJAma3leoON1WdfgzdYPZoBNntwOEx4+5qITaYoBzP4U4VqOrwYrbJCF4Pi9+1iJUX1iDJIqmpLFu/foDepyYxVJmgXUQs5MiNZEnrXspmjZJXwRJ08/Zvn8/g9jnSioVoyYnrtOUU+8YoLFvF8WfnKIdFVv6/TbT9nrM0rVcsx+S2YXZbCa2pWD0qvJg/JfFRKBSA55N7/i5jY2MAXHnllS+6Nzk5SUtLC7fccgsf+9jHXrL/+vXr2bJly0mt5Y0oTVARHxX+LJnrT/LcNw+RjZUILQ7SuanuRWcnACwOmbbVPsCgaZmPRWcEkE0S8bEMW245iJIrs+q6Tvr3JshmdISihigKTB5LkUqmETQFE2XEX78NgYjmcKEUIXI4xlx3nM4zgjSu8NO2oYpcVqNQEpAcZprWV6PnFao6/HRtqsVsN2EYBqWCDpqKyTaf/Ox3qV3fgLu1Cle1DVF6vrbJzh/1M96dITWaw1UWSUyXaBYEXOsWoD42hGjRcaga9rCPuSmFIw+O0rrax6oblrD7fw+ST6XITyQpmlQe+c/j1C1wkZjIUyxolGbSaKLB/p8N0LI6wOT+OXITcfIJZf6tUzewVztZelkNx5+LIpskdEXDEE2YvWZCC/2svKSOuk4HqsnKw8eiuGo9hBd6OOdvl/C99d9GjyRJx+N0nbOJZdctoXZNLVaP9UTCteRElonuBMm5IoZu0BZIYdfLzFm9lBQHuNy4w3baN1RhrXbTe3CExGSMmb4Ma89bTjQTYrpHZnTKSbA4SWloAta/fIVOW5WTzmsrWZgr/GkxNzdHKPTC97JyucwPf/hDbDYbixbNZ+2dnp4mlUrR1taGyWRi8+bN3HfffS8a74Mf/CBNTU38wz/8A0uXLn3ZeTdt2sSePXsYHx9/0eHY32X58uWvK9IFKuKjwp8psz0x5voSzBxLMX4kyexgFn+jE2+N/UQbXTcY3DFLdZOFxZs6WXhWGNk0/2EeGUgRHUqhl3Vme+K0rfJx5H4Lut2Ff7GHbFrDiKcQjPnkYggSSBLmKhclVSI5maaQLCEIkI8rXP2llahlnTs+eZD4nIYraKfjvCD5SI5FF7dgtpvQdYPHvjdB9/0D2AtRus6s5tSPrsPqef7ch1JQeerrh4kOpmk9NUzj6iDBNjcmm0xuOo0gAC4XtrAXXZ/v42oK4OqsQZzL4WxqYOCJAplEnGJeY+9dI2x+fyvBhVUkZwrzr0USKRdVykUNQzdoWOQmGJbJx4qYzCKxgQTMzmCKJ2lbEia4MEjflnGUyQiHfhLH6rOx5OwghTw0rAzgCjvw+wWm7t/DQDTHonetYt1fdDBxMIKRzXPkrj7MHhulRApV0dh3/wSGy0P3th4K6TK+Rg/52RQjTwwQHS+gaVBjTNFY7Ke+047iCZGJeZBkAYeaIvp0N4XeMSTJjGQSMNJZtn3pAKnhBCavjcXpA/hSIyQ/9STPTX6MUz++4SVFXoUKr8Qfw/LxoQ99iHQ6zZlnnkldXR0zMzPccccdHD9+nH//93/H6Zx3w/793/89P/jBDxgeHqa5uZnGxkYaG19swfvYxz5GdXU1l19++e+d98Ybb+TGG288qTVecsklXHLJJa/qdf0uFfFR4c+S8OIAwU4f6YiCaLcimeYTdf02E0cS3PPZg6Smi7SdEmLNFfN/mJqqk5pIIWgaSlnkyO48VU1Q0+mkmLaw4PxGHD4T939uP7oiUL0owKKLWpjoz+PzwPRIgfRsCV0zsDhkwp3zGVB1VSM3ESN+dI68x8L+dByYf/PZ+DcrSM4p9GxPkjw+Q66UxWk3iPXHqVtTe2LNifEsk4fj5OJFRv/rKO46Bx2n1/x/9s4zTpKrvNdPpc55eqYn57BhZnPSKmchIYFAJhoMmCjANsnGYONwsY2zweaCTTBgsAkSIAmhnMNKm/Ps5DzTOafK98PgFXslEQ0SZp7fbz709Ok6VafqVP3rPW+gZ8RLfXqZpohB795WOna3MXBelJNfO0o9X2f9W/Zy6HvLHHusSHpBBUHEtAQEtc6T/3IY2S2x4w0baD6vTnJJY+9v9uBwSqSmSwxcEMNUDVITBTq2NlBLV1Bkm+Z+L727QsR2NLN8NEFuxUarGrRvC3D++3fT0Bs8+1A//e1TPPX9aYy6ge7w8qpbtqJlSxz56jSiCO1XbWDqAS+5hTq1kxVW/vY0vvCq5Uc1kgiZDHalgmRb+PUKDaSQa2UE20XbgIfRAhSWyhiJNGZDjbZQhS037EJ6xU4cRpUn/uwMtmlhVesouSTOWg53LcfM575F5tp+mjauJRhb46fnhRAfr371q/nCF77AZz7zGTKZDH6/n+3bt/PXf/3X3HDDDT/XvryYWBMfa/xK0tgf4qV/sZfcUoXEeJHGXj/+Rvc5beoVg3JWR1dNUgtVaiUDT0Bh+WiSM3fOYGkG5ZKMmYZSvkS4xY3U6WHwvCiltErbcIRKts7O1w5w2dv7uPX13yV1NE8+78Iy3GCbDJgThMaSTD3azhNfPEPy6TkU1cAhy6gVA4dbwjJWTRSBBoW2QTeFgw5kWyDUFSTcEzpnnxWXRGN/AGPUYnk0TzVRQq+ZcCyNdWAUX7SBXa/YTd+V/Sw8PsuZ75zGrBsIooDSGEYUi7SEa2gei8CGDvp2+Zl7bB5REmla38Cu324DILdQIrdYYedNXWd9ZmxBZPpgjtZ1ATbeOEQ5Xmb9DQM4gy66djQRaHTQsTHI0JVdNA2Gz9nvmeNlskUJybZZSQjs/84iT/3nAmZKo7nfx9ab+um9fgP/+b6DaAslEJz4RHAFFNS8iex34fSCSzGwMiqFSox0g0z/y7cTEFvpvu8uipZAWmwjVp0lYFdxj0r0vGU3cmsvRvF85h+dIT5VZcw8j+Hl+zBFB456mbnbjqL4dhPuCv5M11rx9AKZx07jG2gleunw/8h69xprPB+vec1reM1rXvNj233pS1/iS1/60o9t98POpy8m1sTHGr+yOL0KzYMhYgNBxu6fZ+zuGfouaqNzRwzbtmkaCLDx2k6WThcZvqoFl2/1clc8Cg6vgqmahPxeSggY+TqCU6R7ayPFgk21aoPDge0UiM9rnPr6CeKPTWDUDBRXA4rLS582wa7K44gP2TwykWPJP4RW1gCbYKODLb/Rz8nbZ5h4PE7PhQm6d8bYcZGP9OMuzHoD3t4mPA3PLBPN7o/z6F88jl2rs+GaAYL778NVXKEy001u2sLIl0G3WRkr0nO5vZoHJOBEQ0DyODAmU/gys4TFHDUBtKKXfNpNrM9LZDBK+47VMNpSssp9f3uU/GKZcG+Ygat6aR308OBnx0hNlWhZF+Smv9iKw/3M7WHXq3s48K+HUFMlXEEn8ckSc4fTDF0YwxtxkpwsUlZWBcnASAvH7olT0Z24GpvY8sYBOs9rQ6tb7HnLBk7ctUhDk8yO65s5fe8S6liJpk0dXPHWHqo5lQc/ej+qpKBdeyEN77+c/Zf/LX4rT6NYoGdHK+2dG5AX53A2+hFdDiRFYvi1mxh+7SbGH1zg4H82klkM01RfoJqzmbjlKNkD01zyr6/G2bS6j7mJFKkTcSLrmohuiD3vNWZbFvNfepDiyQWcsSDevhierjUryq8LLyaH018ml1122Y/8XhAEXC4X7e3tXHrppdx0003I8k8nJ9bExxq/8hRXKhz++gTFlQqZ2RKtIw08/b0kR+9JEuv185b3DmLoNktjJRSniOhxsv76fgQBXDE/3/v7MyQmsqjLNrmZPGYoSnKhjlHT8YcV8nGV40tJDEsERaZxYxM7rl/Pwl8fRyhYCLaNoRr4N4YxC1UcLgjHHOgVneVTOfSawf1/e4S3fvMaXH4Ff9RFvSDiDj3j62HbNge+PErq0VEU0aCoFOgK5LFMjVB1gul6K2YdDL+f0adLrL+hQtNIjMEbhzl9+wRLJ/OkJvKg6VSTZQxkzJBK6ukpgj4LmR+EkzokpvanmXoqhambLEzWGR+3Wbc79CPHeOVInNRoGlEUmXponge+OEd2Okfz+gjvuOVyIh0+2rc04o04ufL3t/D0d+PUywatQ1H6LmpDFAVcHokbf7ebG3+3G7Wqc+Ab06QmcihuBadPoWNnM8mJAp6RPuqjCUqJCtmpLO7+FoLHHqPVMYtYgIOp68C/nfUXjSA2hLE1Df3I06A46HCINA5N43rDdirBG3jsY/fiOXgIuVgl8YllWt75GmoJjdN/9HVSOQVx00au+pcbcIU8z33ggoAc8CAoEpLHieT+8TkQ1vjfw6+r+LAsi6WlJaampgiHw3R3dwOrVpRcLkd/fz/BYJCnn36az33uc3ziE5/g/vvvJxp9fgfv/5818bHGrxSGZjJ+9zRqSWXw6l68UQ8Or4I75Fgt6tbgwhYETj6UJrNUp14xae33cuj7CTKLNURJQF9OYuWLNHT7MX0BTt+3gqTXMRWNSJsHTZVQqwqSCOV0nVLAZmW2SqtRpSlQY+d7+pnPyZTXbePYqIknqBB57bWoS+DvrWMVKxSTKj1+B7JTwjJtqnmdO/7sIJ3bolz07mHqBY3u3c+8cafnqyxO1dF1kBSBuu2gJPhxq2nqthuzrlNxhlHDnXRGnZTGlhBKfhITBfIrdVip4wq7KXn8GCEdQXHQfXEXrnKa9KkEpcwKp78/w/DL+zn2QIaqoWBr4JY1hKkpap19XH7zepZHC3SMhM+xegA0DEQIdQURJRFHxEs5XsZUDQpLJao5jYvfM0L/Ra009geJdge4+mYv6YVWwi0uHK5VJ9/cchVdtWjs9nLm/iUO/OMTaAtZBLcTR+c66gWVlg1hNl/dwqH5Zcx8mePfOM15f/8bZK0z+M9oJJZLVPQsx0p9TNUyXCwtMOI/Sv3Wr1IvGxSnBWRTITA+TeRv/pCR142wXJimsXAc8chpSp+PU043IoyN4ygKzNeCLBzNMnDJc4sPQRDoeefVRM4bwtPViLMp9Au7ttdY48XCxz/+cV7+8pfz5S9/mde97nVIP4i6M02Tr371q3zwgx/kK1/5Crt37+bLX/4yb3vb2/jDP/xDPve5z/3EfayJjzV+pVg8sMKR/ziJUTMwVJOdb9mMO+jk0vdvIzWZp5DW2f/NOTqGPKg1k5ZeLwDFlEYuXkewLMypJKKho2arONtXIz7ARhAEvCGZaEhFQWdpRcBSDZZP1QgbWTr1KQKlOtX/uo2233sXy9tbcF/6Sq78nQ3c/k9TFLIFqgUJxXCA6STQFeK6P99FYrzA8pkCcwdSZOfKvOzjOwnt9J5zXJIMbr2IEFAI9Ldhxpo5fbqEVwWPouMJyHg6G2j9jXWEPBpj//oIjqAb90gfTr8DySHhjHgI2QK1lhDesJvz3zKEZPVy14cfQa/D6F1zdJ3XijfkwNMcRNYq+HMpBFsnoidoXbebtg2h5xz3tu0tBDsuQZQE3BE3E0+lmXp4iXVXtGGZFse+fAzJ1mlftxkA2SHR3OcjsX+G098dI1X2kkjYaIU6Gy5pIhCWUJN5rEoVoa6Sm0izdCTJ0FXd9F3QwuJjYaqpKu6wC4fXQfOH34z5dR/inEVhaT3K7KofTXapit1ZoZ4psXwiSyHpwy26KDqLjP3d4/RcP8zwx1+N+qV5hNQ8tfFFLE8AOerHtCTMWBu1inX2OI1UFjORRhnoRnSuWjmc0QBNl2/6H76S1/hV4NfV8vHBD36QN7/5zbzhDW845/+SJPFbv/VbnDx5kve9733s27ePN73pTezbt4877rjjp+pjTXys8SuF7JSQnRK2aaG4nrl8Q20+yjmd+//tJLWCxuBFMV75oT5y8yU8YSfDF0dIL7uJH02SnJMQTB1bFOm/pA1LSlFMOlE8AtVKHUmoYqY0hIKMbirglJCaAtiWC0OvM74/R/6L45z/9g0M7omiOCVaBrycuX+RalbDE1BwN3pRHDKbXjOIZVrc/YmjzB9O42904wo823TvQKfNX6LU7qChQ6JQraKXVaquCMFWkGwDOQDZx04xv5jH6wW/IDC4rYnOS/p48G/2M3HrGM6gi+2/NcLG63tpGgxhWzbtF/WyeDiJt9GNJ+Tkqnf3oxbrLB0qoVZMoi1OIj0BEARs22b20XkqyQpdF3RQzhusnM7RNhIhNhg6u783/Ml2jm1pQK1o3P8XB1i56yiCaZA6usyVn3wpwc4QxdFFDtz8JbITaZatZpaUbhyyjZoscNG7NtAwGCV1TMMUZWSPg3DXaubFcE+Y89+/h4UjaUYPVVn6y1Euf1svvt//EPLJLC9RLWaOFKjkVLZc24aroYmVwyuMHppkstZKRCqijCoYsyfITBe59os34W/5KIt/9HeUV3REb4iW915Cbs7DoN9HR5eIbdtYmRzZv/os+vQC7kv3EPnd3/ofuWZt26Z68DT6cgrv7mGU5p/cNL3GC8uvq/g4fvz4s4THD9Pd3c2nP/3ps5+3b9/Ol7/85Z+qjzXxscaLFtu2qRZ03H4ZUVoN6Wzd1sx579mOVtbpPK/1nPaSIqI4RVRZwOES2felMaafThFsdRNoC2Dm6vg8FtZQmOREEdPpYGlK473fuZSJfRke/o85rFQWy6qgqqvRH6Io4Ak76X5JP+lxB9P7x4iXohj3xzE8AVoGAkRa3ey4tpkzd81RDQnIDom9r+9l4IJVx8RyVsPTEqD3Ije7XtWJy6c861hdEQ+xzc243AK+7giVeY3GkRgOp4jodZA9MIGUyVJWi9QtJ+EOH+uu2Uh8ooSm5qmmqtimhVFVaexwEW7zkDyZJNQV5ML3biF5JkukJ4jT58Dpg1ivl8SYC7G/h4HrY2x61TrqJZ3R788wdstJjLpOaixLPCGQmirSPBTk5X+xC4dn9ZYx/eQKj37yKFrdwO2y0PJVbFVj6sEZ+MhDXPqxCzn02cOkTqxg6waKXEGQbSzNQK0YjD+exL25j5bmCN6om71vH6FpKHJ2PBrXRTn1dJHZ43FkZ4Xe7WGsUoUjt07h9CkMX9XGrlf0EYh5SI1nOZQY4VTBgy4aeEUDsVSEuoFpdSMpIkLfEPbQhZilMWS/l6YbziNmW8T//mvk/rGE8KorcHc0Uj86hjY5T30hje+V1+Bof35n1J8UbWaJ1GdvxUhkqY3O0PLhN//c21xjjV8kLS0t3HLLLbzrXe9C/P8KLlqWxTe/+U2am5+pA5XJZIhEIv//Zn4ka+JjjRctT359nlMPJmhdF+Ca9w4gOyREUaBzT9s57YqpOsmpErEBP5e+Y5DFAyuEOxw8+bnTpGfLCIqEvyOEL+pCNAy8ESeKU0S3BaorBVweCVEWWDpdBFvCs7WV4mIa3dZx+mQ2XNnCyz68ntnDzdzxcS/1mSJWzSJ1OkW1oJFa0pAdAj07G1g4nsPb4Mbb6D6bd2T/txc5/L1lNE0go/q45LUOWjpWBYihGpi6hdPnYMsHryB+LEEmCyH3As6Ak7bzujh4ZxzNnEJSTWynFxmZNleazNfu4eBYACnsp3lLDNEIEFPnMe9/kIdvf5ps1UNsU4zzP3wBHTubz2YSBdjxyi7cQQVfg4vOkSBPf32GsYeXqaUrGPEc0U4vgvSD9raN/YO64PnFEk994RQLBxPkZ7PI9QphXxnbqlAVFTRDorRSorRS5uhdK8iaDwmDrNiIOyDiDfsxNYuVqSquMAye38W1H9iApEjnnFNTN1k5vIJ14iSKw4Ckn1wGypk6yScnWbnrGKGBRm766ssZvWOCxD1H8VWqlAU/TklDlAQEh8jmt+1ElKXV6KeYTUBYRhnowdEcIfOtByk+cQLJ7aC67zjGUxraUoJKUaek25T+6xhbPnTVz30d25aNbVnYtg2m9eN/sMaLhl9Xy8f73/9+3vve93L++efztre9jb6+1QKNk5OTfO5zn+PAgQN86lOfOtv+W9/6Frt27fqp+lgTH2u84JSTFRYPxgm2+2nZtGotMDSTM4+lyC3X0Osm2aUaTT2+c3+XrqHVTO799DiTj8fxhRS2XxlhZd88MxUDmdVU6bJTWi157xVpWxfFSqQx5lTqqsa6q3sJNbuYOVLA1FZ9P5JjBWSthtuoY5VlEieTfP9PD+LyK/SfH0PN16kmSpRmMtz9qTPEMy7U5SyRsEm9oLE8ViI5U+HCV7VQT5Uopm0M3WZ+2mC2UiZZzPPeP49SSZTZ96kDqEWVrW/aTOu2ZvbfV2D2SI6GTg83/tFlBJpcLE9UWD4g4w54aF/XQCQiED1zgsThNL5aD8vlXjr3duBXajCfIK3miM8ZJHx9qDWT4ocfwRV0secdmwm2+bFtG8UlsfvVPRSTdb7xgadJnEqjVzS8jW7C3U1seGU3G27op5BUzy67ODwyo3fFmd8fp5qt4Wtw4qkUUapVbEEF2caKhGkebsThdyLaFhmpCQsBT28zzpCbckbFMkEUbZweiYZ2D5aqP0t85BbKLDw6g5KJYwkWJz//NOGrdpKeLqFkywgOKM1mSJ3J4MzHiRam8Vs6KV83juZGHGoFd28z0XWNANjpDPahIyhmDe2Oe1nImpSnk6jZCorXwBHyoD10BLx+ig43CV8/2qSDTZqGlS8hRcMI4s+WJdXZ107jW1+OvpzGu3fNd+RXiV9X8fHud78bURT52Mc+xlvf+tazuW1s26ahoYFPfepTvPvd7wZAVVX+8R//8WxEzE/KmvhY4wVn/+ePM79vGX+Ll8v/eC+hjgCSItK/uwFDNWkZ9BNqOTeB2NKJDI/831PoNYPUik5utkhOsJHKeQI+C1EU6DsvihKu42300LMjwuKBFc58bxpyOfwRmWiPnwvf1Idp2HiCCq6AhMNWcRSzGHUN27bAMEkcWiE7nqVtY5iL37WBeiLMxKN1RAlqeYPcYpnKRBq7xUEtU0FXLdRsmWPfKCDZJr4WL7teOUD2Dp2C7sa0Vs0IqdE0yVMpLN1kcf8SzVuaqZd0TN2inKmTWagQbHZz8bvWs39hHD1doGlHCwO7IxQ+f4rETBWdAEo0jOhS0Go2cllDsEwq/jZ0Q6CuQuJMFkmRWTyUINjm58j3ljhyxyINnV58URfLE2WqWZ2GdjddO5rYeHU7m67vWnXAjXpo3fBMQrFQh59Aixd/zEPHjkasTIHU956mIoEsOpFavdTzNZZPZrBlBVfYTXR9lI7LB5h/Ok5ppUKgxUus38f5b+4j/+ARnvrQPjpv2IIVCCO7ZEqn5li68yhCuoJuyQiiQSYDk9+eI5+xCCpefEGLlh1tdO5uxldspDIUJDdfxjcSY+AtF1CczxMbacId9fDYf86TXyiz1dUEmXnUQo36gTNoJRWxpxNnXwu+K/ZQnJzG7Q9QHVxHWuln445G8v/w72jjs3gu3oX/jS8/J8GYraoYx04hRMLI/T3Pe30LgoDv/C3/s5NmjV8Kv67iA1bTrb/1rW/lwIEDZ4vWdXV1sWPHDhTlmaVjp9PJxRdf/FNvf018rPGCY9QNLNPC1ExMbbW0uSAIXPiGbra8pAVv2IGsnPvWmZwokJ0rYdvQviFCYalMbq7I/HGdgU0e+i/v5Pz37UF0SGgVg8SZLGN3zVBK1XE5HZQLOmIIjtw+T3RDndmjeVqG/DizVXJFE1m00REQAAsbo2ZgAy3rQ3TvbOTRfzuDt8FJ/2WdfOWDJ1A9DgzDJtrtQ6sY+BudhNoUqskKgZiXS97YRWyLzuKMzsjO1WJqDYMNRAcjqGWN1q3NyIrIxW/pY99/zbB0LMMj/zoGNvTtbmTHx66lPJchMtKGI+hGCvqoXJ1n5kmb7p4QGy5s4PCRE0hBL86YD6+rleqKCaaNLAkE2nyEu4MsHFjhsb97inJVpJJvYN3FzUR6QwSbPZz/m9307Y1h/Yjq8p07Y/hjq2Gpkwdy7L83heRsp/faPirpGtmkgaFazB/Pozt9WGIdEYvaUp7cYhW1pOIQNayIwfJDFqWnZymsVFg8VURr6sDWNbzHn0Iq5WmVfUz3b0VXZLpfMkDq9lkszaAeDHL9ly6l/8JWBFEkcvEmat+do+yu0HLNDqLro7TvaqWhN8TkwRxPfmuB/HyRQ2o/bbaLduZod7hovKgHaaAH/66NuIb7kP/kvdjVGhc1NLE9q+EtrZB4z5PYxTKIIv7XXgeOZ5yF69+8HfW2uxEiYby//+4fKUDWWONXEUVR2Lt3L3v37v0f3/aa+FjjBWfHm0doGIgQ7vQT6Q1RLRkcfyCFrIhsviJ6VngsnMgx9miClnVB2jc30NgfJH4yjZUr4HKYWKqBWC+RGavRtTWKKILikFAcEpnZMitn8qhVnWBHGHfYhWXbHP2vUUIdS1TyMvWSgSciIyoigkPG6Xehlg0k0yLUEWD3Gwfp2tGIIAi8+h/PA6Ba0BjYGWTJJ1DLayhhiXCHwMjV7Qxf00J2qkDjYBjZKTOyU2Zk5zMWnGB7gMv+7GIM1cQTWf1/x3CI1M4IS0fT5FdqZOcr9O1uxN8dxd/9TJSEa+cmBnZC7xssEODBT56grDvxyy783VEatndz4v442NB5QRsbXrGOhp4gd33oIexyFUomTe2t7H1dNwN7m3C4RLS6yXc+fhrLsLjkLb2su7CJ+RN5MgtVendECDa5EASBSFcAy7I59VenSB5ZBl3HEfZhBaIUrCyFuER5KoN5agqfUSBT8JCcLJKrOpFlATNfIXGkQmY0RdBtUM+aVDIWLr2CNyBhihKSJOHvCPPbX7gGT5MfX9RJcaGErAg09vrwx3xnl0EqNZF5oZuyt072nmWW9y3g8koMX92OszVC6nic8lwOAZtiuAltXQtbN8VpSBxFdKawr91J5pETyAEPgS29FGaKnPjeHJ6VSXzpGlIuh1LTMDWDie9NUklW6H/JAEoyja1qkMtj5/K/pNmyxi+TX2fLx3/n9LjzzjuZm5sDVi0fL33pS3n9619/NvfHz8qa+FjjBSfSEyLyQzVOjt6b5KGvLKxGr7hENl/eiGlYPPbvk6ycKTJ7KMONf7aF/ktambtnlJnjJXRbQhLdiKqGXtBITubgh0zkT391glpRB8DnsmhwV1gYLVJXJfSQAkWoJE3QHXTs7SK/oiK7ZWTJwuGSET0yYw/HcTgldv1GF1pJxdsSwBN0cM17B3j485OM3j1HfF8WGwGjruO0azhlk0CTk7EHFlk6mmb9S7oYuKT97H45vA4c56b8oGdnlPmjWWzLpmfXquCwrdWIEkfIc47vgSSLZKZynPzqcWoZkaaOHna8bjcNO3uocYr0VJ7JpzPMHj/AVR/ZjuiUCTa76NoV5PI/GMEXduILOwE4/L0l8vEalgmZxRrZpSr3/Ms4+eU6fbsjvPwjG5h9KkEpUaVnbwvrLooRf2oOVAGH30G2JmCFwiwey2BkirQaVSRMBLVCrRZB9DipGyJSrYKt6/j8HvT+XhLHs6h1i1ZZYfNr1uHxrufM1w5DZzOKz0WoeVWYXf8n2zh0yzROv0Kw9YdEXMxF99YwiyfzKKqJnilSOzHFyaNHiWztQqwaYFs4rBoeU6P90p1EOY0Vj2OVS2S/eBtLR9JIfg+9H7iRI3fnmXxkmUByjj4hRJOURJmdJPXX/87J8Sb0ioZe0dn5smsAAbGpAXnThv+RubDGi4tfV/FRKBS4+uqrOXDgAH6/n97eXgDuu+8+br31Vj7zmc9wzz33EAgEfuY+1sTHGi86BHG1jL0oCasl4Fn97AmtllB3+hScHglv2IUkgiULOLwOpCYv+lwBRBNNFVDcCtWijuwU8Ta6UNwykizid+lYVQPqGobtoa6JeJvcpJdz1PIaoe4w0UGR9ESW5SNJyskqkkvG6RLJn14m+/AxFBkC2/qIV4OkzmSYfWAKIb6CwzbRXX5Kc3nGvpVExmTx6UXSJSfVrIpW1ek9v+VZDpY/TLjNy8v+ZMvZz/VUgZlv7GfliWnCW7rY8qGrzhEgmYksimRiGFW8goPEnQcpHphg+zsv4/EvTbHw3SPYps1duoXtdCIFQmx/6xY8YRezR7J4ww4au3307mxg4FgeQ7MY3BvF0CxMzcI0bdSywfyhFE/820kqGZXUVIHLP7CV7i0hiktFon0hTj6aITFVYuFolqouUxF8KLKA4fJSNRxIoogn7EIQvdiWRseFnex40ybu/Muj1PMqot/BxPEq4ZhCRm7CmDXw3jZD955mHG4Jb9RFZkUlefsEU7efZs/bRui6pJsD35hBkeD6D2+gkqpy2x88SWR5EpdcQdezdI/sZeqJMs31ZVrVLI770yxf0Y4xfxBagyAGsNQVBLGOUVFxB2WcuRWEdAbNBZJTRgm4MVJxnP52LN3EGXIh9/cgf+Cdv7B5sMYaLxQf/ehHOXToEP/8z//M2972trM+Hrqu8/nPf57f+Z3f4aMf/Sj//M///DP3sSY+1njRse3qJpxumVK6TileZfpQlt7tES6/eYjFE3mi3V58DS76z2+i84pBVg4ssuFl/cg+Bw9+eAVNg0rZ5sRDSZ785hKlZJWVEyVst4edr+2mb0DkzB2TCH4PjkgrwcEA+RMLKNUClqYwfs8sG67uoLHHy+htBSzDxqwbyCEHsmWSOplH122W78qT9nVDtYKzUMJr6Tg9IuFON+uu66J+ZgYtp6FXNLTFAiDT0NOOKP/4qIl62WD8iSTmk/sRpiaJH42TLDhZOJzGNTyA6HLgjThp29JIQ3+Yzs1h1MoMrkSJ5L023qE2onv6CbV5UFwS2FDNa1hOCdkhommw/5Z5Dt22gDfs4LoPbSTW5+fGj248uw+2bbP3tV2MPpqgvFTkG++bRctVCTWv+nwUFkuM3zWJKEvotszQBY1suaaFg9+Zp5yRyHl72PGbLcwfTpE+lsfQbIJ+AyUgE4x66Tu/lf7zm7ny94Y5edccs4eyTO+L40bF6bCwXC7Sc2UO3fIktVydnr3NxMcKVGdSGB6RqQdmqKgSp+9bQhQFGntWC83ZvgCSx4WAhr/JzRU399PS46T6jZM0VxeQTsY5pW1irn4F7pKX4bSBbksEz9uAGYlSvOvbRGcP4RB0zM5O9MYIylAI38uuZo+7lVq2Rsv21uc7dWv8L+LX1fLxne98h5tvvpmbb775nP8risK73vUuRkdHueWWW9bExxr/u3B6ZLZcGeXrf3SSuWN5Gjo8vOrP3ISa3ay/9JnENjPHihx7soJW8eA+XWfDxT4MXwC9qLKyqPPk16ZJjBfInVymVhcQvF5UU2bLm7dgeQOM/v04etlk8dAy1fEktm6CblJYLpOaLhEI2TgsDRMby+EhtqmJelEnWzSppKtkdRd1SyPa6kWQ/YhFlbbtDVz7j5dTSOo8fjyOJYCcreGWNJwhme2vGTgnbG383lmSZ7L0XtxB25ZnqqUeuHWOI7fO0DJ2kOZGC+p1TNOJrvg59r05yvEq7pCTyz+0jcbBMFvesJHDJ05iZEUUBTwdEbxdDWy6oJFavs6ZR5MYihvRtmjdEKR1fZCxJ1JUFvIUThQ52SvT9KHt5+ybWtGZP1lgcl+a3HgaS9NwOkW6dgXY9YZ1jN05yfRD82QWqpi+BWSnjEOx0OM5RAtkh0x0UxPH71nGqGlYlkjNI+NrctO2tYHu89soJGocuXWK5YcnKC6V0EwJy2liBR0IDRGyi25yc0VqeZXSShmnYiKXKyApKE6RYKuXgJlDqZZw2l009EdoHIpgKXtoaipgaBZT3zhC+0gzma2dWPvmEQSJUkajbMhIyRzxO0ZRs1WmT9UQjirIo/M4NR0lpOBb185ixxDF/hibNvXS5Fy7Zf468esqPjKZDENDQ8/7/bp168hmsz9XH2szaY0XLYIACOe4bpzFsmwO3b5EbrGCWakzg8m6C6N4YwESuSxGTiVzbBkznsVRzCPYEmbQxZaXtFLOqDz8T0dRTyeo4sKyBJymiQCIHgdK0LMa0VEq4Aoq6DWT6OYmjLpBPZEnY3qxIzGoGXSFa6zb4cCwm0jN+hFaPIhuN7mFHJopITi9SO46ogDh3lVH1/8mv1Di6NfPUE5Wyc0VaR6OIv3AKqKrFoYlUQ02U64nKAfbqXf307q7A1kwmX1oFoDj3w5QTNaoFg3KVgsOt4+Nrx1h01u244z6sW3ouriHA49rVFN1mrvdXP2BYRwuma7hAAf+KY5gGKwcWKC4NEiwfdWZ9IkvTTC1L8nKTA1bEJHcCopiE27z0ndRK4GYB1/Mi9PvALGOjUB+oYiIjVFWESwFs6Ry2+8/hZxLE7ErmJZCudrF0oqTjnCU9Okk00+usHJomWq8iFXRQJAwBQFTNxFtcPkdNA2GWD6eRrBtJNvGGXAS6vDRc3En3YMO0kxhVwtIR9xEX/o6bvqzEQxtI5Je54mP3IlWLFGcz9PytuuYLhrYpkW9cx1+XSEa1LAPJ9DrBqqtUpsvEe7oweM0iV7ST7FrmMk7J+n93BeZ+heBzr94J+6LnkmmZNs2C08tkZ3M0bGnjYaBny7L4xprvBjp7+/n9ttvf5bl47+5/fbbzyYe+1lZEx9rvCgRJZEr39nH9KEcTb2+s06HAIkTCQ589iDzj6ZwWCKaYKEWNfZ/Y4Y9bxrg4U+dQq+buFw2omKiCTayLBLu8lBJlPjKX+8jf3QWl6XjoEgdJyYKpqAgt8QYuqqddMZALCt0bI8hyBLenijT3xtFqOq4RR1d8eE1yzhyRWbvieNq9CFEo4g/8OUYuKSN/EIJxaMw8pJ26qkSkcEoiltBrxusHImDIOD0O6jl6nga3IiSgGVa6MUa21/egduvICs9TH7nBLVTU4RKi+y6fgejj6WppypYlsWxr58m0BWhVjIg0owc7cW1vpvRfTlOfO0x9MU4A9cP4fS4SB5KEc9K7Pu8kx03dlJJVXH6HOgFA8sWcQWdqCWV498a48hXJzEVNy6nTMNgmM439NDa7QJBoGt7FFPVae334PudrRTzFvOjJYpzebJTeep1GyVXJmRmUPMC2DoKOi4H2LKGHgxhFmqc+PoU1UwdQVMxRQVTslBFD8EuP3LQTbak0NsR5qUf28q9nzhCOV5BEEzcok73ec30XNLN8r5ZspM5KBVxT+cB8ARW16dNQ0ZqaaSyUKNzWzfBwgJhqQCREDv+YDeqLtG8IcKpjxSp3HkSW3QT6glz2YeuxNvgxNfk5fDXx2nMjtGcPI6jaFH6py/gunDnWQtRabnEoS8cpTKXJnkizhV/dfnZUgA/D2Y6i5krovR2IPycUQVr/Dz8/JYPfgUtHzfffDPvec97uPbaa/m93/s9BgcHARgbG+NTn/oU9913H//yL//yc/WxJj7WeNES7fQS7Tw3FMQ0LI5++RjJY3HEQpmW1ihLswZaIsNiJkdDTObKP9hGcqJAdSHN3IyFKSlobj/YNvd8fD/l+SyKZSFgISHgRKeGgiWIaCUVSzeoFzRkxcVlHxrmxH0JTj0YxyjZuCRwRrwEYyL2mSR2pU5dchMd9rLpN4do6A3S2BdAEASu+ePVN+R6xeDEI1nmvz6K7JRw1PIYqQKeBhebXz8MokjzcBTbtBj/zAPkji/QuHeA8950IbYNhadGyTyxgssjUnryJM5AN4JTQTJNvI0ePBEXzRu99F7SieSUOPX9eSYfW0EYG8PpsFi422Dvey/nkcUUoqEy95VH4KAPuaed2I42zIrKnps34/Q7OX3bOKPfOYORKlNBQwiHOO/8Rra8pJkj35kjM11Ar6hwepTskVmCg81s/P3r2PiSrtVaPNnVVPeH//S75I7WySdUsgRAlPCGHXg2Rum+qp9NFwY59oU0xZUKkiIjhAIYpoon5GHnO7Zy+mANb1YjGTd4+HOTZLM2nTvaiK2PcOzeOBnTR72oMfbgMitJEafhQMg5wbbPmspSU2Wmp6FacOA4XGCTa4Zwo4Ip6xz64nE0b4S9IReix42ztYHidJnMkQXSY50E8k+hl7KMXPlSPK/eivKvjyObdaTmxnOuR1EWCS+eoHnsCAo92OqFaOUaucdPoTQECF84/FNnRjXiKfJ//a+YqSyel16G/zUv/Tlm0Ro/Dz+od/1zb+NXjZtvvplkMsknPvEJ7rnnnnO+UxSFj33sY7zrXe/6ufpYEx9rvGhJnYwz/b3TBLrCDN60CcsWuPufJ5jYV8SlQcvmRmruCEuT80jWakKtUrzCnt8aQi1p3P2RR7FFGSXsoC74KWcN7HgRh1bFxsJABgQEtwvZH0avi3j9Ei5Rx51fweGWsOrtjD26QnVsAYdZw9HXRGxPN4HcAvWQTlHT0FxhCkKQ5s0xWof852TBBFg4nuPY3UvMHsggCBCLaDREQJAEHF6F9p2rzovV5RzJp6bIHFsicXSF0PY+opva2PnmEU4vT4Kq4o4FKeWcWE0xXC546T9egDfowBt14/I7KKxUefKzxxG0OrbTgeKx8LX4MYoVojGJ0lwNj6SSO1VEWcxz8R/cQGgwRqBBQS/XkZ0SikumocePWXRjuN0cvzeO22nz1JfGSI1nOX2bwoaGOB7FpDSdQs1W8LQ6EASBUkbj8S+OoyUNvFE3dcuBpUbwS2mkUh5hbpJ6rg3LCtK4o5PophZGH1ghm0jgb3DSsjnC0AWNlOt5lsfLdG/0M//UEvWCRnyiSHJBJbdUp1bUkRZmWXpkinoNNMmLMJ7hwJdO0byznY7hELJLQliYR15cpibkcL5jHXY2RzVRoTCepOSVWDyaoWFXP8e+cYZ8WaY4Xebo738Nn/MRIp0eXILAuj94H5WNQXj6SdxXXHDOufU2eemP5tFi4PKVsBaXWbn7GNn7DiOHvCgRP/6Rny75mLmUwFiMY9fq6OMzP9ccWmONn5U//dM/5T3veQ/333//OXk+rrjiCqLRn78y85r4WONFy9gtx4nvX0B0LBDZEEMMBZk9VqDub8TpDbP3A+u5//9O4PaK6LqIK+zivLdswOFRcHgU9r5nG772MAfuTlOrypiigMdhI1dqAJiRKG3nd7Ph+j78TS5u+9CT1MslynMS4RAgmGRGU5DLEdESKIKBq2zTO7IRd7mJRD5JIQ+VukLqQIYv3fwUu1/Xz5Vv7z1HgARjLrDAqK3mGRF7A/ReFqZpMEzz5meqproa/cghP7WSjm25OPpfp7hoIEZouIORP30lWq5CaGsPD//RKK72RtwBGdHppKHnmVh7q67iqObxGCU6b9rIyMv7WT6e5tg3x0lPF3FFPNRtBTlfwBRk0o+eIdLu5em/fwwEWPfWC9h98zYs0+boE2WWxsrE+nz4m1xIsoBt2ZiChNTdiVsqEtrUhbs5eLb/wkqVYryK2dBJy/AA17x9hMkDOab+8XaqKyqmXsVIZPn6b5/GUE12/fYwLeuCFKYzWDZ0bY/SNtJA26Yo5ZxO8nSKyTsK5KfLqLUI/hYBf9SJNySycjRDvWYhBn0IqkpmSeWu37sX17pOXvYPF7Pugib6d0eJGwWCHR68W4fwjB7GsZBgsFRgYeAGWocjmGqAcucGctUMogB1nJQLFspyGdkTxCEIeMpx7LEjsDQBoRBs2QKsZuINveQ86g4Lubsdqa0ZQTi+an0RxOf0V/pxKOv7cF24E2N+Gc9Lfvq01Wv8z/Hr6nD630SjUV7zmtf8Qra9Jj7WeFFhGhbTBzIAOENucnMFTN3myNfH2Pnu3XRsDLDiENlwUSMdO2MEguM41RKyqCNLTo7fu0L77naaB/y0bY3RtjWGq2OSWz52nJou4JQdSAgIgo3TLXDhe7fQtaOJ77znAWrxPIYpEJ+QWbcnhDfsZN3VnZx5JEkxpSDUTaqZOg/8zSEC3VGEWiNVf4Ry0sLUDFZGC5x8IMmlb+pGcUokp8vMHs5QmozT4CqjDrqpqhKxkUb2vGcr/gbnOccuKjL977ycVNJm4XiW3KMp5C+Ocsm7R/APPVPJd/eNrTwNtA35iPWdW2yvnq/j9snI3T4aOjz0XdVPdqG6WqFWAGQZx/r1RMwkWq6KM+wme3KF/EQSBChOJOh9xVYA2s8ziJ/JIdaqNPR6uO5PtnPijhk8AYWhq7p48tvLlI4b8ESG9ReuJoLzBQT6dkdR6zbbXt9PeDDIzqFmfKVlJv/9CVz9LegdPs6ky1g2pCdy9GxvINLlB1FE8PmYPl5mYHuAUJOTOz82RWK8gFoxwVUF2+baDw2zdDLLpBTAjoqsf/UmUseWWHhyGbNmUJ7Psv/fjlKa6WDTu/bSvCWGtzlAZH2MjGXhcIp0b4sw/JGtBPqbKCWrDFzZTbA7RHQghDkxy+zhLRScAlWtnQGAUglUFUQRqtVzxtz72htwXbYXKRxAcLlofu2luDqbcESDeDd2/9RzQPS4Cf3Ob2Hb9rOsaGv8cvl1ER//Xbvlp6Wzs/Nn7nNNfKzxouLMIwke+twkAJsvCeFsjZCYKPP0Vyd57EGd9Zc3c/0HB2n7wfKGqNawVA1bM6nEi4z/1xESJ5L89q0voak3SHYqy6GPf59wvIjD9pDES7PDjWjphKwCi197lNLYAAtHM2ALiKJAsKeBve/fRVN/AFfAyas+dQFPfS7IsW+NUcoZaAUDZ9WgLobQJBODAqZhIYoKlmUjiAKPfHmGR74whV2p4CilifV4iUYdJKoe4rMqT92yyJXveLa3eNNICxvfeSGJfziKhkJ6pvSsh9DQ3ihDe5/b7Nk03MT6G9dRWioxeP2qk9jIbwwRaPNRTNQQnAodWxtxChqV5QLRrR1Ul/NILoXibIbcmTiWYSLKEg6XyPh/HmJp/yItW5q57K+upO+8PQCM7cuwcKqMoZmMPp5m/YWNHPvqcabvnybQ5ufKP7jgbMp4gPJ8HmdTCFmwqE3O4SklQJbZcPmF9FzUwcLhBNP7M5wan8ZxW4Hf/PgQYr3K0TsW0AoakseBXtYQbYvFI0ki3QEcES++gQa6r+zBF3JgqhapZR21ZjJz7ySLT8xj/+kF7HrjnrP7EXzbq6gfPo1jqAdX/2rYtifs5JLf24LkkHCHXKw81sj4v+RQaxrIDsrpOlxwFR5ZhmAQtm8/Z8wFUURueSZM2hEN0vSyn78WxprweOH5dREf3d3dP9P1Zpo/ohDUj2FNfKzxgqFWdBS3jPiDLKa5xTInb58iP5PD3eTD1eCjdW8PKwtTVCpOyst15o8WKFyt0r5udanB3x7CEXBTy9URLQunVad2epZPX/EdLv6D89Am51FX8si2iZsKGgo1y0kkICEW0szcO0HtvgXShRAWEoEWD/4GB+EuP67AqmWisT/ENX++F9Xh5+kvnUbBJtIXYfMNnez/9iI5r0glrxPu9LPpihiLpwocumORzMJqevEmB9SzFQJ9HtyKA9MWfqQ5vufiTjavaCTG84xc1/UT3RSMuo5WqOFu8jP8mpFzvnMFnAxd0/us34QGV5d8FK8DV5MfvaqTHU1Sms8R7I1SilcYv3eGarJCvWRQy9Vw+FbHpLnPS9s6P6W0ysCu1fDS1KkU9Vwd27QpLZeYeipFYizP0GVteNtCFMYTOCMeRr+/gGiZWKrJ0a+epDBXYOWpeepZm3pJI5uXOHhHnNr4AmpRwzKhZUMDkZiT0nKJ/HSOC94yQPNQkOSZLPe/9zY8c6P4Yj5e+69v5MFPn2H2yWUsw0Kv6lQyNRSXhMPrYC7tZWK2g67GEBtsG62k8vSnnqa4WGTdK9bTf1U/sb39CIaBVqhhNDRx2x8fAAEuuflG2oYjaFWD5YMpgi0ewm3eZ43rGmv8qvHFL37xly5218THGi8Ix2+bZvSuWZqGQlx48yZkp8zhb0yQPpPBKRoM7omw8ao2nDd24lvfyf7bVyhlddrWB2jue+aGv/ddm3G7LdInEiyezJE5FcfSdArzFe768wOExTymZSOIIrYlo2CgCAY+uY4lCJRzGpqm47JNBEkgkMtReGCJ299ncu0nLiLcuprN01ANCtPp1fLoXVHatzZy0Rt7aVsfZP8t87iDDgYvaFwtjKabBBpdxAb8RNtdeIs2mTMpVg6t4OwT2fTSfvb8Rsfzjo0ki+z+zcGzn6sFjfRMiWiPH0/Q8az2aqHGgY/fTfrECl0v2cjW333GT2BlosTEvjRNvT6Gzo9i6SaaahGfrhGKOQk3uxAkkYZNbeglFV9HGHfjD5ZyRBFPZyNqzcbT1Yg76qGYrOFrcBJscnHTH6+nkteYfHCe+/9miaYtLViGtZrrQpY58F+TlDN18ktVrv+T82nc1YOzMcDxg7dhzpcwBYlUwkS9cwoMg5CZRwxEqHS4aGhzkpg08Ds1hKiHl3xoBHSDJz59hNJkku/+5i1YdYPEWIFwcZYwccS6RPHxE1z2kQs48OXT+GI+Gjq93PuRh3EGnOx42xb2/+ck2fky6Zki7ZsbqC4XiB+LY9QM5h6Zo/+qfkRJpPnS1Voth741TWa2hCAIJCcKtA1HeOLfxxh7aJlQq4drP7qVwA+q/D4XtmFg1TUk3/O3WePFy6+L5eNNb3rTL73PNfGxxi8dy7IZv3+e/EJp9U13vkzTQAiHR0Zxy7S2+dh1U9fZB+2e1/Sw+9XdTDwWJzOdRyvUoH31Zu4OKJjLKYylBMZSHsOWMbDBNFFzZTSfgOUNIsgiEjJy2STsLKMoUMFBXnMhWAYSFk7RRDIsDN1m5fASj3xhkovfNki42cWB/xhj7qEZ7IKGSRWf6qK0XKRvZwN9OxvILVf5r/fvZ+VEhs6tDVz4tnXIboXWQS+PfbxMejRNOatScZSJNDvwhZ8tIp4LQzO5959Os3QyR9twmJf+4Qiy49y8D6W5LHP3jlGJlynFK/S9YjOBjhCWZfPQF6aYP5bHgcbhRhPKJUoVkZzSRLQ/zE0fGSTU5GT9W87DDoURXU5sYTU01NfkpvfqQeKdUba/up8nvzDO/JEUndsaueidG3B6ZJJnspy8fQatZmLtbebqv78KURSYf3IB9dQUZtXEsSWMbYOjo4n7PnGATNGF3t6DLSs09kcJOjUczjx+OYm7w0C6Ypi2PT4S380RDRq0b1OIlmeplS0CIYnMXJZitUY9W8Wqm5iIWIjIHhfOiBeXZHDtn+3BFfFy/58/TvJMDndQoTBfxNfoIjFeYGU0z92fOM6e13UTXddIZiJN8nSKez/2CHvfuxNNtXF4ZDq2NtC6MYIgQseWBmDVQmfUDcqZOtWc9rziwyyUSH/yaxgrKYKvuhrfpbues90aL15+XcTHC8Ga+Fjjl44oCnTujKGWdRp6AgRbVy0ZO143SGN/EG/UTdPg6sNz4tEVKlmVrm1Rjt0yTmqiwOKhJNf9n92c+P4CC0czCMs1yuk6alXHlj0opookVDBMi7ojguQCKRrC47KJ+iScqUWUYgYcDipmCEWvoaCjubx4QhqUahTidQ5+fYJ00uLlHxqgOLaMo15AVCR8Ro2Z246jmHWUrhZSEwXcTQEWT+SoJOvEz+SRJOjftfqw2nnzDgolkfg9K4iWQq36k0X+Tz66xPHbZpg9mgeXg9xSBbViPEt8BHqjOCI+KukacsSPXjOA1YALxSUBNuW5DPGFKma+hCk70Rod5AMepp5KIwkmom1y9M5l9JqBpsH21w6xfCLL1NMpakWd6f1pkuN5SvEaC0fSnH4oQSmr09Ci4Im4sNJ1Ai3eZ5bQRuMEAuB2gRlPcucHHiQ9V2PldA5ds/B3BBl6STdbX9ZD81CQxS/eR/HuFSSHQdsGhZMHM8THilDTEGbnWPqPMZBl/CU/ddmAkEw9JyDYFiU5TNOWLlqvHWBifw71+3fStLWNjpt2MXM0Ty5ex9vsIzoQpjWpMn7vHOVknaUTMnNHQ3Re1s/SgWUSB+aZf3CKifvmMSJNNPQEuOZDI7z8L3cCnB33Ha/q46RXIdTmIdDi5vlQJ+apHxvDVjXKjxxcEx9rrPFDrImPNV4QdvzmOoau6MATcaG4Vi9Dd9DJuiuf8Z4+evssD/zTCURJoHUkSiWpAasVbh/99Eme+OxxbMPE1+DAqbsw3CJuh4JdttFVE8MWqDW04Qsq+EMgCDZIFpVsAMpFaqaAv8lFw7ZBZmYlrMVlFrNlvKKE7LDQS2WyyzUWD8YxUzkam2V0U6RWskjPFKl+dwbvgIZlWPiyKq0bwyRlgb69Mdo3PZNmO9IbZuR1w6QqLrAh0nluhMpzYWgmR741SXq6iGjqOC2Tlo4giuvZCatEh4x7x0ZWEqcxczB9/xSBjiCKW+HKd/bTsd7L6K01agmwHRah7ghac4zmDWFO3jlLfqlCICJj6yaWYWOoBvGTKVaOpVYdaAVwehU6tzcwf8gmOhDiiW/Mk1us0bU1zOUf3Eotp9I60nB2nwSHQiWvISkixXiVetUmOVXEsiVkBXxuE7FUItTswhVwErt+J4XRJZLTedRJE8MhoNkKtqFRLhjoAQvJbSPLEOkJYjscJBY0kCzkoIcLv/BGjn/9DLOPjSJh4op4yExkMUwJpSlEMaPz6CePUK9ZOFwiomDj8kqIlsGB/3sA8eB+osUySbGFleMJqm6T3Eqd1FSRlSenWTm4Qu9VffRf3U/75gZkGfb92wkSxxNc+J7NBNv9LB7P4gk5iA2shh47etpwDvVgJDN4dg4/67zVMhXKSwVCA40obuUnmzhr/FJZs3z84lgTH2u8IIiiQLD1+R/ClZzK01+fITFeBEEglxfxxPys3x2lfTjEPZ84jJoqIVk6xaIMsoJlSbRuambnK7s488AiM0sOquk61WqZkfM6cAcVTn3zFOKZMSRTQ/QECMVcvOTDW9l3f5mDfzmFVa2AUMYVVPBGPQR8BouHEyBJRIciuNsjnH6yQG0mh1pzUjidw9/kZtONvYS7g4zdPUv/xTHcgXOXVYYubMIdUKjnarT0P//b8n8jKSLhLj+FeAU7naY2W2BseolQzEHn1iYqqQrte9pxRzxUMnVSsxUq8QpWqcojf/IgmaksfVf007w1xvjnH6cwlSO4sZ3LPnEN0b4w3iYfhXiV7x5fwTJsPI0eNlzSjVE3CbV6eOQfDqEWVdo3NtG6vQVFr7Dw0AwDGxroe2Ufi395BkFcjQ6K9gYRRYHCSoXJx2bxRt1kkzp2OExlIYGUWcLdEaVxuAlTcuBEx5qZJXHHPHct5jAbGqmWTZYfERA0DzF1hp1vD9M4FKEwrpMo+3DWBbb9xjBSTeb0rWOsLNWoVW0kW8YZ8BPuDqJrNmKsEUmt0Hb5EN2Xd5OYrbNwYAU1VSJ5Jkvr9mZi68J07W5m5xvXUc9WWPjn00RqS4hOC8EfpSL6kUUH/kYnoUaZp78yRTVVRa/p1Aoas48toOuQmqkgyiLxUxkmn85w+DtzeEIOrvnQCNEuL0tHknD+pTRvjuFoa8QyLSorRdxRL6ZqsP9vHqI4m6P1vC62/e6Fa9EtL0LWxMcvjjXxscaLElO3cPodBNr9q5M35MMSFWIjTTh8AnLQuxopo5sggSaISGadylScQq6drhu24BjN8dhnT1GqaDzx6TSDl3XgE2sYooEkgSBbOMwaucMzvO6DW5j4dw/12SKCBWrNRF+ukH1iiWq3j74dLey6to3oSAvuv3+cmf+aIVOpUI12Ivk9tG1r5s4PPUz8ZJrR788QaPPTsfWZVNyiKOB1W5z8/DHGVIOtb9lK597ndjotzOc58bXjuBWJi96xgYOfzLM0b2AZNonjCZL7Zqhla+Smsux67x5sw6SeKqNXNQTLQiuqTN45SXGxQs9kG4XJFGZFo3RmkUc/VsLX7Ofyv7mKYIufC986RHKySM/O6Nk39tknl1BLGoZqEoi5GLmuk/vfdyeFmSz1fI3BG9Zx1c39JGcq9G4Pk58rcOxrJ5k9mKZcE/E1eundEUYRLSrJPCgCUoOTodfuYel0ntZGg9kzp9GrKov3jZKWshiWBLU6sqmxeCSN9X8P4JZtVGpUajbLp2vw5RPEdnayknOSSZYxcePwSAxfN4w74GLXW4Y57FFIzVbJ6j7W+RSu/oOtxE918ORnjgGw/TWDBDsCyA4BvW5RcwuITge2JCP7Ffpu3ELA14sScrPtxm6iHW4C7QGMuoG/PcDUg7MUFkoI8upxSi4HTesjLH9vCb1uUs2pVLIqtallTn7h6dWopredhytr8fRfPUBpOo0r4qH35SNUlovoFZXCdAbbtBDktRoua/z6sCY+1njRoasmB29fRtVE2jdHqRdVdNOm/6Iow5c2Ikmw5WVdTIg1CuNxRFnGH3BjrKjIep1TXzpEpa0fW5IwagZus4SzorH4QJXei1qIKE2UVkpU8gL16Syzj86z8x3b2bg3wGh8Ga0iY6tQVw0svUTBJVLIeNEkN86gk0BpmaaIjlAuMjsnk63UMWoaet3AMizMQoXJuydYGivhDrnYeHkzsiKSn8lRmCtgmRaZicw54qOcrpGdztM4GGb2wWkWnphfjbrYFGPnu3fApw/ibPCx/ro+Tn3tGJa5mtgMIDdfwhV04u2MYhbKuIMO3E1+BFEAt5umkRi52Ty2ZZM6mSJ5Ko3jk4eIbOulud/Hntedm2+kebiB1jaoxGs0DwYYe2gZR9iLK1wl2B3GG/MR8Tvp2hwG4OAXjjK/b4n8Qhnb60Ns8dF7aQfRDidPfGQFrVhH8jgZfTRJvagjWk76rukneTxOYUxHtEUckohlCtiGjFWvkz8wufrO6fcjWRaSvZqXpLaQxrRcyH4nguCj55IOLv/9bVRSFRoHw5iyi2K2yJkHlunZFaOp24MsmFz1x7uRnDLukAtDM3n40yeJn87RtaMBx/pe0ktpLNWivK9CaHudq9+2nsa+VTG290PnU1oqEugKcfBzR1FLOv62AOmKi1JeZ+5Eia0v68SybAKNLjq3RJi/L4VlWAgCmLrJia8cYfnJWdRMBcWrgNNJ92W9VFcK9Fy7HnFNeLwoWbN8/OJYEx9r/NIxDYsD35whPlZg03Ud9O46t1jX8liJE/fFqRU1Sgt56kUVp10nbGWZbLbZdGMfQbeGbGpITgeRgQhDlzRz8t/zVBcy6MUyUt3GsWcz/mYPLOcQTAtBq5M9soCv3UISwagZ2JiUFgvc9eFHWPjOAXw1lZLgpWD78VJFqKnU5lROVwxmjuR59SfPJ5m0ySc0alWwBRGhrpKezHP1n+5l378cRF1MMXbrKQrWPO7+dhwemfUXNdG8pZnmbc0YNYOOPe1nj1er6jzy9wdJjuVo3dJI784GXCEXskvG2+SleUsLA9esht7aloWoqaTuOUTUVcYoVYmtj9C+PUao3Uf7tiZi6yPU83VmDmc5/FABT2s3L/1YH5P3THDk84cRZZmpYxVOHJsm0qyw5wo/iZkqvrYA2141QHEsjrmcQK7qPPEXjzA7L+LwSFz5oc0M3ziE07+a66NW1JCdEoE2P+6wi7aIm5Y9XSgOgaNfOIzscdD3mp3Itk7X1et4/JsrmLpF41ADu1+3hfJSgY6DeVKzFXyUmLnrDIWUjpas4q7lsRGoGm5c7U2Qy2AadZytUS67aYQT319k4JJWLnpzP8f/4xjzj83jjPqo5GysbA5PtAlFtrjr5tvJjqWQ3A76XjbMzndsp5LXWTiSpppRWTgqsvWGQY7PJyisVLCqOvWCTr2onz0/rqALV9AFwO53bWPouiLZhMbEP41h1E0WjufY+YpOrvnAM/lVOi/rX7VmCALtl/QRP5XBHQti1nUcER/e1gDrX7sFT+OP9/9Z44VjTXz84lgTH2v80klNlTh+5wK1goZWMejZGaW0VOTYl48gyiI9120g2OymMF+gmqlh5YrEzDkK98GR5RRNQ2HqeRXFoxDtD7HtN9ehJfOUs3X0sg7YYOW54jfbyF8T44nPKRTG4gj1Ko5qjtLxHLZl4bR8aIqXwlSa5KkkvnIWCRNbsNFDUZRKFdsGW61jpvNI2Tn2/52B0tpNqUuh4Kwiqzb+mJfO7U00b4zicVns/+Q+UtNFBNtCqxmMPZbEHVBo73Ww+YIAcshHcPAZ50y1rFNOVTE1k1K8Qsf52wh2hpCdEpH+Z9rVsxUmvnGY8uExWFggt7xIoCdK7NodXP7RPViGhex8ZkqPP/4E8tgpqr4gJ+5yEmoJcd5HLsXhc3D6QJXamSKcPs2xQ1kqVRFxwxCNfUEaGp04/C4s3aKS19FKYKkihbh6VnhMPpXisa9M4w4oXHHzIJd8NIjskon0hLjvjx8hdSZLarqIuy1Cz0UdxEaauKLBx/z+OP0Xt1GvWigNAfa8ZTVt/L6/eAB/1ImVyaPZJSTJAFFC7o6w5T27mbtvgvxckawVIGKpNCoFtDMaT/xzkeNfOUolXkarmTh8Cr6AREBwc+CzBxm/7QxWTQVFQbMVOna30bang7aRBuJncvTsbqL/+l5QNZKnkqiaQGt9nODJMtbg1Yjec8NoZadMdCCCr0Wnb2cD2aUaw1e1ntPGtm1qmSqt5/ecFRfb3rGTjr0diLKIUTcIdod/pPCwdINavIArFkRyrN2m1/jfx9pVvcYvHW+DE3+TC1O3aOj2IQgCC08usPjkAoIoEBmIct37h9j3FYHT95iUz+Rxl1REzaI0m+LYbbNsvbEXZ8CJL+YhPNDIoX+ZRS/WsRAwkLBMmSNfPETrgJ9dN7Zz4ukg6uQSvooOi1lsVst0CKZJPVtBkoWz7ycKOh6XhegKoJZ1aGiiQUug1FTyT43h2ePAt6EDuUPH7RHZ9fp+mjeupjtv3dXOyBu2UE5VUZ0BDn0/ydjjKTLzFS4eWKby+BHksB/Z9yp8G7oA8DW62fTKQRYOxOm7uB1XwIlrY9Ozxm3liWlm7xpFm17AVc7gbQ1hmqthu6IkIkrPRMLYtk1b/iRy7iRG2UP8EZtFt5/tr1/HttcM0bG3wvRTSbLfmaMwISCaGm6viCfiIrQuwqb3XY6aq9KcsHnsX47hDSoMXdmJWtFxehWm9qdJTJTILtVYmaxwwx9soG99iPxKFc2WQZKQ3Q4sS2D2vknuTmQRsMnNFZn83iimYVPJqmx4+RCxDQ1EtnSQObVCMlvB0kwkVqN4Qm4VKZsmsq6JyacyLH1nhtPfmcCJirfBiS6tkJ0sIRgayDJi3aRUqzPx4DyCy4Gl64iYmIaIZdoE2gMoTonLf2+ESk7DF3UhigLurib0u47RMH8MnxYndUhh6UgStbEdf3eUnpu2IyrP3C5dPoXL397HwX87xMKdx4g0bCE6tHoNzD84yehXD6F4HWx//8WEehtwBV10XND9E80Py7Q4838fJHN4lvBIBxt+76q1ZZkXiDXLxy+ONfGxxi8df9TFtR/eTH65Ssu61XV1JeCiXgfLsnjyuwmkR+rsfkUbjd0+Vg54yN1dopYqUjK8HPr2LI2DIc57x2aO3x/nM287iL2UwiNJ2IKIlzqKVSNzd56V+z0QieAa6efCD55HRzcc/9v7mH1skZruQTBNJEVECbmwGjxo8yvUbA9qrkZopA2tpuBpa8JTslHiKnVdIjFTxVu2KaU1vM0BZo8VGbx09dgkh8zgDeuB1YfI3KkK1fxqiLBZU7ENE6umYtW1s+NhGRZDV3ez/iU92LbN0TsXWTyZZ8NlzfTufKaGizPswbZtshkbuabgcYo0JnXOfe9+hmDUgTgUQBVcFGUJwSnj9K2GdDZ2eWns6mE5prFw7yhCOEjHSzfTvC6MIAj4+5rIHUzSOODg5ntfjlrWeezfRsn+2xhbbuyhZ3sDpx9MYBg2lZzOyQeTdG0Jc88/nmbs7iUcosmON45QSVRIHlokP5cnO1eiWrLAtrBNC9uE7MJhIr1hAq0+2jb1Yj04g1o1UfHgdDnRV2osPTGHq78dywKjpKKpGoagY0sSltvCaVZwU0WJhHD1xkieyVEuy/gkcHid6CUbQVHw9TcR7AqtnidFItC0GnVUTlU58E+Poz1xCtvOoAg5NMlN/LsnsNvyeNtDhIfbiIy0nzO+iWNxlvYtrGa0bZs+Kz4ypxNkxtJITonCbJZQbwPPRXkxR2LfNN62ELHznqmEbJRq5E8uoqbLFE4vo2YruJsCz7mNNX6xrImPXxxr4mONF4RgzE0w9kzIaTJukbcCVIoG+oSKM1RmZbLCZb89QHpXmH16nblDSSqzJmZaZfZwjp2vhtFHUyQnSlCyidkifkHDK9YRBBHd0KkaDqorFRLlJdZd3k7Ljb3kX7mLVN2PkTVQF9K4PCIjb9lBqWCS+Ox3CWpJSn43il/GcsgYtokpyoiBMCuLIrWxPO6ZLKLLiTvkItz63KGzoiRy+Tv6mT6YJdbno7mpj2xHGKUxSN3fSOZACqumcvzWcQItXs6/eQuVgsH+W+YpJuvklut0bokgKyLVXJ3otg76X7WdUqJKdVHEcHoR5dUp/P8XnxMEgZY3X4NnXSfO9kZccZlKokz37hjJyQLT+xI09vrpvXiQ1kuGzm4jfjxJJVkhOVdl9O4FnH6FS9+3BRuBhcNptKrB2ANL3PjXe/CEHNz3mUnqFYOO4QCWYZGfL1JLljGcIrWsyqUf2M4T/2BQy9epyz5Ko1nqRRXR0JAkEZfLgVY1mN2foFiwaLpmO7nxBGZVx+GwkU0Nxe9EFi2a+70kZgVKKZu6rdDYF8OFiricxG2W8VgFXJEg5bYQZtak+cIOBgYGOfLFY+QrMksLAifuT7DlmhbUis6Jb0+iVXWahwLkp7JIdZtCtA1cUbJLKhXbR5Ms4Qh7KGZ05u9ZoX1DkGjH6lKMr9WPp9GzGp7cEz479popUcpoyB4H5o+4xY598QkST8/gjgXwNAcI9K76PilBD7ELh0g+OUF0Vy+u6JpfyAvFmvj4xbEmPtZ4USAIAtUqFFIail+keV2YjuFVq0h0KMolf3Ix84dT3PeZCfS6TWxdiMxciexoglhtBtGqg8eLUXViSiayBDVngFpVRrbq+AorHP/6Kdob64x/5xTlmSz1uois1cCGxQfHCPVECDhVJLdI73luEqJJWLDxdNiUJkwKFRnZrhM0CsiGibetjeGXdrMwUaP2H7PsfXXHs7KPNnb7aOx+5uHR+qarSc+WuPsTxyhn6jhsFaNcJztbpP/STqJDDXgCMtXZAl7ZgSgJzDy+yKGvnsYddLL35i3ohsXkt08R2dBM13UbGL1tjLHvT9B5fhdbXr/x7PKLu6cFd08LxcUCi//5MJV4CTSNRFpm4WiGUKuHcKefSMfq/mUnczz1qf1UMzVwOdHrIlgGuX2jxDa30DQQpLBSpWN7lJXRHP4GJ7/xfzZRL+k0dHgQBIHz3zRAPb6a4bV5fRh/s5eBlw6y/2vjmKJGvahhVHS8bQGi/REu/O0h5g8mmHw8ga7ZhPobaWuxKMxmaRhpp+e69Rz8t8OkRtNEOzy0bGpk9LZxbBu2vrIPo1glvnAaJVfDFkSSJ5OEBzew7e3DbH1Z52ptns5OHv/KDLic1H7gSDr/dJwj3xwnv1yhqd2BK+RC7+0lemkHyXuOodkpFBn63nIR6vQSj//ON8jofgIXbuH1n9yN4pJYPhRHVy0i/RHUVJEn//w++q7fgBzw4O5vRXJI/KgKgoIkIggigiisRib90FzofcNeum7ageR2rOX/WON/JWviY40XBVtf3sXhW2fILtfRVZN15zcwsPsZc7Vpwuy+OEGXRsOAl4Gtfp7+jzGS+6bxWSUExcYUZOqRGIZexxGLULLdiGNTOKkhYlM+OsljX7QQ06sRNFI4jJHN4aiVqB6vEG33YLgDSKKOFWrAzpoIgknP9ghJp4HiLaCZErVKFhGbYMzB4nSdheMF/M0eOoaD9GwN/4ijXKWSWc0FYdRNEAQyczUUj4JpiygKbFxnMHUqji9dpjDez8LBBIX5EmVHhcTpNGPfHSdxNEU2beLpHmX8b27HSOcp7eug55JOwp3Bc/rTKxp6RcPULdR8HdkZRJRFJGX172y7uoFRN9DKOuFmP52XtCOcPEntnuMs7/ex+eWXMH/GYvngEke+PYuv0c3Vv7+Z6A9lbB2+poP24RCVTJ3Y+giTDy/wyO9+B216Cc0TQtACKA4B2ba49Hc3M/ySToau6kL52IPUZhPEGsIsncyilVS0fJlgqweHUUWwLbBt7FKFaKcHh0ehe3uUxuEYU10ejLklZp6KU120QHDR0u89WxRw243dGLaMqVsMXx7Dtm2wLaoFjcJKDcu06GhzExmI0HJBP7Vjk9iFIq6OEM3b2jh190HMlRTOSoKUJvDtD5iEeoJUT81Sy9RIlurkj85h6SZG3WDLey5Ar+k4fQ7adz3fohgMveV8IsOteNvC+LrOXZoRBAHZ4/yx19Iav1jWLB+/ONbExxovGIZmUkzUCDZ78AQddO9tYfxAAbUCT92d5/w3WDicIrPH8uz/8ihLTy+gzsapBETqiylG95cpp2oIJri8MqrowKyoOASN6koO26njEypE7Aw2AnnTZGbfCj5FwzZM5GoKh6mCYYAlUZ5Pk2kbxh+W8ba1UltZJtofxBvzoR+J07qthQ2vjvLA75eopGsszVuoySVqRQO3X8Lf8JMVi2sdDrP5+k4KK1VMQSRfEBCcElOPr3D0P06gTc3jEk2MUp1aukLnrmZSY1ncIScrJzIs7FvEKNUwdIuTX9yPuJwC20JIJRAN/Vn9hfsjrHvZEMVElfY97SgBD107m2jo9hNsXn1Aq2MzyA88Tn9EZf+Sh0xCp6fJTWDQS2rOwChWmf7+GEsLFpmFCnYwjGlYFOPVs5aT/ybU7ifU7gcgczqFlIqjGBWEXBW3YEBDmIt+ZxM928JYholQr9FSn6Gmp5GnoXlXF4XpLE3bOxj7uztxLC8Sc3vJaE6KCxUkSaBlazOyW0F2Sgy/cTuwHd/jy5S+MIokQbTvGR8Jt1/h4t/qAVaXlo58+Rjzj88TiogYfWHEeoViRqMwkyF+cImOnR1seuU2Ynv7cTT4kfweXGEXqiLhkGHxaIr4Qp0GUcOs6TRtbEGoVKgmy/g7QvhbfAxf00FhJsvp2ycxHG4GL2oh0Og6Z5y8LUG8L9vyk06XNV4A1sTHL4418bHGz4xlWqTHs7hCLgItP926tKlbPPDJkyyfzNK5Lcql79nIrtf08uA3sxTjKiunM9zyngeJNdmcfjxHfiyJWa7isFS0vMZSMk9NDWAiUvM3IbQGqM/n8VZTiLaOIigYdh2XXUXCAsCFhq4L1AwBh23i01ZDaxGgWoPsGYOcZRCLqoiL+zEsiUpLiLE7JsjO5imvVOi9opeu39jBybsWMQUFhyLiC3vYfGWMaKf3OY+1mqlSSVaI9IWRHDKKU+K8NwwAMH88R3quhiiJ6PkK2Zk8guGioc9P645WGre2o3idNA9HkRwSD336NHYohGCLeHoawCGCz4siGrRdMoi3NfhDY2wy//Qy6e8fwE6ncXU0cuaL80iyyMjNFxIeipw9jyf/+OvoR0/jCHnwBXZS1n1kpgsM/MYeBElAaQiixRXElQWifUHkWITYcCOegExqIkekJ4BtWMiuVYdWNV8le2KJ5vVBVobbyR2YoFqwMbHx1/I4imke+cNposMxNv7GhrP7LMgSm24+nyc/e4Jjt83hnZ/FH5SQBYP4kWXUgkrbcIjK0QnuuvMYctBLz4WdtF3Yy/T3xzFH48gtYWbvGUe+vItATwOS8sxSmF7VWXxqkcJckUpBo2VjK6lDGXLLecRCHqdPZt4wuOjvXoYz4GL/Xz1AfNnEM9xHdKCVUllgJSVDtYpVUxFlgebNMXov7aYwkyU/neHAx+6g8NQo6VNJ4kUXFW8T46/eyWs/ed7aEsoaa/yANfGxxs/Mqe+Oc+rb47hDTi760G7C3aEf2d4yLSYfWqCWq9O0IUp8NEc5XWf5VI7cYoWTd8zT2gaSqCBk0yzftUjBY6MWdERdQsBEckqgg+CQkGUntTKITREiw43UCxpWXcI2dGzbxMFq6K2JhA1U8YLbjW5JyKqGDdiCQE3wkKWRasaJ7bKx0lkEfxWrrFPcP4rZ5MMUZPyDDYS7g1z87k3MjqoUk3W6t4Xo2BBg+009z3nM1UyVx//yMUorJXou62HbW7ef833npjCv+sstCKLA8uE41WQZV9DJrt/bTrDNf7adK7Bqgt9wdQe5lW24PQKdrQYzj8zh3HoFQ5e10XHJALWSwewDKwRbPdQSRQ5+5gDiyWP4gxLKWJKaHEB0OsiOJggPxQBIzVaYn7XxFy0kRaH9mi6Kuod1V3fh6YrS/e7rAWgoqsQ2t+Bt8hLb2MjKiRSP/P0BtKKK12Xh9MmMvH4T0ZFmHvvD71OdWCa6oYndn3gZd7//XnKPLxKwCkS0KitfexiztQPbsrFes4Xud15DdTpOaHsftbzOyrEU5bwJ3ibaRnzovhDqo8cwqzqVk3NUNG21Aq/sQREsiosF8vMlSgurVXNHvxgn/dgo7Zf0M/L2vQDMH05z+DvTaJpEpaCTmCwzP72AbGvIhojb4UBySTRujKF4HGDb1LI1LMNGjnjZ8a5dOKM+Tt+/gpEpMH7rCVKTJY59d4buy/vRqzqT3zmJPreCkE2jFyoIdQtDLZE8uoJt/0gXkOdl7K5Jph+YpX13K8M3rV8TML9E1iwfvzjWxMcaPzO5mQL1gope0ymuVH6s+Fg5nuLAF0+gFjUGr+6mfWuU47fNUM3VOHnXPGceWMZhmozsClJPBqkfTyK7TIJeJ3VDQq2aZOMqHsvG4/Gi5VZzN2j5Kh4PNF0wwML36niMBGAhYmIjUsOBBCheB41dXuKpIJ58Bbel4Qi6qfk7EIoiSs1CRMUblhFkB3bNQsuv+mO0bGvg4o9egDfqIXkoi+hU8DaKeJt8XP7ejc97zJVEmeJyCa2kkhnLPGeb/y5C13tRB7ENDcguGafvuZdw2ofDvOpvdzJ/5wkmvnwIvyiw/oYttF22DoAH//ooU4/HQQCHqFOPqzg1J9pKFbcrQsNQDIdPITrScnab3rCD6u5LyXtbadvbxZV/dslzPuBcASe9l3af/VxYKlOKV1HTJUq1CoFmL7MPzzJ+pML4/fM41AqOkJvDXz6BqoGvL0pUN2iKusGyMf0yzTva8TZ5EVsDhLb2AqsZcFu3NLFyPEXn7gE2vnEDT/7rSUT3GKIk4m6UqScKGHUwRAeVkokjV4VSCX/Uibvdj1gqUpjLk/uPY7j6Wum/rIsjt0wSf3IaKRzAPdiOOjuPWlSx3TL4ggy8agcjV8RoP6/jrLVk42/tYPHhSUKDjfg6Qtz3j6eYPZimsceHf7CZdMKkVIaFI2lCAQXZrWA1hvE0OTF8JdRpG2QXXdEy9VvvRF7Xj2Nk3fNeL/8/WkVj9LYJCgtFqtk6XRd0/tRWxjV+dtbExy+ONfGxxs/M4DW91PN1fDEvzSONP7a9IImIsoggCSxNVJmdKZM+lsLlFbENC2+DB71useW6VkLNHp74dw/xQ8tgGfjb3CgOF4lqioJhUK2AXtMQDBN3Pkv16RLhdS0Umhxo8wqiaeKgioSOjIUtSAiaSn6ugMPlJWjlUGwNWYNAg4zm9tDkMvHOnEJJqFSCjZT9bVjZAka8TszpRnatTpemHi8tg36KSZW+XZHnPV41X6VwapFwswOz1ce6G3/8Q8cb9Tzvd6ZuMvmNw2SfPI25sIyeqiM2N2Hp5tk2hmpiaCaZuTK+BidOpxu9fwO6aVAToWtTN5teO4y74ZklIl/EyXV/tJXc0hAtQ4Gf+M26Y0eMngvaSBxeIHcsRyVhEe6PMDWmYbR0IpYzRPcOMP+t/bhOLuKIRNjzNy9HO3YGV0uYllech7clgCCK52xXkkUueM8WqjkVT8TFxOMJTj6Ww2xpp3vEx8XvGeF7H36cpUNFrJpKbVFDnZvGF3HQcXEf5/3Nyxn/+hEOf/4Qpkvm2NfPENvQgHP8BKGpceRYmIGPvopKVSB+YB6lXsbvd9K/1U/T+ijuyDNj0zjSgrs1zONfGOPIIwdJz1Yw55coZQVG3rSdcgmUfArz8DG8140w8vY9PP5/HmZlSaJl23r87jLGTA7fI99nedakYe865I9/CDEU5CdhNWtskHq+TrDdjzu05oS6xv8O1sTHGj8zzcONNH/84p+4fctIlPPeuZlars7TD1YpLMxhlWoYVR1BC/KSP9yLUTdpWR8iPlVmZkwjHxdw6SpBuUbPBR0IVgPVgo5W0dAni4hWHdnWyI6nUZfS+CSRumCgC+CwDWxkTEHAEhQMU0RTBbA0DMWNqcqoNYHZCRM94MQlV6BWwzI0bI+Bf32UoqwgemTGHktgfuRR9r5nG42DEV7xxxuplQwCjc//MJi+7QTTtx5B9jjY/LuX0Hxe57PalJfyaGWN8ED0WQ/hH8ZQDZbuO830rYewjp7AIRr4O6I0XbuehpFWjKqK7HGy901DRHt8nHlwhUpWJTbYzNDFzRz+4lG02WUW7x8j1Opl6BXD52w/FHMRirme1W/q0Dzz950hv1AktK6F4TduQ/EoiIqMN+ph84293Pm9o5g1FW+jB3+Lj52bwji9MpEOD+t3+ln+2sPIkgVGFaUhQP+fvZrj3xrjwH+cYf31q9lhLdNi9I5JclMZuva00r63E190NX+KIAqkposU5qtIMox+8SnslQSy4qVuuBEqOSy9Sk2tY6gm7rCbTe/cSzJpEz+RxhV0cPQ/T1M5NYPHaRDtlOkb8dL/hQt55M8fZvqWwwi5LKc+9SCpx9vY+r5LCa+LUS9qINg89LcHOHXPEo6on+YGFSE9gVcXCRntXPm7G5j5u1spPZZlNp4gctNlZGeLqPkqS3efQPE5cRg2hmFRStQI6ja2bWMaFpL8/Of7vxElkT3v3UluJk+wI4DiVn7sb9b4n+Tnt3ywZvl4TtbExxq/NARBoHvvai2PkhUnNZGlvGDiEG38LoNwixuH14GpmyTHcpSWilTLJo1SlohaI3PnIp7mTnou6efU0zXklI6ol7DLJjY29ZKFaBvImICIgYTicWC4XIimiauYp01cRmvpI9LYjng4iWzbCOLqA65s+9DFRlxOFUdPL8WkRj5pIBhVZAxO3qHRtqOFxsEIDreMw/3s6WMaFse/PUF2pojXLD2Tw+E5hEVuPMkTH76DWrLIujfuYuTt5z/nuGUWytz/jluwJmdwOUycTgeKSya6s4fQQBOn/s+3kX0uhn73GiKdDez+zUFsh5OxR+IMXNbOyEva8Tp0jv1rCUs3WTiwwtgTaTp2NrP5VUOI4nPfHNVCjdEvPMHSo1PUSzq5mTz6ShqzUCJ2fj99r91N4ugKRk3HNm2cfgf+9iDh7iAtQ6tv9rZt03TFZur1Ezh62wh0hEiOZjh9+yRaRcdQTZo3RkmeTHL4009SnEgw8TU3F/35FfS9dNURtaHLi0MB0TIojS4yPlvAF3OzcVsEtbkD9XtzSAULwe+l/aqNZ1ORX/C7Ozj1/Vnmj+VZ/P4s3kAL3kqC6MUb8XQ3MfvQDKUzSyiCieyRMGoaiUNLHPv3Q/jWdzL95AqFyRSZ8Sx1FQTJplQo4ylVoFom8V+PEB6I4Qq7yS+YzD08w8zio8iCgWGbOL0yvpgHzdZZaLwM36CF5+2X8vR/zZA4nWHD9X0MXf3cvkI/jMOjENv44y2La/zPs7bs8otjTXys8YKw86Uxeoa9PPFXJQqzeaJ9IYQfJMfa9+VxTt41jwMNwbapl3Qy8xUU0SQTXyK9pOHdOoAnoKAnDHTJiYoTh1PAXc2gYCEAVcFHdNsACjrWwaNIQh03Jr5YBTGfw7YriKLA9o0q9eEWUpMFUrUhPH1+JKdN4ekV1KqFggmmQS1do5RWzzkO27Y5fusEs/uWGbisk3B3kMNfH6cYr9GxpYEdb92L7HXStOPZVo/MqTiZw3MYFZXpbx5iw5v3nBOZ8d/MH8lQOj2PWK4gRd30veultI404lvfzsJth6jMphAUieKZZTztDWQXqxy9O04xqXL0niQbr2il8+IeLM2gXqhz6oEEpUSJarZO70XtBFuf24dAVCRkj2P1zwRX0EFpbBmrrmGpBu1XD9MwFKVlRxuFxSKW082Bzx9n7+/swNfkpRQvo1UNdn78Brpfex7OgJNIb5jcQhG7UqY+l0PYtJoXJf7oOLUzs9jZKqazgeThxbPiI9jsoW9vE7VEASupUayoaKrJtjf00rMpyIkZN/nJKnZbIwUxRDlTxxtx4nBLLIxXmdifxUzruNe10XLV+fS/YyuiKLD4xByWJeCIeGkabsSsamSmCqwcT6OeKKHpItnxDLZh4nbLBFw6idEy4bKJQ1ax6yr5p8fo+53reOgDd7B0ch5r9gzu1giRHa20bGnEVg32vGQYpbWRSKeXcrzC7BNPUsurjN45zcCV3c8r/tZ44bH5+cWD/T+zK//rWBMfa7wgCIJAY4+fi//wfNJn0jRubEJxydi2zfKpLGbdJNjkolSskTFiSBUDn13CNCo4DB1PxMCT18nYIpIk0d4hE9vWwulHXJipJIIISnc7qVMpxFqFJlFAckhYgoAliJTTGj5JxpIEune34rqojbv/Mk5bfZpOy4Md6aTQ5geljmLKCFodT8RF84YIlm5QWczhjgWolU1G75qhHK+glXX23ryF1FyV4nIF0efmhis24HCdKygM3UKSBaKbW/G1BaklSwT7os8bCREbDOHcOIB66CQF08vEOPS8th9Xk4fI9l7yxxeQfS4C61YTWrn8Ct6Qg2peJ9DoRJQEREWm/6XrsSyb1PJBtKpx1oegspynnioTWhdDcj5j1lc8Dkbeewltlw2BouDvCrN422FW9s1QMVykllQ6NrVw8V9cxVOfPczs48vET6SYfXyJ9FyZ6Qdn8IadbHvjMANXdJ/dbumJ4wTOHESxHZiZGIZqoBcqRLqClGSIbGik47IBTN1EK2u4Qi5u+ptd9GwO8tCfPUoxAdkiLP97igtuFAi1BVFrFsual5VvLWAaNr7kDKljy5TzTtKzIpLiJHZBP7vfMYIgQCVdJTrSzPLRJA27+7n0ry4ndTLJoc8ewDIs3AEP5QrIQiMiFpGBCIIgkB7NkBcjBD0CtteLp78VX18zWmMbbu0kolZFVGWCPf1sfs9F+NuCCKJIdjTOoY8/BrK0mu9DFGgZia4JjzV+bVkTH2u8oIR7woR/UBejnK6RmSmy7rI2bMMkYmUIVXNMTkNZ8yDpdSTRQrJ0JEvDYWvgCeCxCngqaaoHCoRb2qm3rccdcuCmSmI6jW1bVAIBei5vpm4pLB7Loks+xK4hAk1uBt5yAbm8iMOsI9fK1FYMBvdY7HzfZTgDDlITOabvn8F2OMmXJY78w0OUTs4R6G9iw+9cQajDTz1bIdTuJdDuJ7Iuhu0s4u8Io9fNc8THse8vcujWGZoHAlz1gREu+/zrKEymiG5pf97Kpa3rgtz4H6/gro82kp8vUS1o1HJ1/E0eLKeb0KVbiO3swtO+miXTG3Lw0g+uIz1XpW1DAFEUqBfqHPrCUWq5Ghtv2sD6a3sIdfjR8xWO/NXd1JIlOq7ZyLo37z2nb39XA/4fyr7pu/lSzsw4WZrRSH52nJf/2VYCjR66L+gkN1vCFXSyeDLH6PdnKC/maegOkJnKM3DF6u9t0yT34FEUow56DbfTRpRFuq8dRi+peFoDtF0zguJWuO/t36ISL7Lxt89j3U0j7Hzj/2PvvuPkuMvDj39mZnvfvb27vd6rei+2movcjY2NTS+hmBYgAUJIhQAJ5BcgoUMwMRAbQq/uXZKt3qVrut7vtvfd2Zn5/XG2xHEnWbIkS4Z5v17ihXdnZ7+7d7fz7PP9fp+njehAmO3fOEIuUqCsaxfRXzupfdMiBnsLpGIykj9Lavt+hn7zPPm0jFJUQlHVcgSrBbPLiigK9D09yMEHjhObzpLIOrEm7Yx3J6m/shqjzUjHz44R6Y/iL3Ww7gs3EBlKoiJitgjIskqwL46n2UXz29soXjnTmXjRDVUc3uHElIOisjwNN1biqvKiaRrpSJaRbX2Ejo4jGiTa37kW7+IqPNV6s7jLnT7tcvHowYfuksuGUyTGEuz4316CPTEqlxVz1RtK6fzsdtxjk1QbvIyoDjKaBbuQA6tELp6nal0VhryH9MET5CJxDIIBi91A9NgoiTwYzSIzEzkigr+YVGk9x+4/iDEZBaMBo9mBZnfQ/btuSq9swlHlRUsWYSqWCGxsweI2kY1lGdo5ycCxFANHJ1EfGKfd2ENFjQEEkGNp6hc7yB+NY0kaMAoKm9/XRu+uIBVtTjS5AMxsm1UKKrvu72FkxxDDzwiUNTlYdkcD3ray0785L3D4zKx7z2I6HhrAU2al7/fHOXpvgnT/BImuMWzFDjZ85XX4FsxkP3wVNnwVp3bO9D7Sw5Fv7UAtqBgk2PypmTa8of5pMlMJCuk8ycH5twK/KDGZonfbGPGYhqIKqIWZ7rQApQuLWXJ3K8Vtfg79ZhCL14Kat+Nv9lK74Q+6wYoirsW1ZEeDCF4PbX+1BVESKV5eRfHyKnqeHuHx/zhMYWgU5UgHqCpdPxBpvXMRoiiw+W/WEomI9H//GRozJ3BPSmT3gOgqpUgsUHNVEeYTk0ylMgg5BSUUpagpSfmWKpbdPLPeaHT/JLGRBPHJDHmzE1JpDvz7Y8SvqWPhX6xi77f2kgmlkQwC011hdj3QSzKm0LSpnNu/dQOx0SRWt+lk7RWAhhtbYHgdiQd+i1VNEb3vV0zsGyGGh5FREFMJ8lEFm9eE2Wsh3T+J2aThqHzpcvy6S0cPPi4ePfjQveIyyQImi4hkEElNxNn/hceJj8QIhwwUbB5iYynADZI4U5VJlNCMJrKqiEFVEFIasqiRi5qIBeMEE3bMhRLcLifCYBhDLIQRjXTGimSxI5ok2u5s5/ivuyGZAk1FVVRySZmJw9Nk4jLp/ilKpCwlH9hAy/V1/PTvDjD09HMzWRaLEQWJTFTALOSIGGScVoWK66qxV3oJf38vWibP9MExhp7tp+k1C/CWmNj21QN0/bqLNe9aRPWqAKIk4CoyQKGAaJDIhNPn9L5VLiuhclkJfY/2sPdXh5DjGbRImMJUHC2TY/C3h08GH38sF0qh5XJosoqazp683dNaStX1C0gOhqi7fdkZn3/PDzrofXYU0SixeGsVjRvKcQdsyBmZ5770PKHOEP4mDzVXVmJ/UxMmr5XhXWPs/cFx1rxzEf5GD0o6h1FO47BreNbXzOlpMnpwmuDhEaQTPZjzMwFANqPw+3/eSVGdm5VvbObWTy/noaFezM8ew2QXMZcXIfRKeMtNtG4uQ1lgZuTxTpKTKVSDFaNSwOcFd8BK77MjDB+YJhnMEFhQhGdhJcEnD0E6z+i2PoxFLsLjOVJTWUqWlXHsgcNMPDOK6HURG3UjCOCucHD4/zoY3TtO09Y6mrbWkYwWqH7nNQQn+knsOEz08BCRiIvJaQOZ0loiwQJmqx+HZOXYfftQQlHczSUs+8sNmDw2jO75q+PqdH+q9OBDd0HIGRkEAaPlzL9Sh5+cZsdPx/CWWbjlw/WEuoKMHZxAEjSKK3xoVX7ympGObpH6D9yI+uQg0T4J89EI+ekYaiqLoshompHIcIr4aAIhpyEbDUgTw5gTYQQkZEzYSSHKOYraK1jz9laGnuwhbTCQVyVsDcVo02GyoTSCKDCeT2PzmvG4VHqfHWFo2wByLI2ChtUoYPGacQsaxngaye/B2OKn7IYliAaJ8ivrmdg3SnQ0w6Gf9RCeUhg/FmbiaBCDWWKqM0z1qgCCILD1o0swKDKSARo2VLys99oecGIrsVNwmvBfUUH4+W4MNiOOmlM1R1KhDGNHQvhqXRTVuqjeWMv4c7UoOYXWO04VRZPMxjlTLQVZZfcDJ5jsibH01hrqVpcAoGkz/2N1GVl6cxX+Ji8Dz48R7Jwm2h8hHc1w7Ps99PxkP7Uba6i4aQljB6ZRCxr9z40S29PFxCOHMPd1YHWZSB86gZLMYHCeytCUtng4PD6BlsniJEIl4yQOTNI1JXFAsRMdz9C23kP08ABZ1UXG4qe/30P02BASKru//Bw3/PftXPP7D9P9syP07pyaWYxsEZk4FuKp/9jH2L5xrG4T7ho31/3NUvalhxj95S7MxmLS0TxyQQCPi6mOCNHuSSxmCatHZMlNVRy5dxe5eJ6+vWHS0TyJ6Qzh6QJdT43hLrNTaalhqu8ghawJzVvAW+/H6HUiOBQUVcTsNaHlo6iyQrZ3lO5/vh+Tx0bdh2/FVhd4Wb8PuotHz3xcPHrwoTtv051B9nx7P6IksPr9K/HVnz6VvOP/hul+LoTdZ2b5DSV0PpdidNqM1SBz7cdXEMlaeeZ/+hjsSCHdVc3hEzaCx6awlXlouaqSyKEhJAnstUVMHA9j95nIR9OYCyks8SCCpmJGIYsFCRVBLRDvmuDpf3qCwkQYl1ei4faF+Js9bP/U02hAKqEgWs3kDSLR0RRDz/fgMmSIWyWMdhPlrQ58ToXwaJqs343NJtBwQzNFTTPf2quvbiY4mCL6007iExkO/bQLuSBQyBQoX1pC1crSk6/fV+Pi9v/aDJo2786W+WRGQ6T6p3AtqMLkdVC6OMCVf7eJQrZAUYuf1OhacpE0nhemb1RV49mvH6HvuQnUgsqKNzax4u4myq5fQnwihSXgOfPP80SMo4+MkI3LKLJ2MvhY9dY2ihs9OEptFDd7OfSrPp74p2coJDKUtngxue0oqkA+niPYHaLlrRasbhPhzikmnh8glZ4kP51GzRuwu504VrSgGoxERxK4yuyIkkjZAh8liwIkD6XxxePYpTxmdZqBqWFSQi07v3ecvv/qwTo1TAGFjNlKLiCTieYhn2f4wBTjx8PUrC5n7T+WY/zvvRz70REmd/bhKLEiGAREg4holE7u8jGnI3h8ImZLHp9fJDGVJjWdIWPXMKoaVqeBa//lSgZ+e5DOHx/CYDVScPuIxgTESYWhwU4sNgPRvjBD+/fhTKhoooQ1b2DTxzfjbq9keu8A/Y/3EVhbhreqgem9QzA8RPpgN4VQjFT3qB58XIb04OPi0YMP3XkbPzjJdGcQQRSYODRJoQBmpwl32exU8u5fDtPx2CiJYA41a8FkgnhEJV/dhNFnxN5YRqwjipJII5kNZIJpJnf0oEQSGMcVKjavZNnfrSU9GiY4GGdwe5p0JIcoimAyU8iZMWoFCgYrksmJmM+i5WVyeTjxyADkckgGMMbD9P6wBy2fx2AyIlQWU/D7SEcmGX7yBIomUrvcR9XmBkaGFKYeO8x0bwxJVLE7bRQH3FQu9SOZTv35NGxtID6RRs4UmB7OkA7nqNhYwTV/txqjefaf2dkUl3pRPpqi5z9+Tbp/Cs/KBlr+7g5UWcFd4zlZlMxR5cNRdSrroakamWieeH8QdXyKHX0jJCbSjB+eJhfNIhdErv3EytM+p8NvwVVqRVM0ShpO9ZdxBewsfm3jyf8OnoiRi+VQcwqi2cCVf3slT/x9jvShHoxmcWa9x6pisuMR4mMpnAErZr+GY91G6t6+FqnIzbYv7iF4IkLdlZWseudi3FUu1n5iMxN76inKtCE98yQGn4uq0tWMPhihkM1TiM5MVwmCgH9BMa47Wnh+MkchkcJYX36yFb2qahz9RQ+j+yaZ6gxTfmUDdZvqqF5VRuUSHw2bqgCw1xaT7p/AUuZloiNMLphAzRSQkTAZFdRcnue/e4zI7l6UlEwmlkMTPaSyZuwlDiSjiL3IghCME5QlJM2CQVUhlqf7h7tp/QuJwV/sIz0UJiynaPr87QRW1xI/3M9wOoVkM4PJxPHP/AxLmZeaN29Aspxdh2Sd7tVKDz505624zY+3zosoCUQnMuz/xS4sLhObP7oCf/1Msal8psDhn3VjSkdANoBsYPhwhA1vruHwoxOUNjopbXDQ8bte8lMRLA4jRYEa7C4D+ZiMWZUZeayT6X0DTG7vI5cuIEtekGxgd2AJuClpqEXIZIl3juGzCpiryunbOU02KyBpGhayWLQckZ1dpCdSmAwO7A1FNL15ER337UYZnSARNeFbXIbTq5E91EWiVyGXUhBVCLT5EHNZjOkEXT/chbM5gNk+c5FwV7rY/HczRcKmusKEBxNULC2eE3icKyWVRY6lKSSzxDtGGX/yGKO/3kculsXVWk7lzcvwLa6a9RjJILL6ba2Enj1KZCiFOpam64F92NQEZGSUdusZn9NZbOXGTy4lPpGmtMVz2uMW3lLH5NFp8pEkq+9ZQs2qUpbcXE1fIYLJJhE6PIa/xYezzIHBItH8nuWkh0KceLSX5PeO0HjbAob3TRIdTUE4jG/wAAa/G8P6NSx6xyrsvg2o79uKYDHjlyWGTjxMuGMSU6kHUbTgrnCw5utv5tnvD5JMKGiKmYUrAySDWU7smMBuKTA9mCKXF8gWFB787H6kIi/1W6rZtKXmZJG46ndcjXdNM+YyH/t/1IWaK6DmCpiKLeSm4yRG40z0pTEVe3A6nNh9FvLFxfgKAvaAg/p1pax9cwMj2/p4bGCSxJgZd4kRX42FbCiFnMhhsBgRDTN1UzRVI9ozha02QOvn344giXR96XeEd59ANBtxL6mhaFXjad933StHz3xcPHrwoTtrE7sHGd/eS/GySio2N53sAVK2pJRrP7cZQRTYdd9x0uEsuUSe2GjyZPCRHgnhGDhGrRrGavdjrvUTHEhhcVlYfnM5Fa0z2w77nxsnHUyTTxrIZ1Wu/cd1HPnhPsSRUcSRfqJ7kyiyEQ0jkkHD11JM3eZq1MER1FiU6FAcJRIHzUT1QjeWRc0cf2YKMZ3CERvFLojk40k0FQSTgZqrG1j3F+2EnjlKcFTGkEzjL62mIBfITCZgIomYEZBMCrXXNZMdnCbeH2K6J8rDH3ucttc003z97AtFSYuPkpbT93w5F5ZyHyU3Lqfnq4+SnczQ8eVHyIcSpEejxE9Mk49m8H7hrjn9WCqX+Fn97iU8+y9RCvEU0sQoBqOMM+DG5ygQH4kxsn0Ae8BJ9aa6OY93lVhxlZwKUiId44w/2427sYTyq1oRBIFAq5c3ff+6WY8rW1pK5IgPyWLE3ViMu8FPLKIx1R1DsFqZPhElNpwgOZGibE01sShEJmVKUqPEC2miY1lGfhfDvrSV6/9uGVa3m0TXKKHRDBajgrcQxGou0HBDO8v/+RbMHhtTHQcppGVEYGTfFPsfnkaMhKkO5LBrOeJ2B/mcSnYsiRTNk1jgn9kC/ULwIVnNeFbM/AxrNtdh+59jSOkCks1CNq2hKAKqKKB5PThKHLRsKMXSUIm/tYjSVh8mq4SmgbOhFFNrPdYymZJ2J9U1GrYSJ2VXNuCq9xM8OIJmNHHk688w9uwJUhGZytesYOV7V2KrLCIoSYQHExz4/mFW+Lx4G2YvxtW98vTg4+LRgw/dWSlk8nT+cDfx3iDhjkl87QFspafqFFi9Mxeq5mtqSEyksfutlC/2n7w/N53AXyxgk+yU+d1Iy8uYHMrSsbOP0no7t/9NE3afmfJ2N9M9EaxeCxWLfFQs8VPhS9H55X6m98WQZBmjppI1OnBvXsYtn1tLcZmBbZ8cZbI3SXIsikFTEUwSjgoPjTctpOvxB8n1j1GwFjA2+Cn4fag5I67mKgKb29j3y2HSWRFTPolJKiDGo3gW1KFpAqaIgCUVxmCQSAyEWfnxaxnZPsChn/WQH4px4uFemq5ruGhtzgVBwL2kHkNVGZmpONGjE4iKjAAYXVYs/tnVSRVZITGZxhmws/DtK5GNVnZ9+hFIxFE1AXedl7INDRz94QFGnuzGGholckUVzR+9BVtt6bxj0FSVnu8/R/jwKJZSJ876Ylx1/jnHhR98nszvn6OxLkDJX1yDLeBhaiDFk9/sInIiRMejQ1z/kWYc3SGsXiuehiJcrWVkDQ4MBg3RPkpGVckUzMhjKZLTGaKPH2X8l7vQzGacliJUo4rFYQRFxWQzIhlE1r6rndhAmGwoRfhEhNCkijc+zMRAFqPbgaWkGiWUQyrIGCwSq+6owe6dmZrJJXKIBvEPeqZomB1G5GwBZ6kNLVdMZipFaXsJteuKSR7oZXrPEIuWlVO9vARN09j9QDddO0KUt7pnCs/FQoSe78Ya97D+08tBFFEFiaFDYSYPTaAOj1FIZkiF86TUY1Suq6LqrvXEoipjv+om1RWk/3+fw/GhzRi9zjnvs073p0APPnRnRTRKWLw2kkYJk8uCwTb/nHTZgiJu/rcr59zuW1JFxXULyQUT1N21CmtNCQ/83VE0NUt6LMojH/g1ajKFzWOmfbGVtretoGJpMcnjw4ze/wxiIoGk5NFEIxomrMUumq/0U97ixGgWqdxYT6Q/AhYLciKNHEoSOzZMJGsh2TmKkMoQTaqILpVlH1iLucSLyWHkwO9GmO6OYBiI4RFAK6hkgilWvW8TKgKHfzNA/493YTEUKFleiaPKR+1NdkaPx4kOxShfUXbBAg9N05BjaQxOK6J0al2Io66YiusXceB7+4llzRgMFsqXl7DgI9fgX1l78vkVWWHbf+1n4ug0lSsCrP/AMjCZSCpWJCWHqdzHys/eTlFbCWOHQ0iJKASnSRwpEHr26GmDDwQBo9OCYBQx2Mzz/uzlrMzUL7ejjE1hiCYRkknAg6po5GIZ1IJCNpbD21xC7cZaDFYDZqeZLe9pZvhwhKqFy/CbE1i60mR3Jgi0e/DXuej71RSFeAbBmKeorR6l0EhxqUjd65bQu22U6a4w9Zuq2foPq9l33xES4Tz2UAxRU1AVyKZkjOXF2GxpPEUSNWtKsZtkeh7rR7IYOPSjDiSTiLfChsVpJjUeRZkKYhVFateUUvGh5cipAo3X1DC9b5ijw2MIkojFN7NDZ+iho3R87kESCY2J3XWse9cC7MlJYp3DTI8PcthtYHpKI9g5TTKUQ9AUfOY0alYmnTeSCxdQFQ3RZCCwuY2RgyHYu4fck70MKiHq//6NiGZ9/celomc+Lh49+NCdFdEgseRDmwh3TOKuL8LknNsB9UyMdjM1b1iPZJIw22Z+7a69p56BA1GCv91BZMehmW20VQFEn4feZ4bx1Hnof2SI8UMhbFYDRdcsI/RciFyygKZJDO0eY+JoFdWrAix420rMpR6e/PsnkHtiCMkUI7/ai6NtCqmQBQqomgHNbEEURVa/sYn4dJaDD00gWsw4mgNIliQmUab0ppUkMhLdTw5z+DcjqDGRUp9AuGuabDiFxWdnwyevIBNK4yy/cN9MB3+6m/HHj+JqLqP1L689WepcNEg0vHk9B7rtZIJ7sGQi+K9dTvnVM71Ppg8MM31wFFulj4mjM43QMuEMS1/fQj6tIHpc5CQzgc3N+FpLEASBRW9dhs1UIPmEitllxlo5N5PxIkEQaHvvJkrW1uOo9s3KeAFkE3ke+/JR5C6JcoNE2cpKTIGZaafSejsb3t3K0R8fo2ZNgNJWH7GJDE9+5SCCIHDlPe3Uvq3hhTP5aV0INVtlJnvipGN5Sm9cQSGRIZOXOLptHFkWcSxqw1Zfxo5P7SA5mSY6GGfDR1cROREienQYr8PO4HMWFNWEo7mckhWltK51Iw9N0PXjfTz0rRAmhxnXomrSeSPRoRjyZBgHadwVNhw+G+lIlsm9I7jLHSx/13JEUaBqSyMWnw0lV8DqMaFk84T39GJUMkiRFKrgYODJExQnx8jJCRSbg1wsw+juIPl4jnxOxa7EKUhZNKOZvNGD0+fCVjKTvSpZWMrav1rH4OdOoMUS5CciKKmsHnxcQpci+Dh27Bif+tSn2LdvHxMTE9hsNtrb2/n4xz/OLbfccsbHPvHEE9x///1s376dkZERAoEAV111FZ/5zGcoK3vpYoavJD340J01q99BxYb5m5C9lL7d0+z4n25MdiPXfrgdd7GJsjoLFS1V7D5iIWUS0AQTks1IMAqRXRFyaie5iSRpfyMFBxgXLmZicJT0iVHEgglbQSDXP8ZYPEzJFU00XNeInJY5/GUZ5UQ/JpuIyaRRYksj51JkBSuqIFLSPnOhdRVb2PzuJiY6o0j5Unp+nEETYTjt5VdveJbkQAgxn8OTm8RQBEZBIdI9TdlaOyabEZPNfVavPTWVJBPJ4mv0zcpo/CG1oDD5TCeZ0SiFdJ70SBhnw6lMRDYps+K2SiSLRFGFjaVvrCUXThLrnuTo/+wmMRTFVVeE3elmZCqJUCgwumec1utqSIcziAaRte9aSD4Up+e+58jnoPHt6zHeugA1J2Nvmr842YssRQ4qrm6b977gQJKxYxFyjjaEqjZWfWILkm0mOBUEAbclT2mphpiMkxhLMLgvzMiBIAgwuHcab9WpAE5VVJ742nEG9oUpbXJyy98vwfeG63jofb8kve8Eks2IGAtgcpgwO01kIlmsPiuuMgdV7S5CT0awyAoLb6pCHByiZoOBwE1W+n68g4HfHyUznUXKqhSyDrRpG57FLQRHM5gycVAykAbfwmJUQaQgq4zsGqXt9laMNiOaBkXtpRz5woPEOscoWl6Lf2UtVb3TqIdjaC4f2X3HSaVHsdug7DWtlL1pM2NDjxMbiKLZJYhnQZWxaBlq1X5sEvhqT/1NWXw2vFcvQx4cx3vFAgz6tMsldSmCj8HBQRKJBG9729soLy8nnU7z85//nFtvvZVvf/vbvOc97zntYz/xiU8QDod53eteR1NTE319fXzta1/jd7/7HQcPHiQQuHy2c+vBh+4VMXQgSHAgiWQUGXq0E8PRg4hGCd8t64lMy5jLffirrTgX1ZHrMpFKgbPUhtMB4+kCvmXFJNISBVUk5SqjqNxMdbuNkV/sItQXJ19Ry/IPbaT9jnYab2hk5/97luCOHqxtfkwHwyCqIOQx2o3ImQIA0YEwOz/1ELHhOO6mYhIxBU3VmNwxSXw4hZJVMaoquJ2o4RFix1IMP3SEwOrqk9tcX0p8JMZz/76dTChNy21ttL9u4bzHiQaJ4rUNKFkZV1Mp1vKZWinZoUn6fnec/XsLmEt9bP1wG+6AjXw8w5EvPEiid4pUKItgd2CwGmm4oprIQAwBkDMFfDUurvnb1Sef5/Cnfk/P97ahKAKx8RRXff3O8/vBAv5aB+ULvISHU9TdVH0y8HhRejqFmlNIh9Kc2D6O5LBgdYgY7SZ8NbMvroW8SngkTSGVJTKoER1Lse0/9zOyawJ7XkYTBGpWlWAUFJpbBLJVTpretghBEEhMpgmeCKMqKiXRINL0OFOPhBFEiUTfFEI6jU1JohhEhGIfzbe0suB9G9n38BQH/zWDOTZJ5YZaWu7ZxKGfdJGaSFKysIRUMMOu7+xEVTSW3lFPcmAaOZYh3jNJ83s24V9Vz4KEQt8zw3R/a4JCREE0m6m6eSmla2u5+d7bSU0kmTo4wrH79mC1B3AEBxHTCZzZEY7d81W8VyzAs2UZR7/yJLlIGlN1KSPPxamzDFK7qfa8f0a6V48bb7yRG2+8cdZtH/zgB1mxYgVf+tKXzhh8fOlLX+LKK6+cKT/wguuvv55Nmzbxta99jc9+9rMXbdznSg8+dK+I2hXFDB+KYHEYsGTCRDuGESSRvNVNsD+JmNPI9E5gzGdYcfUqjAtbKWtzc+CHRzCZBUyRKYQHd9IqW5C3XknV+ipq/Sm6DueJjaXIZKPs+M5Ralf6iIxlObxPIXq4gHFvL36hgNGoIdpMlC4rJbBwJvMxvH2IyQPjFFI55HgG1WRGFCUqlpqJJ0TUvJnahU6EcJjMzilkWWVy3wiD2wYZ3T5A2bIAdde3nDEQSY4nSYwlKGRlwj1n7p1S96b1lF23GLPXhmg0UIglGfnyT5l4vAsp42asbRNjHTHcARu5UJLMeBQlm8dT66HyjrUULSrHXORg7HiYsUMhMlkBVdXmdk7VLmybb4vTxA1/u4RcUsbmNc+5v2ZdOfnJMFNhI9t/MYE4HcTtUPFV+ylr88w61mQ1sHSlke5nd5LrUtjx/zKoqkTW6EBVwVnqpPLqZkZ+uZvQw3uRbCZyG2pwlDSTTRfIZ1S0QoGsVUMSJGQZ8nYvoeAERq8Th8eA0WWl6g1raHr/ZkSDyKqtPppWvh55PIh0aD/DH/wCqiGAe8uVLLq7jUM/PMLkkSkEo0R4pAznwmo0Rqi8YREGhwWjU8BaIuCpdjHyWAfB0SiuMjeqf6Y4m8UmkVeyDD+wDWk8iL2tjPZ7riS+4wipnnGyYxFCzxxFc7lJjUbJJ7JM9MShpJR0ME3F6oo/WBCreyVdLms+JEmiqqqKPXv2nPG4jRs3znubz+ejo6PjvMdxIenBh+6iS0dzVCzycucXVmEwCqQ7BskfO4FgkEgXlTE5GcWWFCiqMCMYJIoaPJRtKWfs4CQje8aR0zLBnXsxhibxGIxULlmPs1olPaVQ+ZplhIQhpjuS5A/1cfCHXppuacM1fIxAcCc5xUCYmekOq1mkbrmP/ucnyMTy+Bo8OFwCyWgWQ1bF6JAwV/moXurlpi8uIRPN4Q7Y6Hm0n13T0xCN415ax5OffJRUfxBPrQdHhZuSJaefsvC3F1OzqZb4SJzGG5vP+D4JoogWjTPx4PPYGsuxNpajJDNY7RJ2TSHQaCfQPLPewl5dRMX1i4gcHqbixiUENrYAM83roiGNZFqk47ER6q8oo6j21BqN5vdfA1YreRma3rZ+3nH8MU3T0BT1tF13AQwmCYNv7v3piRjDP9uFOhZFSTlQxAoykwlsoolMME06lMFdOfvCKg4PYI4FUVMKicODLPyrq3FXOgkPJWnYUsPjX+lE6BzGq2hIkkh4II7iDmIQNUx2E5pmxLO8HLNYQ+XmRjo6BWJFdViKAgSKEyQnU4wMKbgPjRN6ZC/psShVr11J2apqRr+xG3F8FLcYITK5gP1f2cHEvlGEuIJvZR1yMsvw06MYlDwVVge///xR0jGZtXdVU5iOII9MIkgSqsWOIIkkh0Ic/veHmT4wTOzQEEY5TSod50R9OViqUZ0CVjWHq8pP8ZUtM9VVRyKIEZFoX5hMV5Tu7+/A21SCb3El0YEow0/0ULSglLqbF1y0XVa6GRcy+IjH47NuN5vNmM1zg/UXpVIpMpkMsViM3/zmNzz00EPcfffd5/z8yWSSZDKJ33/6dV2Xgh586C6qrqfH2P2jXhzFVq75yEKsTgvuZQ20fvbNCJLIUz+eIBvIIovVuK42UbfMg3/DzNoCQRKx+qwYLQZcpgoKh2JIPjdmn4ND9+5BTubxL6+m4PRiiA9hyGoc+9/9iC4HTf4QcUsBczpLTHOhqEaykQw7P/UQSlUtxYtKqbNP48hHUMQcotNFSbOX+tctofaqOqwOI1aHEU3TqL+yDPtXb8dgkpCzBToe7EPTQIsniDy2F7O6APeyhnlfv8luYvVfrj2r90pTFEa/+yDJI/2Yy4uo++e3UPrma3Ec7qVhYQvu1S2Y7UYSwxFS43GqXrOc+jeum3UOURJwBWyEBuJIuRTJvil81Y6T2RlLiZvFn7hxvqefl5LNM/LfD5HuGaXk9iso2rLkrB8LkI+myUXSKPkCgSoDzoYA6gIz4vQEgcUexh45TFffNPWvW4F/aTWZcJr+/RHSaY2CYMS1oJL6dWWsfP1McLXj+12MPdGBIZug6OpmbNVe9v92FPHhCVqurqTh+kYKCnhXNRJYXEL1ygD9f/cMsaPDZOwmzHeuYejBXgr9WYQfHcQ8PoKSkZne0U35VW3YWqtxDIXAXETL7Qvo/81RDCaJ8kUervi7tRz/3/2oB45QkLN0fzVPr7QQRVZ5dmgcYWKc3FAEq9uEv85J6eJSgnsHSI/HSE8kAQ1UlVwiT/+Pd5MVbYiSiLfaQeNrNmGvKmLRh68BIDER5/Gb/4t0zygH9xzFs6yWso1NxKIQ7Q0R6pjAEbDjbS7Rm9K9SlRVzS4G+M///M986lOfOu3xH/3oR/n2t78NgCiKvPa1r+VrX/vaOT/vf/7nf5LP519W4HIx6cGH7qLq3jbBWEcM81CKqZ4YTv/MegBT0cy38eZ1fkaPRFAGh0lOmBGKG5FzKqNHJtnx38coZERarmlgcI+TbNJD7dUNiDYzySP9aCqMagbiYQFUBTSBxECEbZ9/jpbSIhpuXMBod4rCiAtjKoIkKBTSOdSJaahzEO4fJz2VRM2oxCKw4oaFLLjrVNM1TdMY+vFzTD3TgXdZDRXvuhq1oLLorcuZ2jtMUayX6ON7yfcO0/LZt5x8TS+bICDZzAgGEdFkQDSb8GxaimfT0pOHpCYT7Pn3J0mNxanc3Miyv9ww+xyaxpXvbsNtzTP+ZAfH7n0eSYLKTS+vYmamb5zoc8cpxNNM/24XSVcFo0fDVC8ronLx7CJYmdHwTH2LCh++tTNF6FxNpdTcvoxE7zRVNyzEt7iK0LZjDP3PAeSdA3R0JUlHC0wfHOP6X70XpaAyOa4hF1zYvSY2/NVyfDWn3leXRcYV6kNIpxFSLsTydjKxmdL+Ro+dDf92I0999Sj7fjWM6/kQ1/ttyJEkWjZPQSkQORHBUe4iFUxj9LkwUQTZLMXrmxFMJnx//Q6cd1yHsbYCwW7DbDMwvmuI8nU1uCrdVCwvZdpphJyCJ2DBa7aTT8mYCilkkwnJaUOzmwlmHHQ9PU7j2grKt7SQjWaQnW4yJ4YxZ2NImRSSSUQzOlDMdjSjiVwiR3IiiafGjckioQQjaJkcaBr5SAo5nsVaXERiOIqYiNH/X79lvNhF00dvwVapFyS7GC5k5mN4eBiX69Tv8pmyHgAf+chHuPPOOxkbG+MnP/kJiqKQz+fP6bmfffZZPv3pT3PXXXdx1VVXnfvgLyI9+NBdVOl4gfBoGofXjMU1d8tg7RIPW98aYM9/dBLtivDER39LQRER3S5iGfNM6jqUJx6UyZqKmQpKSKF+JE3BYJEwhodRp3PI1R5cFW769gTJ9k/TmXez+b/fSHOZh/Lv7aD/vmdIDkfJG1UstWbWf2wdB/81Sk6dIiLYkXx+Ctrs9H8hlWPqmeNkhkOo2Twlmxcw9OBRks90EWgsweZykx3MIkjiWS9APRNBFKl47y24D57AUlOKuXRug75cJE02nEHJKaTGYrPuy09HGf/GL1FiKRwVdYipJHLBTD6Re9ljMpf5sNaWkh0JYmqsZtt3Own2JxnYF+SOz68+uW0aYOC+pwk+14Wl1I25xIWjIYAgCvhXN+BfVc/ovnEO/fQJPPI0+fEwcq5AdixGJiMhDkdJjccxe6w4nRoFIYEpKzD5690UL6o8+Rw1q0vodhvJplXiY0kWXVFBdDiOaBCpXl+JyWlBUUBTNORglNGHDmH3GjG7TEgGicDSUmo21tLxiw6GdgxhsjlY9a4rKF9XC4DodGBeeGp6rOaqRmqumgncNE1D9XjINbSihmKYVy3httsWk08XUJIpen7bhcHRyrHtUVLRAvt/3k/DumKsSpKKco2yBX76A24M255GKKQpVPtxXbuMyivq8DYVsePfdxDpC1O1vooV96yk+MoWxh8/BgYD9tYqau5ag3dBOaHjk4Qf2UN0dzdKIk26f1IPPi6SCxl8uFyuWcHHS2ltbaW1tRWAt771rWzdupVbbrmFXbt2ndV0W2dnJ7fffjsLFy7ku9/97ssb/EWkBx+6i8pgMeJv9GBxGVHVufcXMnlsRRYcASfR3iDh41OoBQ2jL4F/0yKsfgf1a4tJTybIpM0ESlSGfzVEPl3AZBXRpoJYcwr1V9WitLRxfNuzKHmFbLJAKAQ19Rbsfhtyfqa/jFbI4XILWI0Kjg1LUYM21M5JHEIWm2tmzYKczCJHU1jKPHgW16BkZJytFUzu6qfnvu1kp5LkgikWvH8j9lUytsYyjN6XtwX5j5kDPszXrz7t/Z6mYhpuW0jsRJC6G2dvfU0f6SW5vxtNLsBYGF86gcHhI7D8zNtoYaZA2fhz/WiqRtn6Ogwv9KQxep3Uf/Ju8sE4gs+DofsgokHAZJGYE28JgCCc+gdM7Bnm8Hd2IqdlUgkFVRPIuAWq26ooyBrixAjmsRAGUcXit2OymWi9vZX+sQGsdhGL91SJdzmeJnZkhIK7iDxu4vYyJJOBDX89+/1a85Zm3A6F4H//kv4DKTxrWrnqM5sxu6w03dCIZJSQTBJyMo+SU8jnhTN+mCdDWZ67t4PxgxNkxqNEh2RcNRV4plSKB0JYvWYGfn+U3GAIassZOzhNeCzNZE+C1XdUkD7chxJOYDYbWHljLT37IRtVyEXSGETITEQ4/oXfEts1Qc7sZfp4EFSNdd9+O8e/9zzdjw4SyhkZ64gRWN9A+bparMYCciiGZBCxVlyYUv66y9udd97JPffcQ3d3Ny0tLWc8dnh4mK1bt+J2u3nwwQdxOi+/Ldt68KG7qFbcXg2CQHGdnbKW2VF/om+Kzq8/gVZQab9jJZm0xp7/eIZIbwhPjYcbP7eeY995nmff/2OyWPC1BZjsixAdiWP3e/GuCBB+6jCamEcwmwkNpNCsNvK5HIJoJjKcpGKJgrW5gozZg+xQ0LJ5Qkcn6H+wg2VvX894R5RY5wTZWI6u33RRv7mKri8/RHY8QvlNy2h4z9VU3LoCc7GL/p/uweSyUkjmcVT5yDqL2fPUBNLuKbb4iqlYMDdTcaGJkkjL65bOe5+lrgxzdSmZyRhTB8ZRFfAVOyCVAs48ttFneznynZ1oqkohW6DuhlOBjcFlx+CaWVdw1QcXMNkVo3yhF6Nl9sdH7Tu24GqvxFruw143s9MjPhghORZHU1UMNhuqZMC9uIL2v15LPpEjdPg/yIWT2MxWlGAUqktY/P6NVK4oIx9KULTuVBZi6IdPM/XYYVw5Ga2+jcoraufdXVNU66K+3UIok0JJZckMTlBlyhPe2cuERaZi60Iat9aTCWcwu82ULS9DyReQMwUs7rnF84b3T9O7Y4Jo9xQmQcZoFnH4LaiJFDv+fTtaXiZ+aIBCKgeOXrIZP1quQCaS48BjIdasaSW2txtbWw19vzyEHIojqQW06WkGHtiB3S5gVZLYipyY6m003dyEaJSQTAZK1jXRs30KLSUjp+WTY/KubCQ3OE7wN88z8vVfUfux12Eu07MfF9rlstsFIJPJABCLxc54XCgUYuvWreRyOZ544onLrrjYi/TgQ3feNFVlev8wqqxQvLIGyXhq10Pt8iJql8//oRg5MkKscxxN1SieiNDw+rU4K5yEuoJUbqhj4NETHP7O86THYygYiE3nKa81YymyU7KymkUfXE+H2UA2kqb6tStxxkQmOsJEh1MUtfg49vAoHb/vw5maAElE8Psw5LMYvRaCndPUJnKMT4oksyI2o4JoNZEZDZM8MYGSzhHZ30/1nWtOprSrbl6K0W5GVTTKr2nn4INjRIZTiAaBYF/8FQk+zkQq9RMqbWews4+cJuDIT+N0F2OpLjl5jKaqs6aINE1DEASUvIIiF9AKKkqucNrnKGlwUdIwf+rYWual4rbZWYiyNdUEj4yjCVB/QwuaIGEWZdIjERx1JZStqiSmpLBW+VAzM9NDyc4RcqNBXItqMPlOfWPLh5PkEzncpTaWfXARJVc0nbZom3dZLSVXtpDsnyZw0wrGHj1GZiJGPpykZF0DuXAKu0OgZGERqCrbP7ed1GSSttctpO7q2YuHPRV2XAEbguLDZlaoWOpnzXuXs+1zzxLsDpMNpjDEUlAooGYUjGY7RpMRc5GVqiVFVN29guJb1rL33gMEj07i1FQkVJxqkkgkRD6qYrRqFC+vovyuNia3H2P/7k7a3rORwNIAi9+8hEw4Tf3VdUw+28nYMz3kZAHrxABqME4hkSY7NKUHHxfBpQg+pqamKCkpmXWbLMv84Ac/wGq10t4+U9l4fHycWCxGQ0MDRuPMlHEqleLGG29kdHSUp556iqampvMa+8WkBx+68zbxfD/HvvksqqzQ8vZ11Nyw4KUfBLjbynE1lqAqKu72CgBKllRQsmTm/+dyGppgwEABu5ZClQ1kIj6MThPNdy+leFE5rs/czMDzY0wFVerXlfC2n9zMVHeEkSNhDn13L+LwIFljAUeRGbeaw1rpQXV7cNcWEZ5WSMtG8qU1uAMiV316MzaXAd/KOlKDQQLXLpo1XrPHRs3tK07+d+2qYoYPhjGYRKqWnXkbm6ZpoGnntTYkE80SG4zibfBhdsxdPxPqnGb00DTZnEjGWYpl3TLK3rsc0WxC0zQGfrGPiac7Kb2iiZo7VtD/vzuIHhyk/KalVG5soZDOoykq1VdfuA8sV7WX9Z++jpFf72P4f55EK8io6RwGh5WWj9xAzXtvZKrMh+i0YqktRY6n6f/GQ6R6J3C0VND2uTdjsL3QBC5Qw2RqGKPdQ1tN4GTgoakqU4cnUGWF0mXliAaJXEFCu+JK/FtFGl/TxPH/9xD5WAZbpRcVgaP37SXaG2Jo+xBxi5/koX68ATPD2wbmBB9l7T5u/McVLxRtcyAaJHp3TtPblSc2mcfmtkLBgaTJIBopqXfjcBkorjVQVTkT3J14rJ/BpwZISz5MljBmcqiSHSUroSgiZlQMxW4ySYWpnX2oyTS2Ygdt77+KlltmUuzhAwN0fOUxpvcMgstBUbOfQE0p1upi7G3VF+xnpru07rnnHuLxOBs3bqSiooKJiQnuv/9+Ojs7+eIXv4jDMTPF+8lPfpLvf//79Pf3U1tbC8Cb3vQmdu/ezV/8xV/Q0dExq7aHw+HgtttuuwSvaH568KE7b3Iii5zKoRVU8vHMWT/O3Rxg2WfvQFM1TG7bnPsbtzYQ7l1L5OGdaOEYqHmyZgE1nubQvz2EmNtC3lXEzz6xh1wiT9u1Vdz19U3UrAnQ+b3nMRw9hCCCpdYLqTRyJovZZab9fVuo2LqAVELF41CQKiysemszrrKZP+q2j92Mmi8gWWZf4OVokrHvPYwcSVL2lmsoba7ktf+2EuC038ABCuEY4W/+BCUSx/v2W7EsPPeLu5yR2fEfzxHqDlG2NMCVn7gCURIpZPJkppPYy904K924q70YLEbar6il8eY2PJUzmYN8LMPYI0dJj0ZQ0nncTSVMPnWcxGCE0IkIK+srabrj3LbRnouJJ4+THgmTn45htBkxevJkJ6K4F1YRG4mTnRwGq53y18y8n2hzy6BFowKJolokUSQ6ksRbM1PefmzXMPv+6xmUkUma7l7Ogg9excGfnaDz0SFMdiO+tlIWfPR6kgNBnPV+BJMBs9uCaJSIBmUmNBUhY8BtMFGxtmrO88JM9mPgiV7Gt52genM9gwfCZAtmNI8He5WZ2te1M3I8zlRXFJfFgsuSJj+Woev/DlK6qpp8IofJKiEsbqLk+hupqdLY972DWLYdxCBnEDUjqYFp7AtSFKbDFEJxgk8dIX3bMmwvVLvVVA05lSOfzKGpEtbWGpr+fisGq4n+x04weWCMxlvbKW4rvjg/xD9L55/54Bwff/fdd3PvvffyzW9+k1AohNPpZMWKFXzhC1/g1ltvPeNjDx48CMD3vvc9vve97826r6amRg8+dH9aAlc0kJlKouYLeMrtjP98B64lddgbz7zQUdM0jE7rae93Vzi59rNbmLy6hL57nyLcPY2SzZIOxQmGozz/L49R/PqrSUfyFLIysYk0mgahw2NMPn0cySAiaAX8C8tJTcTI9k2QieUYeaaH9HQS55IGnFocScphzidOPq8gikgWE/lUHk3VMDtnvnknDpwg8uwRVFnBUOLF2lhxxqDjRdnD3aR3H0GTCySf3vOygo9sLEdyPImclokNxylkCwhoHPyPx4n3BSnf0EjrO9ez/h+2kI1kcNd4Zo3N6DDjbChBTuZw1hdjryvGVOwmunOMrFFi538f4vrPbpw1ZXahCIKAf20jhWQWV3MAk9OM2e/Es7yOVP80mdEw2WiGied6qbhrHbXvu4Hk8WGci2pOZj0AGq+uIT6WxF5iI7Dg1BRDNpwm/9wBmJ5mcGyQinU1mO0GJKOIZBQRMimSzw8gG608+GCcdCTPypsWUXN1I0N9BRJPRjHXeVj3rlrq185Od4cOjzD6dDei3Urf00NkwxniQ1HqblzK6LEopoUe1ry2AoPbTue/dUCdB2uVGZ9rmnhfCHu5C8ko0nxbO5oGwb4YosOKdXUddc8cIRQrItOXRymo5Ian0SQDuYIBOSeQmEpz5Lu7yCYLNN2xiNIV1ZiqAhhHM4hOOxWbmzDazAw+fIwd77mfbFph6PEuXvfIu+dWtdW9LJdi2uX1r389r3/961/yuPvuu4/77rtv1m0DAwPn9FyXkh586M6byWmh5a1rkCNJuv7xh6T7JnC0V9Pyubee7Mz6hzKJPL/4yDaCRydZ/uZWNvzlctJD0wze9ySFnErNX1yFq6F0pprk/z1PPpHG3l5LNFTAVdAoZPLk0wpZzURJvYPaDZVkI1k2fmARo48c5ej/exBDLIxis6Lai8gVlWN3u5G8bqK9ITp/1YV9+zALP2RHkgRMVhHhj7bihE+E2Pv13SgFleXvWUnpolLMFX5MAR+x/jCHH5ukN7WbK96/FItr7qJHTVUJ/2Y76eMD2NurMVYFUJNpTE01L+s9dpTaab65mdE9o9QuLyLxo9+RCaWJH0+STSpMHxymbjKKEkvhbiibExSJBon2D11DajiMvdKLwWam6YPXMThqQAmrqLI2X7Lhgind0oajoQTvkmoMFhOKrHDoe/uYPDiG3eEh2JEg3TvA1F3/w8b/eA3ld86tvlq5vJTyJcUI4uzdKaWLSzFboGAUQJbJjEVYetdihnuyjPWk6Pry73ENHSc5nSFoW0C4ZjlF1Xau+8sWKjeqVK9JYHUaKK6ZXaxLVVS6frCLyPEJJLsZDDYEScToMNGw2k9FuxvJKGI0S+SzCo2rfYz3JFh2SwXNKxYSH4zgbSlBEEWcFW6cjaUc/O0wB381xMEfHmVJmwmzUUElj2Y3Y6rwIWsGQpoPWVZITxnJ7B4lE0zT9fsTmMuL8BSJWBvLsRU7cNX7UbJ5hr//FFJoErMqUYgk0FQVxAsfRP450jj/BaMX8c/qVU0PPnQXxzxXssmeGIlgjuRUmv4nelESGfZ9J8XS19bT9fnfMPnQfnKywOCxJBu+djfZnmHGfrcfVS5gbShHySkoeYWqW5YQmlIoXlxOyzVVNF9TjSCA0WLgsTc9TqxzAlEUcDb4iWatTPfGqb2ygmVvXcWjf/cUcnB4pnFdrY9V7/STjWap3zQ73T7+bA+xHYcpWJxMHamidFEp9uZK6v/hjTz7/3YydULGsGeSqa4I1avmdorMDU4Q+uWzFIIx5OkoVf/wbrRsHmPNS297nY8gCLTf3kr77a1Ef/YY4V8/DYKAP9BExOOlbGUFvZ//KflgnJKbVlHxhk1zzmGwmnA3nxqrp66IdX+zkemuMBXLSzGYLs4FK9E3xfEvPYScyFL3+rVU3LCE2ECEoWcHyEazREUz41E7pvAkqKNM7R7A3VQ677nmyzTZK700v/9axn6xE0dLGcVXLyJfEAmFBdJZifBIFFMwCgo4pRCKUyHQ5Dx5vuqF83cnFkQBs9eOaJKwl7lY+LqV5DMKZStn1iRZXqiAG9rXTy6Y4Kq31SNaLZisMx+rtpJTi2WDh0aY2tZFPhinEE+Ri47SHxSptOWw1ZYgx9JYi6w4THmMAR/JggVTuRshG0Tu6kNRDASDOWh0sfxdK6jeVI+73k8hncNebMNZ5UFWJRZ8/CqkM5TB1+kuF3rwobtgjF4HNe+9gWTXKK4ldbOyHtN9cR7+jyMkgzkqWhxIqowxPoWQF9j9D79F7R0lG8lQEI1kIwWCXUGMqTyizYSQE0CbWXCZnEiSVfpY85mbKV5eRTqYxlXpOvlN2N5UQXB3H5qqUVBElHAMSdDIdMiE7Hkqrmln0O4iNzDOE3/5axrvWEzTSi+xvT1Yt7QhWUyoeRl55z6so71kFSPJE42ohQWIBglLZTHlV7URip/A7rfirZ5//7zkdmD0uVCSaUzlfgyl/gvWh0Ny2ZHsVuRMnlw8izkgYfdaiI+GUDN5Uj2jZ32uiuUBKpZf3Dbb6eEw6ZEIar5A/MQUFYA94MRd64XBKIJRoiQ3jL0wgeZowt14as1C6PgEuWiGkmUVGKxzF9nCTGDW/OEbqH/nFgwOC4IgIKkaNYvdFHIKlkVbcI5ayUwmaFq5gPK3rqK0xYOalylEEhiLPfMuBBYEgQXv20DZlfU4aopw1c7dTZLoHqf764+RCyUp27qQlg9sPXmfnM7T/dsuMqE0Iw8eItIxid1px1olYusewjKYIesxI5Z7yAhWsh2TaPk9XPnGDfSPmvBWu2D3btQhC2Ioi5gLIU1n0ZIp3PUzC5wNNjMN792Kb20z7vZKPEtrz++HpZvlctpq+6dGDz50L8vYjj6m9g1RuqqGsnV1J293LqzFubB2zvHpaJ50NI+SV5nYO4LDolIQ8hhEienDo/hKbJgaKsFdTNH6VpKdo0w8dwItZUBLZgk/u5d8IocsWcnHs0weGOP47/tJnpik8fpGlr1/HYIgsPyvNlG6tpbEUIThJ3oQLElEUSA/Hmbs6SS1d60m1m9lYleQvKgy8P1n4YAbURIQRIHy6xajKSomi4jBJGIswPShMcLdQfztM9/GF9zaQMXyUqxu07xTLgBGn4uKv3kjueEprG21F7QBmOOq1YhuJ+NPdxN5egjiE2RW11K0aSGZoWlKblx1wZ7rbOUnw+QnIlhbquYs1PUsrqJ4XePMBfqqmfohZqeZ9X+7kfRUkshzxxl+JgYmEd8SByVr6gEId06y/0tPkYtmqL91Ee1vPf3rEgRh1vohURTY+t56oreV4yqxIInryIxFsJS4kCwmlHSW4S//jEzvGN6rlhF487Xzntfis1O+6fQNAZVcASUnoykqSlaedd/IzhGO/fgocipLsmsKNZNHlAXql7kohAwUplXSWYFIxEayYMYWHkWz2qlvLqLlXTNN4zqi/WT6x/G2BUjFZcgViB4eOrlFGsDVXomrvZLYwT5Gf7oD97J6HI2XZ22HVxs9+Lh49OBDd85y0TSdP9xDcihMpGOSogUBTK65C0f/8AOyYqGX5bfXEhtPk+kXmIyGECQVSVUxW0WUnIKpxMuaz91G0aJydv/T70gMRogNxdDCUYRcFlEUEH0OStbVY6/w0vXz7chD4/SMjVO1ppzilbVY3BYarm9BkRWcFW5233uU6EgUcypLVbWX4HCGyHAKBQmDJOCu8yIICggCciJDvGsMR30Jle+6nnAEsqM5bOVeLL5Tu3EEQcBb9dIVA01lfkxlF76TpGAwYF+zCJ/Ny+TgzO4i76JKfIvWznrPXyn56SiDn/8RudEgni3LqHzf7BX5Zq+dBX9z08zY/2BsZqcZs9OM3dKC8kQDSiiG/9qFp84bz5KPZVFyBXKR9DmPSzKIFFWe+rlZK3zkohksJgO5sRCp44MUokliO49T+oarEKRzn65wL6ik4W0byUzGCFw1U3/hxZ9BZjpJtHMcRVawBHzkYzkKeYXwtIq/powCBvJGFxFLgEgEbDYjBRx0/GgfviMT1Ny0iOyJUYxCAf/6asLDKcYfP0Z2xER4/yBFK2pPjiMXjNP/7UfIDEzhXFBN+7++GdE0d72VTne50IMP3TmTzDNbFVNGCbPHimia/WukZPMM3/sI6d5Jyu66Eu/aVgwmiTWvn/lGGx2q4tB3FPpGByAvo6WzJOMauUSCIz84wOZ/L6P25oWEu4OkIgUysoAkxhE8TpZ84gaWv2clcrpA388PEJ0UsTgN5KOzL06SUaL8ijoMvxtDS0uY64tZ9JFVhCbyWA/FsWxZROuGUlpvqmP0sU4oyAS3dzL6yz0Eti6m/m0bWfOddxE8Nok94MQRuPzKE/sWVbLiM7cBYCma2SZ8LoGHki8gCCAaz+9jQA7GyE9GUNM5sgPj8x5zpnGZKkqo+dw9FIJRLG2nsmj+JRU03rmEbDBF3U3t5zVGRVbY/42dTB8Zp3J9De1vWIxzWSPpnhG8W5a+rMADZtaMlG09VQ+mb2+InT8eoKjaToklg8EA+Uga0WPCU+9BMBpRozGE6hqKr7uC8QGZOr8Vcc8UqYgXoyFC7MgwwWeOkzw6gBZOkAslGf31PtwbF+Oq8yMaRNLjUf5wEmimor0Aooggnipv/8dyKZlcqoCz2PKKB6mvRnrm4+LRgw/dOTNYTSz9yGYiXVN4W0sxWGZ/w0p1jxJ69hhKKsvkb3fjXds6635PtRuT10EmlEUqZMimQmC1oJbVEAvJpKZSlF3RwNULyzn+4yPEh6L42/z4F5WRCMuMHAhStbKUq75yG/0/34fJaaF4TT2ZaJZd3z1MZM8JPJYsNTctZOVb2xg9ME1RicT09i5MJW42fWQpWi5P/Ik97P7LHcRzZkw+B/bUNJIE8c6ZNRNGq5GylZVcDCd2hzj06CSV7S5W3VbxsrdGvhh0nKtY1zhd//0sgkGk7f1X4ah++dUxrY0VFN2whnTPCP5b1p3TY1VVY/JYENFooGRx06wLosFsoOXu5S97XH8o2htidHsf+ZTM2K5hWu9aTNVf3YmSyiI559aYebkOPTjKWEeUqQOjxH1pcomZqUZUDXeZneqrGum/9wmi+8coRBJc9bW3MPxUDyM/H8CckjE0uVHCaZALpMfjFC2uINYfRjOaSY+EKVpZh8lppviFqakXmYpc1L3/BpI947iX1s0bUManMjz+xcMkQ1lW3FXPgq3z1zTRnaIHHxePHnzoXhZ7mRt72fy7BMxlPgSblejhUXJGB3XRFGbP7G2MkakcacmONxdDLOSRNAmz30Ll2iocgZkLaiqYZfJEgnxaw5ozMvXYGIPPj2O0Smz40DJqVgdovWczUyfiyDL0PHyCjh8fxDg6iOw3YTDAyn9rpW5dObv//pf0/uoY+bxG1V1r0BIpMs8fQ8nkkbMigpzHUmPHUuqi8tYV872sOVRF5dBPu5nqDNN2Yx3Vq89unl1VVLb/aIiJngQTPQnqlnkoqbswjenOVnDfINGjowiSSPjQ8EsGH5qm0b19mvGuGE3ri6lo95y8TzQaCLxl/jUTL6X7sUEe/cxO5KzKlo+tZPnrT62vmDgWJNQToWxpCb7a+X/XziQ6liKbkLE7BQ59+3kSg2FMbivla6ow2k0IgnCyZ82FoGkaZi0LI6OQjBIPaUhOC55yN4HFpbTetZjAinL6vv0o2WAKVRPITsVJTyZRcwVEVUVze6i7oZ7o/n6s5V7q3nkNBcFMrHMcT1s5Cz9xE+JpdrO4FtbgWnj6rdzTvXEmuqMoeZWhfUE9+NBdUnrwoTsvmqYRfvowqY4hvFcuwLm4HnOxm6TgIhKG6J5ROr76OEv/8TWzHtd6QwNDz42hdhUwEMUWcLH0H6+hbEvbyZ0HA4/3MLGth9C0St+uKWxCGns2AoEAcmam/8i273ZxYtsEnjIzwtAghe4BRDmFWOzDUVOEyf3CWhTRQDaeQxEMHP9FN/l0Hnc2S0mtDadFxp4YxKEEqH7dFjxrT7/A8A+F+2Mc/30fmUiObDxP1arAWaWyBVHAV2ElNJTGWWTG5pl/F8fF5G4JYK8tQjSIuBpLXvL4yFiGZ+/rJTqWYawzzt2fX4ZkePml4l80cmCaUF8cVdE4+tu+k8FHKpTh+W8cIDIQJbCwmOs+u2FWAbRCNIGayWEMFM37nk+diPHoF4+QTco0L7WRGIxg89spXlrOorevuChTDtGBKJn+CWxCGkEqYC92Yi5yULG6gsbrm/C0loKiUnb9EgqKiK26CJPbRvNdS4n1R0hOJGh/63KaXtPO5JNHiezqIbKri/a/2kpqKIyzvvi0gcfZCLS4qVxcRHI6Q9MGfUHq2dAzHxePHnzozkkulmHqwCj2Mhe+lhJyo0GGv/comaEgqe5RWv7j3YgGCXOxCwxGBEmYt+ZH/eYa7vqhh0J6K9neUZLDEfq+v53Y/j6aPrCVQkYm8swRpMlRbHkTqsFBINyNU0hhMeSpXOBGVTWmemJkE3miagFXIo3JpGGw2ynd1Ez1XevIxnMYrSrt799IcFwmOpVl8kCM3LRMxuTGLllwK0FERSY5GmXy4ATuNW1ndXGyei04/DYKWQVvjeusL2iCILD1vQ20byqhqNKKw3vhgo/UdIpgdxh/sw978em/1ftX1OKo9iFIImbfS2ddjGYRk1VCNAiY7YaZdQUXQPM11Rz9bT+5VIGK5TO7iSL9EQafGyEbSYMKqjK7AFp2cIKxL/0fSipNyZuvw7157tRMdCxNbCKDklfJKh4Cq6tJjcVovHXBefXXedH44SmCRycwRSawF1kpvXEFonHm/XGWubB7fDRdX09xSxF9//schz/fjc0uYDCKlN+6itK19Vj8DqxFVkZ/upPyKpGEIBB5Yh/BMjMj9z9L5In9SFYjoqBRcdeG8x6z3Wfhpn9YTiGvYLbri1HPhh58XDx68KE7J0fv28PwU73YSp2s/furEVSY6ggjT0QouIpofeGitPST12PxWRE1jfo3r2XyyaPkw0mKN7VjKZ7pivpiKj1d6mD3df9FpnuYkSe68a5uwl5dhNEI/kYv5aVeXJsXITw6gSkZwdZSRCGvEn78KA32CYylRso2NRMoreHIVwuYLBK2hnK2/fsOsoNBXMUmKrc0cvV/3czokQjDn9hNNjOMYFExOSRkrZh4UCCRdNG7PYdzQ4TyBb6XfC/sRVau+ttVxEaTlLS+9PF/yOIw0rjq3B7zUuRsgee+vIup40FK2v1s/qeNc9rezxpD8fzdaefj9Fu47sOtTPcnqV7ivWDlu6tXlvKW+68nPpmhYpEPOSOz6+t7me4IYXabWfz6VmrXV8wqgJbtGyM7MIYmK6SO9c8bfFQuKaJpY4BUKMeiW2oJtCxBVTSm9w1x8D+fpGRlDeVXNsx5XLw/yMijx7FXeKi6YeG8Rc2SUyl2fmM/yb2duOIjFLf4EC0mPMvrqWCcrD1D61/dQsnqekYeOUpyMIQcipPNpbGVuQk918nCf7oTgNFf7Wb8wf1kpxMUCgKCzcKxz/wCeWAMLZtDE0GeigIzVXNjhwbQNPAsrX1ZQdSLJed1uktNDz505yQXyaAWFORUDjmVB4OBdEUTsuRDCpzaqWD22FnyiRsBiBwcoO/ep8iHk0zt7KXlwzfgqDp14ZXTMtGEADnICgJD/XlqilSqbllCsi9I+TVt+JfXkN5cQurYAHlnEY/+8w6E7dvweKB1XQOtr78OyWykelMdhYzM0Z92EB/qJ3NiEi1px2AbpOE1i6hZWcyKN7XT9ZSbBRv9VJbm6fnVcYaCRuJJA7ZwgWw8f9bvh7PUjrP0wq0bOB+FbIF0OIMqK6TDGQrZwrzBR3Y8TKpvEmdrBaaisw9AAk0uAk1nf/zZKqp1UVQ7c958amaBpqqoWL0WFt7WhMVtmXW8fWEdjqXNFGJJXFcsnvecNreJrX81uyuxksrS+YNdJAbCRDon8S0ow+Kdvdj0xI/3MLmjD6PLgqOmiKJFFXPOrSoakZEk+aiMQxCQzEYki5Ho/j4K41NIqkZ+YBxtVR2e1gBFy2vITceQMmnQVDwLT621MHkdGN02BIOEZrYgxzMoiRSS3425zIlnQRWlt6wGILitg/7vPIamQd27r6Fky8y25PTgFBMP7sdc7KLsNavPe/eS7hQ983Hx6L+lunPS9qbl2EqdOKs8+FqKURWN6psXM/p0N94KK4n+IK6G2WsIBHGmgFdiOEJ0PE06b2TFP9xwsvy0q9JFyZ2b6PnJIQzFbgZ3jNL3cC8VK8u44mPXnfyWbWuswNZYQcfDA4SHktjTKjmTimg2npwGMFhNGKwmqq+sJtQdJGFSsLkM+BeUYSmyI4cTNPuCtL3DSyQlMdKZIpXUyEczaLEC5noPJRfhAvtKsHosLHnjQoZ3jlK5pgKrxzLnmEIyw4kv/YZUzxjuJXU0/+Nd57WO4EIz2U2sfM8yJg5NUrKwZE7gAWAs9lL1T29HU9RzqmVRKICiGWammtxWJPPcjz+Ty4poFDHaTRjt80+HxSazZBUTKVcZFYvraHhHG751zSQ6R7FW+UHTsFb56fmvB0l0j1F203IC191MIZVDjqawVZ1a3Ovf0IrxhY7OjuYA/T/bR+eXH8RoN7P4c2/A1Rxg8Od7kbOHcfgtyIksaBpyNHXyHKO/2EXwicOINjO2mmK8q869caFufnrwcfHowYfunHibivE2nSp/LYnQdlsL6X0dRHf30JlOs/Jzt8/69uVeVE3DPdeQ+tLjZBIFcpEU+VjmZPAhCALXfGwp4vgYqcEgqSMR8PkI90YoZAuYbLMvMGWL/ASWl5MvNVKz1k3trYvnfNsrWVDCtf++FU1RyATTWIsdSEaJEz9+nolHD1NAYlIpJitYkHIyksmAvdSCt8KOVpjdZO7VpHZjDbUbT7/joZDKIUeSqHKBXDCOJhfgheCjMDFN6pePItqt2O+4HtF+4bagnovShSWULpwdwOYiKUYeOoJkkqi8aQkGq+mcanPkMwUe/moP41MeKup9LP7wcoy2ucFF81vW4G0vw1rixFU/f2t6URKwFdsRTCZca6rwb1oAgHtxLW2ffv1McBDLEN59AjmWZvLRw5TduByT24bphUAjn8wx/GgHANXXtWG0m9E0jUh/HM1fiozK5I4TjPzuAL0/2YuSlglcu5DKm5YjAP6Np+qemLx2RLMBg9OK4QxdonXnTg8+Lh49+NCdN+H0NY1euF+g+MpWljjsDD/SgbupGFf97MqfhVgaYyGD2QKiZMBc48Ampun54U7q71hGriBx9IlJHEVmFl1Tyg3/sg5V0eZMKyiycnJXhCiJIIk4yk9t0xReuE2SDBglI3LBQMN1CyiqcTLdHaFiZRmOy2Qa5WIwl7ipeP0GYvt7Kdq4AMl6qjx85qGnyTz4FILRgKEygPWquZ1lL5WRh4/Q96NdSCYJk9dO+dXnVnQsPp1jsjcx02hOtmPyzS4aJ0cSZAYmsTWWU7Gl5YznKl/oY+P7FpAK5ai/YnZfHEupBwDJbsHRVEZ6cBrvivo5i5HHnu6m6we7QBCQTBLV17fT+72niT53BPICgiIz+cgBCskcSjiBlskS2dnN6s/fgTXgmXWuiruuwN4QwORz4GiZO02k012O9OBDd94sfidt79tM/MQURcuqTzvn7F9ahX/pzHy3msuTD6VmmnoJAhQK2NxGBM1C410rGNs5RM/9h5l40ohkMzEQ9XL4kQksDglXsZn6FT6kP0iIaJpGx48OcuJ3HRgtBpa8by3lq6rnjKHmDeuxVxdhKnKien2kptJULC/F7DTTdlHencuLIAiUXLOEkmuWzLlP9LoRrRawWhBdr2zdkfkM7Asy3hWjdoUfg9WEZDbM/HuhqJ32whaYs9ll5Kuw0rqhhMGDERZeW4bJ8kK2JyuDUmDgi78g1TWMY0k99X979xmnogRBoH7dmZvxGZ1WWj/xGvKhBNbyuQuLRaN08u9ENBlIj4SZ2t6NQRLwVNhx1hYRPzyIpcRFIa+QHYtgK7KSHgqeDD40TWNs9wjZaJbKdfU+oOtqAAAjk0lEQVSYXXOnqF7KpSjH/2qiZz4uHj340F0QvsVV+BafXdGiQjLD8Jd+RmZwkqIbVlF041qOfeUJksdHsdf4qdxcz6Hv70eRVTRNppBVMFkkJKOAwSyR6Ryk98BBfCvr8b7QxTM1mWTP13cR3j8Imkrw2AS3/uytuKs8ZOJ5EtNZimocTA+kONGpULrAQOu6IoS2C9975dXKdtMWpEAxgtWCaXHrSz/gIkoEszzz390EB1IM7A1x+z8vxuS2IpqNFK+pJ3ligv7vPYloMdFwzzUnMw6nI0oim9/ZgKpoSAYRJZvn6Le2MbZzGG+LH9tIECWTIzcSRM3kEC9A1VODzYzBZkZVVIYPhpAzMrlkgeJ6FxVbmhGNEggCZVfUoxUUnA2loIF/XSOuVS3Y6gP4WkspZPIM/HAb1jIvjsZTQc/UkUn2fWMX2ViO2FCUha9rx2A3n9WC01wix4H/3ktqPM6CNy0lsFSv+zEfPfi4ePTgQ/eKyw5NkTw+iJJIE3n2KN3HZbp/cgQtlcE2lGDg8RM0v24ZnQo4A3aaXr+cek2iqNqGWcyT+NmjBIeCxA4P4vz8GzHYzCSmMiTDOVRZQRQgG0wRG0lidNl48POHiQwnad4YINYxxnR3hPH942R6hkhGFTwrGmi7tgqj+fJZeHkpCEYjlrXLLvrzZJMyPTumMDuMNK4rnnfbrigJiAYRURIwmEQMNhNlW07lpoLPdRE9MIBgkIisaqDshpcetyAISIaZ5xr46R66v/kE+XSBXKyOhTe1oY5P4du8GMPLCDxm1mtEAfDWeU5mEzRNY9u3jnHgVwPEp3LYPGYqFnm5+Z9XYHJbyUXSKLkCRpuJknUNOKu9yIEKtn37OKIksrbNgjwZJKNZoGBEkU+tR1JlhUJOQSuoRPf3sXfvUexVPto/vHVWh9/5BI9NMbx9ACWn0PdIjx586F5xevChe8VZa0txLKknenSEgQkTfb8/SCElIBYMSBY3ibEky9+/jrprGjC7zCfXcCy5rgw5keHog2YEg4hkMyO8kB53ljko29zGhKaipbJknH6evq+PZbdBaDBBJiYzejxCaYmNcH8MMTTNie8fJzKZQ2uawmA20H7txenj8mql5vJkByYwlRW9rDLkp5sW2ferIfb+fAiTTcJgEqlfNTf7ZPeaueaDrUz2JKhc7MXwR7Up7LXFWMo8iCYD9pr5F4aeSS6SwmQ3oeQUHAEHVW/ZgvmFaripoSATDx/CXOKi/OblZ7UbaHT3KHu/vQ+A5e9chmQ1YbRI5HMqB3/UQag3Th4Jg1kiny4wfWiUvv99nnwsS2IwTOkCPwP/8xTx7kmSspG4oRTJ72Hoiwcp9I+SU83k62qJn5jCVjqzG6t0SYAlb19GJpQm8fxRUsMR8pE0if7gS2YhnRVOXJVuspEMRc0vv6/Pnzo983Hx6MGH7rwN7RxlePc4lSsD1KyfewHXNI3Jrij5ZJ6KJX4km4Waj9/N8x95np4nhrAlIpgdDiS3jbIra6ne3IAgCNiK5n4DNTqtNH3oehLd47gXViG90FHXUWzj2k9dweTdbTz42b1MdkRJHZxm2W11NF0ZYKIzyvLX1FK9xI2nyEDyiMxUNASCCBeg4uWfGk3TGPvWb4jvOo61oYLqv30jkv3sd1Jke4YI3vtrRJuF4vfegbHk1LoHJa+iFlTUgjjrm/wfK2v1UNbqmfc+/4Y2bDXFiCYD1jLvWY/rRdWvWY4gCGiiRP0bVp8MPACGf/o8U08dx+CwYK/x411Wd4YzzYiPJkhOpkAQ6H6wl2BfFIPFQNW6KqxOAzavkYp6H43X1FC11I/dLqNkZFS5QCGdR1NU5FSOzFQcwe7AJiXxVhVjmk4jWkUKWQXnokrcLaemXUSDRMP1M+Xohxwqw7/NY6/w4qh96alEV5WHK/9xC7lYFm/9ub9/fy704OPi0YMP3XnJxnPs//4RIoPxk5U1zS4zE4enEESB0oXFTBwL8dR/HiKXlFl+dxNLX9tAMpyn72CCUEhEc5ez4cPNLLirHYff9pKVGx11JTjq5vYjcZbamToexDHUiSEVR6OFutXFLLy+Ek3VECWRib3DTG7rJjkaxVbpo3lrLf51zTRtPJV2zsZzDDw9gNFmpHZz7QXpYfJqo+Vl0t3DKLEU2aFJ5FD8nIKP5I5DZA73IBgk0vsX4L7+1M6Z5a+pwmw3YHEaqZsn63E2BEF4WRmPFzlq/LT95fzN8IwuG6LJgMFuRrKZ5z0GIBVM0/HLTkSjSNW6SqrWz2QbjE4z+UNTFDIFnAEby17fQjaeZ/FrG3FXzOyyUQsKzW9ZRS6UouraVqzFDkqvXUxyMIRmsVD/2sW0f3Az498zke4dp+HGNfi2LJnV3+YPVd26jJIrmjA6LUjms6t9Yi+2n7EEv053MenBh+68SCYJi8eCNJbE4jZjMEv0PzPEnu8eQhAF1tyzFFkRSUdyKHmVVDALgCKrlNTZUXIFyts9rHrvCqTTpLczU/GZwk2lbuSJIKF7f4VWUCh6x62YqmfPVZvzcdxSEru7QOUKI46imR0AgjTz7aOQLZCLZYn1R8hELHgXqyy8oWpWwNP1my6O/fQ4RqsRo81I9fo/v+6fotlE0S3riTy8G8eyZswV5xYkmOsrZpq+mU2Yamb/jBxFFtbc/dLZhNNJDEcIHhjGVe+naGH5GY8t5BXknIrVefbFyKrfcAXOpgCmIifO5tOvheh7oo+u33QhSgLOgINNfz/TfyVyIohaUDA5LNRvrsHimhvAiAaJuptnV2CVQwns5R6QRCqvbsZot1L1wdeApr1kQC4IAha/k+DRcbr/bz/2Mhftb1uN0X764En30vTMx8WjBx+682K0GFj/oZUEu0L4m30YrUYy4QzZWA5BEshEstRfVcuCm2rJxvO0XT+z/dVTbmPL+1qZOhGnYW3xaQOP8OFhjn/jadA0Wu/ZhHFkgNTzh9FUDUtbHabqMhRZYezQNCabAU9LKTVb6slH09RcP7deQ9nqKhpvW0AunkU0iBTSMpqG/vEwj6Lr1+C7bvXL2orp2LAMU00ZotmIMXDhdhSpisrRb20neHAEZ7WX1Z++6WSxuj+WCGZ55D87SYRyrH9jHS0bXrp7L4DRYaFk84KXPM7itmC0G5EMImbnTMGy0M5uhn74DF6vg8a33Ih5nsDjtOcr92Kwm7GUuk9upxVeqojOHxl88DjTB0YJH5+kdEUVgTW1aJpG7NgIuXCKopV1GM6QzdHNpgcfF48efOjOm6vMgavsVF2I2o3VxCdSiKJAzRWVmO1G1r9zdlEoQRBoWl9C0/ozXxDivdOkhsOgaSR6pyltKMEQ8IOqYqyc6YJ6/Hd9HPxxBya7iQ0fXs7CT92JHM/gqJ97bslkYOFfrMbbXEz0RJCydbVzmoe13NqC2WXGZDdSsfrPu2jTy60BIQgC5pqz30EhJ7NkpxPYq3wvucBTUxRQVTRl5t/pjHcnGD4aRZFVep6bOuvg42zVX1OP1WtBNEoEls6sxQjt6CTVP0VmJESicxRzsfslznJK7Vs24V1Wh7nEja1y7iJQTdNIDIYw2YxYSuY/r7POh+ngKBavFVtgZmFqvGucji8/jBxNUX7zMhrfsellvFqd7sLSgw/dBecotrH+AysuyLmKltfgW9KPpmoUrajBVl9M2T++C01RMdXNBAbpYJp8qoAqa2QiWSxLSk774QwzF8bKDfVUbqif936Ly0zrrWeucvlqlYlm6XqoD6NFovn6eozWS99aPZ/IcuTfHyIxGKJsUwst7zx9+3hRElnw7iuY2jOIq6EYe9npf86ljU7K29wkQznqV1/4ei6SQaRyzewF1t4V9SS6RjG67dgbz237qmQ14VvVOO99qqKy7dNPMvaz53CVO1j3xTvwLZlbRr/x9sUULSjD7LGerOxbSGYpJDIouQJyNH1OY/pzp2c+Lh49+NBd1pw1RSz88NXkp2I4qmZW5ZtqZs/zt1xfRz5dwOwyUbXqzJUn/9x1P9zHoQeOIZkkzC4zjVfXvuxzaYUCiOLLau3+hzITMeJ90+SjGcKHhtFU9YzndDcU42546cWm7hILt//TInJpBYdv/iZxF5p/0wJcC6qQbGYM9nka+2Vlun7dQT6eo+mWVhwBJ5qmkQmlMbstp11QmpzOMPpsL4XpKLFkisixsXmDD9EgUdQ++2/Au6SamrvXkp2KU37j0gvyOv98nH/woU/qzk8PPnSXtVwwzol//wW58QjF1yyh5i+umXOMp8rFhg+fyrRERxLERhKUthfNu9jvYsqdGEIensSytAWD9/LrjmuwGJBMEpJ5pubEy5U62sfU936P5LIReP9rMZW8/O2ajpoiStc3Eu0Yp/LGRecdzPwhk9WAyXp+H3OR0RT7ftaH2WZg5d0NWF2nD2QEQTjjVMvY7hE6fnIUJa8giAJL37mSjh8dZOjJE3ib/Kz48JUYLHOzUTafhaLV9QSDIRwBOyXr58+QzEc0Gqi+Y/VZH687ReP8MxfahRnKnxw9+NBd1nKTUbKjYZRkhmT3GACp6RSThyZw13goapo9N54KZXj2/+0iOpygel05V7xvMZLF9Iq0jZcngkx/+X+RR6ewr1tC8d+8/bLrm9F8fT0Wl2mmmdm6l7+eJbHjMOnOwZmttIdPYLpm1cs+l2Qy0Pb+LWgF5axKg7/SOh4fofOxESSjiL/OSds1L12MTlNVeh4+QaQ3Qv3VdRS3z6w3MTrMmBwm5FQek8uMWlAY3TFAajxBIVsgMRrH2zB3vYfBJHH1Z7YQvWcl7goHxj/ob6Mp6gX5/Q7v6mbyof04WiupfN26c+oarNOdq8vvL133qpeLZZDMhnm/wZ0rW0MAS0MFqf5JSm9cgaZp7PvWbsb2jOGqcrP4TYuQU3mKGj1owTBZzUwmmkPJKUT3nOBg3xGsZV7q37YBc8B7VjUQ1ILC6LY+lKxMxcaGs96uqKYyqMkMWr5AIRI/35d+URgtBhquqj3v81hbazDt7kC0WzHXnXm765lomkZ6OoXZbcFgvjw/jhx+C2aHEaPVgM17dr8Lkb4Ix358lHQwTWI0ztX/dg2CIBBYVsaqD68nNZFANEokxhJUXlnLYL6Ar7kYZ8Xps2UGswF/w6kMUz6R5ei3tpMci9H8hpUEVs+dhkkNTjNw/w5Eq4Wa16/FVuaZ99yaqjLyfztIdo+S7J3Au7IBxzmuWflTpK/5uHguz7923avW6I5+Ov53LxaPlWUf2YS9dO42SCUnM/ZMD5oG5ZuazhikBA+PMz4ko8guYkGZIk0jn8ijFlSyoRQHvvk8+WiWovwYHoeMpbqU9q3rCI5ksQx0khkKkjo6QPZgB672amr/6jZMRWeeDhnfOcjRbz9HIVcgn8jRfNfZ9Tsx1VfieeMN5HuHcWxZddllPS4k18alWBorES0mjEVnv6Pjj3X+/Ch9D3XjrvGw6q+uxOy8/LaBLriuCk+ZHYNFoqzNc1aPMTlMmJxmcvEcNr/t5O+CIAgElgbY9q89jO0dw13jYdM/baT2upkdVueSwQh3TDK+cwAlW2D40c45wYcqFzj+2Z8z9tAhMBjJJbIs/afb5j+ZIGCr9pMZDmIpcWPyXfquxpcDPfi4ePTgQ3dBTewaJDEYITUWJ9I1dTL4UAsK48/2oGRlCnmFnv/djaaBpqjU3LjwtOcrpHLIqTxqXiGfyCGIIkvesZzhbYOYnUYGHu1CjsRJ9fdjKDEh2cw0XlHKotoAYw+ZGPl5lnwyhpJIkzg2SKpn7CWDD01RURUVTVXR1LOfsRUEAdd161/6wD8BgiBgrnj5FUZfNLpjiNREAjmVJzEcxdxeegFGd2FJBpHq5ee2W8YRcLLur9cRH4kTWDL7NamKRjqURnnhd1pOF3BXnXsA56zy4KotIhtMUrRwniyFBmpBe2HhgnbGciGCIFD7nq34N7ZjqSjC5Ju/dopOd6HowYfuggqsribSPY3ZY8HbfOriNLmzn+Pf2Y6ak3G3BGYu6hoveXEvXVNL42SCQipPzQ0ztUKK24opbitG0zQcAQfHvvQIWqaUbD5J2fI2LNUz8+tl1y/Ft7yO+N4eJn/zPCa/66y2P5atq6WQzlPIFqi6quk83g3dS6nZUoeczuOu8+KuPftFq5qioA4MIXg9iL5L25tE0zSmjk6RDqYpX1l+Mnvja/Dha/DNOXa6L0Hlxgbc1R6KFxTjqjy3hcmapqFkZRRZwVLixF7hoera5jnHiSYDbX97K/b6UiS7hbq3XHnG8xpsZjzLG85pLH/q9MzHxaMHH7oLquLKeooWlmEwSxisp3YFaKo2UxhK1fC0lRK4shE0jYqrzlxPw2gz0fL6+WuGCIJAzZYGMicWMvqogLXESeCujSd3SwiCgKXUg+WmVXjXtyJazUiWl95yKZkM1N7Q/pLH6c5f4y1tVG+ux2gzntOUQ+7nvyP/20cQS/zY/uaDiKUXtoDYuQj3hNj1XzvJhDI03tDIivesPO2xfc9Psv07xwG48j3tNKw/t63hmqZx4gfPMbWzj2xaIRHMYbAYKV1VTcWGuYGDq6WChf/42nN7QbqT9ODj4tGDD90FZ/HMbUBWuraOQjqPkslTflXrrC6i56vxzWspWlaNtcSJvWL+b8FG7+WfRtY0jfCvniWx8xiuzcvx3bD2Ug/pohMEAbNrbj2Ml6Ic70KNRNGyOZTRiUsafMhpmXwyjyIrZGO5Mx6bmMyQfKG/UXzi3At+5cIpJrb1kB6PIWcKSA4nZrcFk9tCIZlBslv+pNca6f506MGH7hUhmQxUX//S/TLmo2ayZHfsQzCbsKxfPmcLoMFqonhl7QUY5aUlT0cJ/+455MkwhVgK1xWLMLj0rqPzMd1wNVo8gVhdgaH17GteXAwlC0tY+IaFpCZTNFx35rHUrStl6kQUgPpzzHoAmDw2PAvKUfMKgYXlFF/RgsltIX2wh5FvdOBeWkvdu6/Vt8leIHrm4+LRgw/dJaMND0NnJ7S1IVSevnZC6uFtJP731wgmIx7AuuHl15S4nBlcNkyVJSiJNOaqkjO2c/9zZ1yzAsOqZSAIl/ybvmiQaH1N21kd6w7Y2Prxs9s9Ne9zSSLtH7iKzEQMa8CNZDJQSGYY/upxMiMh1KxM2a2rsZb7XvpkupekBx8Xjx586C4JLZ2Gr35lJvhobUP79KcRrFbkVA40DaPjVCpey+XR5AKgkRoOM/XgUbxtAVx1F75fx6UkWsxU/PXd5AYnsNSXIxj0P88zuZCVUM9HJpwm0hPE21iEtejiZqrCR0YIHxnBt7gKR/VMMTLJbsG9pBYlJ+Nsr8Tsv/ynGHU6/dNNd2nIMiRTIBcglQRZJj4ap+PrT6IpKi33bMa7YKYCp/36DQiCgILAsecixHp7cTeXsPoztxDsjXH4/zpwljtY+Y7FmGyXvlHa+TC4HRgWX9pphFfC0J4JJjtCVK0MEGifW9Hz1ULJF9j7n9uZPjqJv72E9f9w1QUprjeffDxD53eeId4zhbu5j5X/+lqMDsvJbbJlr1mNudiFaHp1/w1cTvTMx8VzeXx10P3ZEdxuePvb4fbb4B1/geByETk2Rqx7gljPJJEjIyePlTwunHffiO3GLaiqgFpQUXIFNEWl68Fexg9N0ffkIJNHpy/Z69GdveR0ml3fPcKBH3Wx67+PUMgVLvWQXrZCpkBqKomSK5CeSiKn5Yv2XIIoIBokBElEMIgI4qmLmmiQMJe4kRNZNE3vJnKhvBh8nO8/3Vx65kN3ySiLlzE0APKBFFWVMTzt5bibStEUFe/CuX1HTE4Lbe+6guChEfyLKzC5rPjqPUwcnsLqs+IM6IszXw1Eg4hkkhAlAYNFmnURfbUxuy203b2E0R0DlK+txuK9cLu4/pjRYaH9A1uIHB/Hu6Acwx+sCSqkc3T+18Mke6cou24xNa9bc9HG8edEz3xcPHrwobtkgnv6GfjJHpTszLfFlndvYvlnXzuz5sM5/4e4f0kl/iWnFqcueG0LpQuLsXotuMr0ktCvBjavhQ0fWkawJ0LZ4uLTtpF/tajZ0kDNllemOJersRRX49wqsOmRMNEjI8ixNFPPdlJ9x6rLZk2MTjcfPfjQXTIGuxnDC03bjC/U/fjDhaZnQzKIlLb/aS08/XNQ3OSluOnSVib9U2KrKsK7uIpE7xQlG1v1wOMC0TMfF48efOgumaJl1bR/+FoKqRz+VXWXejg63auWwWqi7aM3IieymLz69OOFogcfF48efOguGUEQ8C+f2wZ8PtloBgQBi/vcq2HqdH8ORKMBs96NVvcqoQcfusve5OEJ9n9rN6IksPKDaylqOf9uqjqdTvdS9MzHxaMHH7rLXqhjmmh/GEEUCXYG9eBDp9O9IvTg4+LRgw/dZa9kSYCilmJEg0jJorkr/XU6nU736qIHH7rLnr+1mC3/thVB4KJVj9TpdLo/pmc+Lh49+NC9KhitetCh0+leWXrwcfHom8F1Op1Op9O9ovTMh06n0+l089AzHxePHnzodDqdTjevC9EYTg8+5qMHHzqdTqfTzUPj/DMXeo/h+elrPnQ6nU6n072i9MyHTqfT6XTz0Nd8XDx65kOn0+l0unm8GHyc779zcezYMV73utdRX1+PzWbD7/ezceNGfvvb357V46PRKO95z3soLi7GbrezZcsW9u/f/3Je/kWlZz50Op1Op7tMDA4OkkgkeNvb3kZ5eTnpdJqf//zn3HrrrXz729/mPe95z2kfq6oqN910E4cOHeLjH/84fr+fb3zjG2zevJl9+/bR1NT0Cr6SMxM0Tbvk62Hi8Thut5tYLIbL5brUw9HpdDrdy/Sn8Hn+4mv43N8OYTGf32vI5uL8/eerz+v9UBSFFStWkM1m6ezsPO1xP/nJT7j77rv56U9/yp133gnA9PQ0zc3N3HDDDTzwwAMv6/kvBn3aRafT6XS6eVyKaZf5SJJEVVUV0Wj0jMf97Gc/o7S0lNe+9rUnbysuLuauu+7i17/+Nblc7rzHcqHowYfuVUVT1Us9BJ1Opztn8Xh81r+XCgRSqRTBYJDe3l6+/OUv89BDD3H11Vef8TEHDhxg+fLliOLsS/vq1atJp9N0d3ef9+u4UPTgQ/eqkXx4G1Mf+Vei9/4MrVC41MPR6XR/4i5k5qOqqgq3233y37/927+d8bk/+tGPUlxcTGNjIx/72Me4/fbb+drXvnbGx4yPj1NWVjbn9hdvGxsbe5nvxIWnLzjVvSposkzyt09RGBhFicaxX70WY23lpR6WTqf7E3Yht9oODw/PWvNhNpvP+LiPfOQj3HnnnYyNjfGTn/wERVHI5/NnfEwmk5n3vBaL5eT9lws9+NC9OhgMmNsbUKNxjDUVSMW+Sz0inU6nO2sul+ucFpy2trbS2toKwFvf+la2bt3KLbfcwq5duxCE+QMiq9U673RONps9ef/lQg8+dK8KgiDgeffrsG+9AkPAj2i3Xeoh6XS6P3GXU5GxO++8k3vuuYfu7m5aWlrmPaasrIzx8fE5t794W3l5+QUZy4WgBx+6Vw3BZMLUVHuph6HT6f5MXE7Bx4tTJrFY7LTHLF26lG3btqGq6qxFp7t27cJms9Hc3HxBxnIh6AtOdTqdTqebx6XYajs1NTXnNlmW+cEPfoDVaqW9vR2YyWZ0dnYiy/LJ4+68804mJyf5xS9+cfK2YDDIT3/6U2655ZaXXGfyStIzHzqdTqfTXSbuuece4vE4GzdupKKigomJCe6//346Ozv54he/iMPhAOCTn/wk3//+9+nv76e2thaYCT7Wrl3LO97xDo4fP36ywqmiKHz605++hK9qLj340Ol0Op1uHpdi2uXuu+/m3nvv5Zvf/CahUAin08mKFSv4whe+wK233nrGx0qSxIMPPsjHP/5xvvKVr5DJZFi1ahX33XffadeJXCp6eXWdTqfTXTB/Cp/nL76Gf/zbqQtSXv0zny95Vb8fF4O+5kOn0+l0Ot0rSp920el0Op1uHpfTbpc/NXrwodPpdDrdPPTg4+LRp110Op1Op9O9ovTMh06n0+l089AzHxePHnzodDqdTjcPPfi4ePRpF51Op9PpdK8oPfOh0+l0Ot089MzHxXNZBB8v1jmLx+OXeCQ6nU6nOx8vfo5fBvUrz1sul+R8JwhmzqH7Y5dF8JFIJACoqqq6xCPR6XQ63YWQSCRwu92Xehgvi8lkIhAI8OUvX5hrUiAQwGQyXZBz/am4LMqrq6rK2NgYTqcTQdBTVDqdTvdqpWkaiUSC8vLyWW3dX22y2Sz5fP6CnMtkMmGxWC7Iuf5UXBbBh06n0+l0uj8fr96wVKfT6XQ63auSHnzodDqdTqd7RenBh06n0+l0uleUHnzodDqdTqd7RenBh06n0+l0uleUHnzodH/gvvvuQxCEk/8sFgvNzc188IMfZHJycs7xk5OTfOxjH6O1tRWbzYbdbmfFihV89rOfJRqNzvscq1evRhAEvvnNb57z+O69917a2tqwWCw0NTXx1a9+9ZzPodPpdJfaZVFkTKe73PzLv/wLdXV1ZLNZtm/fzje/+U0efPBBjh49is1mA2DPnj3ceOONJJNJ3vzmN7NixQoA9u7dy+c//3meffZZHn300Vnn7enpYc+ePdTW1nL//ffzvve976zH9O1vf5v3vve93HHHHfz1X/8127Zt40Mf+hDpdJpPfOITF+7F63Q63cWm6XS6k/7nf/5HA7Q9e/bMuv2v//qvNUB74IEHNE3TtEgkolVUVGilpaVaR0fHnPNMTExon/nMZ+bc/k//9E9aSUmJ9vOf/1wTBEHr7+8/q3Gl02mtqKhIu+mmm2bd/qY3vUmz2+1aOBw+y1eo0+l0l54+7aLTnYWrrroKgP7+fmAmCzE6OsqXvvQlWltb5xxfWlrKP/zDP8y5/YEHHuDOO+/k5ptvxu1288ADD5zV8z/11FOEQiHe//73z7r9Ax/4AKlUit///vfn+pJ0Op3uktGDD53uLPT29gJQVFQEwG9+8xusVit33nnnWZ9j165dnDhxgje84Q2YTCZe+9rXcv/995/VYw8cOADAypUrZ92+YsUKRFE8eb9Op9O9GujBh043j1gsRjAYZGRkhP/7v//jX/7lX7Bardx8880AdPz/9u4fJLU3juP455cVKRSkYJxCWsJqczKoSWvrzxD9ndwqKmhoCRpriYimCKGtIxEhUtQSLdHq4BAF0VxgBEGIKf35DZd7uaKmN36eLvzeLziDz/E853m2Dzxfzvf6Wl6v94+aRZmmKY/Ho56eHknSxMSErq6ulEgkSj57f38vm80mt9udM15bWyuXy6W7u7vyNwcA34yCU6CAvr6+nN+tra2KRCJqaWmR9KNteH19fdnzvb6+an9/X6FQ6FfzxGAwKLfbrUgkIp/P9+nz6XS6aNCpq6tTOp0uey0A8N0IH0ABW1tb8nq9qq6uVlNTk9rb23M6dDY0NOj5+bns+U5PT/Xw8CC/36/b29tf44FAQHt7e1pbW/u0A6jdbi/aYfPl5UV2u73stQDAdyN8AAX4/f68+orfdXR0KJFIKJvNlnX08rO2Y2xsrOD98/NzBQKBos8bhqG3tzclk8mco5dsNqvHx0c1NzeXXAMA/C2o+QC+YHBwUOl0WtFotOR/U6mUDg8PNT4+roODg7zLMIyShac/j2Xi8XjOeDwe1/v7e8ljGwD4mxA+gC+YmZmRYRhaXFzUzc1N3v1kMqnV1VVJUiwWUyqV0tzcnEZGRvKugYEBRaNRZTKZou8LBoNyOp15X0Xd3t6Ww+FQf3//f7tBAKggwgfwBY2NjYrFYspkMvL5fJqamlI4HFY4HNb09LTa2tp0cXEh6ceRi8vlUnd3d8G5hoaG9PT09Om3Oux2u1ZWVnR8fKzR0VHt7OwoFArJNE0tLy/L6XRWZJ8AUAnUfABf1NXVpcvLS62vr+vk5ES7u7uqqqpSZ2enlpaWND8/r2QyqbOzM01OTspmsxWcp7e3Vw6HQ6Zpanh4uOj7ZmdnVVNTo42NDR0dHcnj8Whzc1MLCwuV2iIAVMQ/Hx8fH9+9CAAA8P/BsQsAALAU4QMAAFiK8AEAACxF+AAAAJYifAAAAEsRPgAAgKUIHwAAwFKEDwAAYCnCBwAAsBThAwAAWIrwAQAALEX4AAAAlvoXDXRTW88tFx8AAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "*<span style=\"color:gray\">We are not looking for anything specific in the PCA plot of the gene expression embedding, but often we see clusters that correspond to different cell types.  If you see only a single large blob, then the dataset might contain only one cell type, or perhaps there are few counts per droplet.</span>*"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "# Summary of warnings:"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Back-tracking in training ELBO."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox5b decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Camk1d decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ak1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5g3 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cst3 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Tnnc2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5e decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb5 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufc1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps3a1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Gng5 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps20 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps8 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufs5 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5k decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rpl6 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Chchd2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5j2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rpl21 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufa4 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufa5 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cycs decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Gapdh decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Selenow decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox6b1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufc2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Aldoa decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Mylpf decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox6a2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox8b decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rplp2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ctsd decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Tnni2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Slc25a4 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufa13 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox4i1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rpl13 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Acta1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Hspa8 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox5a decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rplp1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox7a2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cisd1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Chchd10 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Gpx4 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5d decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufs7 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Uqcr11 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Uqcr10 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Pgam2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps27a decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Uqcrq decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ubb decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Nme2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5g1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rpl23 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Eif1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb1-ps decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5mpl decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Uqcrfs1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Uqcrb decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox7c decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps24 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Tpt1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Cox6c decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb9 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufa6 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5g2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb4 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rpl24 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5j decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5o decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Rps2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb10 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Hsp90ab1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Drap1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Fth1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb8 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Atp5md decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene Ndufb11 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Co1 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Co2 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Atp6 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Co3 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd3 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd4l decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd4 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd5 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Nd6 decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Expression of gene mt-Cytb decreases quite a bit"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "generate_summary_plots(input_file=input_file, \n",
     "                       output_file=output_file,\n",
@@ -111,7 +3080,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "cellbender",
    "language": "python",
    "name": "python3"
   },
@@ -125,7 +3094,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.9"
+   "version": "3.10.18"
   }
  },
  "nbformat": 4,
diff --git a/cellbender/remove_background/report.py b/cellbender/remove_background/report.py
index dfb5f90..cfd5c05 100644
--- a/cellbender/remove_background/report.py
+++ b/cellbender/remove_background/report.py
@@ -134,8 +134,8 @@ def generate_summary_plots(input_file: str,
     adata.var['n_removed'] = adata.var[f'n_{input_layer_key}'] - adata.var[f'n_{out_key}']
     adata.var['fraction_removed'] = adata.var['n_removed'] / (adata.var[f'n_{input_layer_key}'] + 1e-5)
     adata.var['fraction_remaining'] = adata.var[f'n_{out_key}'] / (adata.var[f'n_{input_layer_key}'] + 1e-5)
-    adata.var[f'n_{input_layer_key}_cells'] = np.array(adata.layers[input_layer_key][cells].sum(axis=0)).squeeze()
-    adata.var[f'n_{out_key}_cells'] = np.array(adata.layers[out_key][cells].sum(axis=0)).squeeze()
+    adata.var[f'n_{input_layer_key}_cells'] = np.array(adata.layers[input_layer_key][cells.values].sum(axis=0)).squeeze()
+    adata.var[f'n_{out_key}_cells'] = np.array(adata.layers[out_key][cells.values].sum(axis=0)).squeeze()
     adata.var['n_removed_cells'] = (adata.var[f'n_{input_layer_key}_cells']
                                     - adata.var[f'n_{out_key}_cells'])
     adata.var['fraction_removed_cells'] = (adata.var['n_removed_cells']
@@ -369,8 +369,8 @@ def plot_input_umi_curve(inputfile):
 def assess_overall_count_removal(adata, raw_full_adata, input_layer_key='raw', out_key='cellbender'):
     global warnings
     cells = (adata.obs['cell_probability'] > 0.5)
-    initial_counts = adata.layers[input_layer_key][cells].sum()
-    removed_counts = initial_counts - adata.layers[out_key][cells].sum()
+    initial_counts = adata.layers[input_layer_key][cells.values].sum()
+    removed_counts = initial_counts - adata.layers[out_key][cells.values].sum()
     removed_percentage = removed_counts / initial_counts * 100
     print(f'removed {removed_counts:.0f} counts from non-empty droplets')
     print(f'removed {removed_percentage:.2f}% of the counts in non-empty droplets')
@@ -775,7 +775,7 @@ def plot_counts_and_probs_per_cell(adata, input_layer_key='raw'):
     limit_to_features_analyzed = True
 
     if limit_to_features_analyzed:
-        var_logic = adata.var['cellbender_analyzed']
+        var_logic = adata.var['cellbender_analyzed'].values
     else:
         var_logic = ...