diff --git a/.gitignore b/.gitignore
index c8e3208..b508bca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,37 @@ __pycache__
 !datasets/placeholder.txt
 /results/*
 !results/placeholder.txt
-/only_local
\ No newline at end of file
+/only_local
+test.yaml
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1/Astigmatism_Tetraspeck_beads_2um_50nm_256_1_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1/Astigmatism_Tetraspeck_beads_2um_50nm_256_1_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1/comments.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1/DisplaySettings.json
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1_MMStack_Pos0.ome_3dcal.fig
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_1_MMStack_Pos0.ome_3dcal.mat
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_2/Astigmatism_Tetraspeck_beads_2um_50nm_256_2_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_2/Astigmatism_Tetraspeck_beads_2um_50nm_256_2_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_2/comments.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_2/DisplaySettings.json
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_3/Astigmatism_Tetraspeck_beads_2um_50nm_256_3_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_3/Astigmatism_Tetraspeck_beads_2um_50nm_256_3_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_3/comments.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_3/DisplaySettings.json
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_4/Astigmatism_Tetraspeck_beads_2um_50nm_256_4_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_4/Astigmatism_Tetraspeck_beads_2um_50nm_256_4_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_4/comments.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_4/DisplaySettings.json
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_5/Astigmatism_Tetraspeck_beads_2um_50nm_256_5_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_5/Astigmatism_Tetraspeck_beads_2um_50nm_256_5_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_5/comments.txt
+calibrate_mat/demo-fig3a/Astigmatism_Tetraspeck_beads_2um_50nm_256_5/DisplaySettings.json
+calibrate_mat/demo-fig3a/Parameter settings.jpg
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1/comments.txt
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1/DisplaySettings.json
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1_MMStack_Pos0.ome.tif
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1_MMStack_Pos0_metadata.txt
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1_MMStack_Pos0.ome_3dcal.fig
+calibrate_mat/demo-fig3d/DMO_6um_Crimson_645_beads_defoucs_0_step_100nm_1_MMStack_Pos0.ome_3dcal.mat
+calibrate_mat/demo-fig3d/Parameter settings.jpg
+test2.yaml
+Untitled5.ipynb
diff --git a/demo/demo-fig3a/liteloc_infer_demo_fig3a.py b/demo/demo-fig3a/liteloc_infer_demo_fig3a.py
index 52e7a2b..1caf2f8 100644
--- a/demo/demo-fig3a/liteloc_infer_demo_fig3a.py
+++ b/demo/demo-fig3a/liteloc_infer_demo_fig3a.py
@@ -10,11 +10,16 @@
 import time
 from network import multi_process
 from utils.help_utils import load_yaml_infer
+import argparse
 
 if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-p', '--infer_params_path', type=str, default='infer_params_demo_fig3a.yaml')
+    args = parser.parse_args()
 
-    yaml_file = 'infer_params_demo_fig3a.yaml'  # remember to change p probability
-    infer_params = load_yaml_infer(yaml_file)
+    # yaml_file = 'infer_params_demo_fig3a.yaml'  # remember to change p probability
+    infer_params = load_yaml_infer(args.infer_params_path)
 
     liteloc = torch.load(infer_params.Loc_Model.model_path)
 
diff --git a/demo/demo-fig3a/liteloc_train_demo_fig3a.py b/demo/demo-fig3a/liteloc_train_demo_fig3a.py
index c85cf94..74b7b76 100644
--- a/demo/demo-fig3a/liteloc_train_demo_fig3a.py
+++ b/demo/demo-fig3a/liteloc_train_demo_fig3a.py
@@ -12,7 +12,7 @@
     setup_seed(15)
 
     parser = argparse.ArgumentParser()
-    parser.add_argument('--train_params_path', type=str, default='train_params_demo_fig3a.yaml')
+    parser.add_argument('-p', '--train_params_path', type=str, default='train_params_demo_fig3a.yaml')
     args = parser.parse_args()
 
     params = load_yaml_train(args.train_params_path)
diff --git a/demo_description.ipynb b/demo_description.ipynb
new file mode 100644
index 0000000..06d948c
--- /dev/null
+++ b/demo_description.ipynb
@@ -0,0 +1,521 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "77e7ae20-5442-468e-835b-3ff15c4a5e39",
+   "metadata": {},
+   "source": [
+    "# User Guide for Training and Running Inference with the LiteLoc Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb48ceef-b864-487a-9544-20c1677ba69f",
+   "metadata": {},
+   "source": [
+    "This guide explains how to train and run inference with the LiteLoc model on your device, using your own parameters. Alternatively, you can use the provided demo dataset (available online) and the default parameters from the **.yaml** file to run the training process. Both training and inference should be executed in a Python environment with the dependencies listed in the provided **requirements.txt** file. For ease of setup, we recommend using **Anaconda** to create and manage the required environment."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c2e6e57-cd8f-4c24-86db-b9ca2684b4de",
+   "metadata": {},
+   "source": [
+    "* conda create -n liteloc_env python\n",
+    "* conda activate liteloc_env\n",
+    "* pip install -r requirments.txt\n",
+    "* conda install -c turagalab -c conda-forge spline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6fa27607-fabb-4cdb-8087-3519524bc7a6",
+   "metadata": {},
+   "source": [
+    "## Parameter setting\n",
+    "Before starting the training process, you need to initialize the parameters. These parameters can be divided into three categories:\n",
+    "1. Camera settings\n",
+    "2. PSF initialization\n",
+    "3. Training configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5bcc8105-b5e7-4bde-b329-dce2d0114d94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from utils.gui_utils import *\n",
+    "from utils.help_utils import *\n",
+    "params_dict = {}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "397065b8-0fa2-4ae1-ac11-66193b65f7f1",
+   "metadata": {},
+   "source": [
+    "_Camera settings :_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "556ebc48-7283-440e-a630-dfb7e4a0938b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_dict['Camera'] = Camera_GUI()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "98c08e3a-bcf8-4795-b185-39931e73d914",
+   "metadata": {},
+   "source": [
+    "_PSF initialization :_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "629ab0f9-8c79-4b74-a3e3-ac054a9e6d4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_dict['PSF_model'] = PSF_GUI()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30bae321-1d01-4133-ba28-c6536117758a",
+   "metadata": {},
+   "source": [
+    "_Training configuration :_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f89d5357-2fa0-4891-9e10-05f4dd4f32bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "params_dict['Training'] = Training_GUI()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f2f041a-e7cb-412c-bb15-143eb891b2e3",
+   "metadata": {},
+   "source": [
+    "All saved parameters for subsequent training will be converted to **types.SimpleNamespace** format for consistent access and management. These parameters can be saved and reloaded for future use.\n",
+    "1. Presenting and Transferring Parameter Data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "545671a6-f524-4fcb-aeef-9af0ed8f12a3",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--Camera :\n",
+      "camera : sCMOS\n",
+      "em_gain : 1.0\n",
+      "surp_p : 0.5\n",
+      "qe : 0.95\n",
+      "spurious_c : 0.002\n",
+      "sig_read : 1.535\n",
+      "e_per_adu : 0.7471\n",
+      "baseline : 100.0\n",
+      "--PSF_model :\n",
+      "z_scale : 700.0\n",
+      "simulate_method : spline\n",
+      "--spline_psf :\n",
+      "calibration_file : None\n",
+      "psf_extent : [[-0.5, 63.5], [-0.5, 63.5], None]\n",
+      "device_simulation : cuda\n",
+      "--vector_psf :\n",
+      "objstage0 : -500.0\n",
+      "zemit0 : None\n",
+      "zernikefit_file : None\n",
+      "pixelSizeX : 110\n",
+      "pixelSizeY : 110\n",
+      "psfSizeX : 51\n",
+      "NA : 1.5\n",
+      "wavelength : 680.0\n",
+      "refmed : 1.406\n",
+      "refcov : 1.524\n",
+      "refimm : 1.518\n",
+      "zernikefit_map : None\n",
+      "psfrescale : 0.5\n",
+      "Npupil : 64\n",
+      "--Training :\n",
+      "max_epoch : 50\n",
+      "eval_iteration : 500\n",
+      "batch_size : 16\n",
+      "valid_frame_num : 100\n",
+      "em_per_frame : 10\n",
+      "train_size : [64, 64]\n",
+      "photon_range : [4000, 40000]\n",
+      "result_path : None\n",
+      "infer_data : None\n",
+      "bg : None\n",
+      "perline_noise : True\n",
+      "pn_factor : 0.2\n",
+      "pn_res : 64\n",
+      "factor : None\n",
+      "offset : None\n",
+      "model_init : None\n",
+      "project_name : LiteLoc-main\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(show_confirming_string(params_dict))\n",
+    "\n",
+    "params = dict_to_namespace(params_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4e418af-4cb5-4346-8ce0-fcddb1971462",
+   "metadata": {},
+   "source": [
+    "2. Saving Parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "38b0d653-b7e2-473d-85b2-421218970940",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      " test2\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "File saved as : E:/Torch/LiteLoc\\test2.yaml\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Paramter save\n",
+    "\n",
+    "# import tkinter as tk\n",
+    "# from tkinter import filedialog\n",
+    "# import os\n",
+    "\n",
+    "# root = tk.Tk()\n",
+    "# root.withdraw()\n",
+    "\n",
+    "# top = tk.Toplevel(root)\n",
+    "# top.wm_attributes(\"-topmost\", 1)\n",
+    "# top.withdraw()\n",
+    "\n",
+    "# folder_path = filedialog.askdirectory(\n",
+    "#     title = \"Select folder path\",\n",
+    "#     initialdir = os.getcwd(),#os.path.join(os.getcwd(), 'demo'),\n",
+    "#     parent = top\n",
+    "# )\n",
+    "# root.destroy()\n",
+    "\n",
+    "# file_name = input()\n",
+    "# if file_name[-5:] != '.yaml':\n",
+    "#     file_name += '.yaml'\n",
+    "\n",
+    "\n",
+    "# yaml_file_path = os.path.join(folder_path, file_name)\n",
+    "\n",
+    "# print(\"Parameter file:\", yaml_file_path)\n",
+    "\n",
+    "\n",
+    "# import yaml\n",
+    "# with open(yaml_file_path, 'w') as yaml_file:\n",
+    "#     yaml.dump(params_dict, yaml_file, sort_keys=False, default_flow_style=False)\n",
+    "\n",
+    "yaml_file_folder = select_path('folder')\n",
+    "\n",
+    "file_name = input()\n",
+    "if file_name[-5:] != '.yaml': \n",
+    "    file_name += '.yaml'\n",
+    "    \n",
+    "yaml_file_path = os.path.join(yaml_file_folder, file_name)\n",
+    "save_yaml(params, yaml_file_path)\n",
+    "\n",
+    "print(\"File saved as : {}\".format(yaml_file_path))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "015b3347-362a-4b0b-8b91-af4f04031c39",
+   "metadata": {},
+   "source": [
+    "## Pre-train test:\n",
+    "To run the training code, you can either use the parameter file you defined earlier or the demo setting files listed below. To do so, execute the following code:\n",
+    " - demo/demo-fig3a/train_params_demo_fig3a.yaml\n",
+    " - demo/demo-fig3d/train_params_demo_fig3d.yaml\n",
+    " - demo/demo-uipsf/train_params_demo_uipsf.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7e8cb02f-14f5-4e93-b3b0-781294d3655e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "File selected :  E:/Torch/LiteLoc/demo/demo-fig3a/infer_params_demo_fig3a.yaml\n",
+      "--Loc_Model :\n",
+      "model_path : ../../results/liteloc_fig3a/checkpoint.pkl\n",
+      "--Multi_Process :\n",
+      "image_path : ../../datasets/NPC_U2OS_Astigmatism_PSF_640_40mw_20ms_256_2/\n",
+      "save_path : ../../datasets/NPC_U2OS_Astigmatism_PSF_640_40mw_20ms_256_2/liteloc_fig3a_result.csv\n",
+      "time_block_gb : 1\n",
+      "batch_size : 30\n",
+      "sub_fov_size : 256\n",
+      "over_cut : 8\n",
+      "multi_gpu : True\n",
+      "num_producers : 1\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# root = tk.Tk()\n",
+    "# root.withdraw()\n",
+    "\n",
+    "# top = tk.Toplevel(root)\n",
+    "# top.wm_attributes(\"-topmost\", 1)\n",
+    "# top.withdraw()\n",
+    "\n",
+    "# file_path = filedialog.askopenfilename(\n",
+    "#     title=\"Select file\",\n",
+    "#     initialdir=os.getcwd(),\n",
+    "#     parent=top,\n",
+    "#     filetypes=[\n",
+    "#         (\"All files\", \"*.*\"),\n",
+    "#         (\"Text files\", \"*.txt\"),\n",
+    "#         (\"Python files\", \"*.py\"),\n",
+    "#         (\"Image files\", \"*.jpg *.png *.gif\")\n",
+    "#     ]\n",
+    "# )\n",
+    "\n",
+    "# root.destroy()\n",
+    "\n",
+    "yaml_file_path = select_path('file')\n",
+    "\n",
+    "print(\"File selected : \", yaml_file_path)\n",
+    "\n",
+    "params= load_yaml_train(yaml_file_path)\n",
+    "print(show_confirming_string(namespace_to_dict(params)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "45fbaa27-4c7c-4b86-a477-921ba848a95a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# file_path ='demo/demo-fig3a/train_params_demo_fig3a.yaml'\n",
+    "# params= load_yaml_train(file_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d71bbc5-0d4a-4bff-877f-04a569d4bf1c",
+   "metadata": {},
+   "source": [
+    "### Viewing the Point Spread Function\n",
+    "You can examine the Point Spread Function (PSF) used for dataset simulation when training the LiteLoc model. The PSF is represented in three dimensions and displayed as a 21-channel 2D image stack."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "e934e633-2a96-4e8b-8c8d-a30b241e5af4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 21 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from utils.visual_utils import show_sample_psf\n",
+    "show_sample_psf(psf_pars=params.PSF_model, train_pars=params.Training)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "041ec868-f148-460d-bc36-d1b154a3c368",
+   "metadata": {},
+   "source": [
+    "### Displaying Simulated Images\n",
+    "Below are examples of the dataset simulation process. The ground truth of the lateral locations of emitters is shown at the top. The simulated images are then synthesized based on the random selected emitter locations and the 3D PSF presented above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "971a4e15-a156-444c-b4ee-bf05f7eac7b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn4AAAHrCAYAAABRk5ANAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZgV1Z3//666W+/dNNjd9AhIjBFcUIMGezSMCQyIJqORb2ZISCCRkYnTkFEy0S8ZRVwSEjWuQ2DM17g8A9H4e6KJmKCICi4tYhvGBYdRhwSMdBOB7qa3u9X5/dH2PZ9zbp3qut234dL1eT3PfZ57q+pUndo+Vfe8P4slhBBgGIZhGIZhRjz20e4AwzAMwzAMc2TgFz+GYRiGYZiAwC9+DMMwDMMwAYFf/BiGYRiGYQICv/gxDMMwDMMEBH7xYxiGYRiGCQj84scwDMMwDBMQ+MWPYRiGYRgmIPCLH8MwDMMwTEDgFz+GYRiGYZiAMGwvfqtXr8YJJ5yAoqIiTJs2Da+99tpwbYphGKagYPvHMEyhYg1Hrd5HH30UCxYswNq1azFt2jTcddddeOyxx7Br1y7U1NR4tnUcBx999BHKy8thWVa+u8YwIwohBA4fPoz6+nrYtv//cb29vUgkEgMuF41GUVRUNJQuBg62fwxzZGD7N0jEMPC5z31ONDY2Zn6n02lRX18vVq1aNWDbvXv3CgD84Q9/cvjs3bvX9/3Z09Mj6mpCvtZbV1cnenp6BmUHggrbP/7w58h+2P7lRhh5JpFIoLm5GcuXL89Ms20bM2fORFNTU9by8Xgc8Xg881t8MgA5vXguwlYEIpnOzLMiIaWtFfbR/RBpo/+DJu2tEvlWL2JRuT+1ZZnvPWPkdAAQZHVlf+7NfI/sOySX6eiU3/V/GIbBVpFIuvdfxyHthSO/W/Kfj0jJdVnhiLod0zy6Lg9EWp4buk3L9hipMPSNTlcXN69LOO7HT2nvdfwodDtkv/Rt2EXyGhBpcpwMbfTtWyG5HZEm66bbdwzToV7CQgApkcSLicdRXl4OvyQSCbTsT2N38wRUlJv/JXccdjBx6p+QSCRG5r/eYSBf9u/z0a8gbEWyTBZFpNLuMwz3kn4tKetKpkhzfyONpvuPtjfZCJeV+VuObofcW8p2TOvS7Rq1WfQ+NbSn9y4AIEJsJtm+8lyKxtw7D8CKkuUUW06+6xcAmafYH2UZapdS6qxeea3RZ4tIyOXosdTtl3KcDRjPi188rgX92kyJJF5M/5btX47k/cXv448/RjqdRm1trTK9trYW//3f/521/KpVq3DjjTdmd0yEEEYYgl54Ke0hHJM3Fb0JlBuPXChWRH3xUZHz0qXyIur6dEXme3edetGlybUQCcsfRZ2kn93kxnO0myjlfrMhLJejck/Wja50x3CzhD1efMjxUF/C3C+LrAcCeVlUXnZon/WHA91PW54/P4YX0IxS2L2N+uKl7ovygKPbdMg2bdlGCNVwWSnSH5u0J21geTzE0qaHEllGf8Ao7dUHjPVJu8HIgqVlfR/jpgZ+r2Y08mX/InYEYUv9o5n1JzBkOEH0/iN/Ii1NChP0BYPYTOODX3txEjD88aPb93qJo/MsOtnDflBod5TtGO4x7RYxvaBYkajrMlnHn9gMK0JsWWmJsY0oLZbfi8mfyIi7LbJ71Rc3p5jY3Jg8Z6F2OfBgd/XIBkntxc/ult975HIiRI+TxzGnx4zaWdM508+/Q68Z8mymzxJ6LrRnjmmbbP9y46hH9S5fvhzt7e2Zz969e492lxgmEKSQHvDDDC9s/xjm6BBk+5f3Eb8xY8YgFAqhtbVVmd7a2oq6urqs5WOxGGIx83A4wzDDQ1oIpD1iu7zmMe6w/WOYY4Mg27+8v/hFo1FMnToVmzdvxqWXXgqgL1Jt8+bNWLJkif8V2TZg2epQu+YvQGU7GGQLZXntRFLpV0Tl98RoKdv21Moh5O6TVB89KyyH5Lv3yzYlo+RwfrSrVG7jsPT3AwCk3GVHOtRN5V3dX8Lkv6YsR4fWbc3fzB7YF8avj5wy1E/2K8tHhfTB5AukDO/79Tc0+TtqUpFR3lH6n3RdPnvd7seM9sWO6oPq1McxBXfIMdKvZSrJpVImN1FfOBBwYF6B1zzGnbzZv0gEsCKaa4Qm1RKfYZOdtIiEp9s/ZbmoJiv3t/Hw97IUFdhwrdBt2v5sickvLMvfzLRNk1+fLjtSqVAYpELqApJly4i8TeRdUS5tvlNZojRJVsjjfHgckZQNg0u91eo2E1XkB9n9it3ymVP5gfwjET7QpbRXJFFqs3qkVKxcMyY/Qp9kSbVwt//KM8dD6vdyPciVINu/vL/4AcCyZcuwcOFCnH322fjc5z6Hu+66C11dXfj2t789HJtjGGYQOBBIB9TwDSds/xim8Amy/RuWF79/+Id/wF/+8hesWLECLS0tOPPMM7Fx48Ysh2eGYY4eSeEg6WHbkkP8Rx1U2P4xTOETZPs3LC9+ALBkyZLcpA2GYY4oDtTASLf5zOBg+8cwhU2Q7d+wvfgNmVBIdSKBi78T9QVQ/P1oHiOyvN6e+q+Q9jZJG0NdP8bUdCjNu3qlj4YTIbldaK424juRBfW3MPjS0JQJlm3uv+rXIn3UbJJ/SPfXMPnvKBlM6Hp1fw1D7i/lPHmkY/GTDsAzj58fXyCffVbzdRk3qeYhNG3f5O+otTcdW9r/LN8r3c9TOEAcgyI9gNThNY8ZXqxoFJYdVdL/6NeSMdWID7sCqBmEhMEv0LcfleLjSq9xjzQbBv9jy5AyJOt+8+HLZ1oXoD0z6GppOpOIe78AGHOsiiLiO66lZuqsl/dzsoz4j9fJbSZGy/0sPk6mXwGAE8ccyHx/f/+YzPcOyBRkkW5p88s7VONgEZ9FxRaa0oZ55D6Ej6hXr3NmtPNetjiPo3BBtn+F++LHMMywkhbeuapGch4rhmGCTZDtH7/4MUxAScFCUs9qq81nGIYZiQTZ/hXsi59lWX3DzxGSvoKWMgNgkRNj0eVoFQ8iderZvWkWdRqaH2mT8mwoLtuPLVel3t3JatmcZHqJ/EWG0FOpLis0nfaZziB9oSV2sqQGZUicDsHTLOjmYXs/4fTG9CVZ6zNkdM/q8sA3k9cyfsL51Soi5mOuy6YDrauvb+7bNMrLWekIPNJruKG5J1gl5JqNx2E5NtCFQeGIrO5lzWeOEo7Td32bXCgAgKSgUio00Gu8iOQI1K/3pLskrKSNUarbaBeE4rbgI7WKPstQLcToapK1aioPupec9CoZppSpNFSBUNrr6WzoD5raJSW374Q9+k9ciooOUJsrt9Nborp67OwaKzf5sZxXQjKFFR0k6ah6ValXxN2fJ4otohWl9JKVUXdXF2P5vjyn4PHrBuSHINu/gn3xYxhmeEnDQtrjX63XPIZhmGOZINs/fvFjmIASZMPHMEywCbL9K9gXPyEEBAQsGm2mSbVWmaywTAtOW6YSSPpQPZFHHJJt3eqSUm+4R473HuxRs7ALEvIb6aaFqUk/k6o8rbSnkjTpm0OG4+2oQbYFVEmRysO0MDuVk5O6bJnjha1LxVQqUdbrERWmrM5HVK9H5QyjvOAl55qUH0M/vSqXmGRfpaKCFpWrnnN3Sc0qogXfibQLID2mIvPd7kkC6ThwAIMiKWwkhVmK8spxxQwvVlUFLDumVo7Q739qW4rldSLitKKHexQloNkGKu8abK7Qoxyp/aD3lc97SemPh6RrbK/c2+S7qVqI3i+TG0vIXfbVnz/0OCkSarc8rhHNnWNUlzxnqSp5nwt6nElXnKi6z06E9IdcD8UtUuu1D5NMEoc1PxDybKB2Sq22RGTriLrPDn22+Hh+ZLvKuNt5v5WbhirvUoJs/wr2xY9hmOElDRtpmA3fyC1RzjBM0Amy/eMXP4YJKEJYcEw1SqGOaDMMw4wkgmz/CvfFz3EAy1Ej12Lm7tLoXSX6V4kQ8ogWJW2cMimbFB2U471//rBaaUOzOxeZFMEI6X9cK5hNZdwumahTibYiw/FZCUOVoXIi7xgSW3vJlopsItwlaK9kzBTP4XhDck6vYvCm9oBBHvCI5Ms1abQiG0NL+mqQpxR5V5ejaT/ptUElPSJPxU+QSVoBoPN4ue7Sj5JIpcLAu67dGJAg+7gUOumqUlihmFI+wI5rbiOGqHBRLZP5WoekBJiV1YBmDCBRuYrsSLehS6V6lL8bPiRcv2S5dlBb4uNeFo5HhCg1OdRtht7vevJ0aqeohNpF3I60JNGhw9LOhz6mrjrUfpmfWaJI3v/Kusm5FL1S6s1yDyLuAco8U/S2vs+G42xaJutZ4MN+K+vVpd6s59Hgr68g27/CffFjGGZYSYoQksL8kp0UI1nsYBgmyATZ/uXv7xjDMMcU/f94vT4MwzAjkXzbv1WrVuGcc85BeXk5ampqcOmll2LXrl3KMr29vWhsbMTo0aNRVlaGuXPnorW1VVlmz549uPjii1FSUoKamhp8//vfR0or1/jCCy/gs5/9LGKxGD796U/jwQcfzKmvBTviZ4VCsKyQMuysJK8FIKgMRyQJy5AMVE+Yq5xWEv3mFMv1xivlUnanerjshPuF4UTlciElwswstShJUx3DELyOIcJVqfXqEWFrToZpqG8pzBHKaq1fn7LtEOsu5prMOQt6nGg3qYROpXZAlSoM8rJlkesk4hEVHCOyDZF9BYkwP/QZNUK9/TOyb/HKGNIJAWwxbsKTtLCR9ohqS/tJMM0MDw4AC7DIOXBiahS9UySvMxrhaSeI/SshCey7tbrhYYN7B6kJrrjN6PeyIRJTl1Qz033W2lVsCX3g2dr2TfWBTdM1jPbDMdgSve62YV1UaoXeRkk67f78yErUTaGSLql1rBc3yOCVpN6UaN4jgbK2crmYyc7rdpluM0W3Q6/tHJ4fQ3iG5Nv+bdmyBY2NjTjnnHOQSqXwgx/8ALNmzcLOnTtRWtpn06+++mo89dRTeOyxx1BZWYklS5bgsssuw8svv9y3zXQaF198Merq6vDKK69g3759WLBgASKRCH70ox8BAHbv3o2LL74Y3/nOd7Bu3Tps3rwZ//iP/4ixY8di9uzZvvpasC9+DMMMLw4sOB7/ar3mMQzDHMvk2/5t3LhR+f3ggw+ipqYGzc3NmD59Otrb23H//fdj/fr1+OIXvwgAeOCBBzB58mS8+uqrOPfcc/HMM89g586dePbZZ1FbW4szzzwTN998M6699lqsXLkS0WgUa9euxcSJE/HTn/4UADB58mS89NJLuPPOO32/+LHUyzABJSnCSHh8koL/FzIMMzLxa/86OjqUTzweH2DNfbS3twMAqqv7gkKbm5uRTCYxc+bMzDKTJk3C+PHj0dTUBABoamrC6aefjtra2swys2fPRkdHB955553MMnQd/cv0r8MP/OLHMAHFgT3gh2EYZiTi1/6NGzcOlZWVmc+qVasGXrfj4KqrrsJ5552H0047DQDQ0tKCaDSKqqoqZdna2lq0tLRklqEvff3z++d5LdPR0YEeUsjCi4L9S5+p3EFTnoS0cPwiOc9KEl8G6i/V1S6XialVFKiPhdUhU61YldKX0CIuBNGD6vZt4r4R7SQ+Kkma0Z1kR+/RfGwsd38P6ouopGPRfAQVXxBTGy8fCUOKSqV4Os3Urq/LlM6EFCbPTvlC/DeIj6YFd38jL/ykZnFpRLpCtmnyZfHwcaHHWamwQn1DtHQOtCqHko6D+nJVygoxqWL1nKdLZJ8TFTbS/v58upIWFtIeuaq85jHDS+hQB0J2DILYLFGpVg5KlctrziHVJiKH5T1rk8oPIf1e1P1X+7dj8hfT7itj2o0hpnBR1qv79VFM6Vx8BmOaUliZtpEFbU9tI/Ux11dHn2GGdQvqS62dMyUFi5ICytBPzV9R93OXMwx+5fr2TbbVcP6zKneY/Pd8+mjns3KHX/u3d+9eVFTIikkxU2UwQmNjI95++2289NJLQ+/oMMB/6RkmoPRnrvf65MLWrVvx5S9/GfX19bAsC0888YQy/1vf+hYsy1I+F154obLMwYMHMX/+fFRUVKCqqgqLFi1CZ2enssybb76Jz3/+8ygqKsK4ceNw6623Dmr/GYYJLn7tX0VFhfIZ6MVvyZIl2LBhA55//nkcf/zxmel1dXVIJBJoa2tTlm9tbUVdXV1mGT3Kt//3QMtUVFSguFgNgDXBL34ME1CSn/ixeH1yoaurC2eccQZWr15tXObCCy/Evn37Mp9f/vKXyvz58+fjnXfewaZNm7BhwwZs3boVixcvzszv6OjArFmzMGHCBDQ3N+O2227DypUrcd999+W28wzDBJp82z8hBJYsWYLHH38czz33HCZOnKjMnzp1KiKRCDZv3pyZtmvXLuzZswcNDQ0AgIaGBrz11lvYv39/ZplNmzahoqICp5xySmYZuo7+ZfrX4YeClXqRTgNWWk3nomUhp+kNrF53eYJW9ICjDVvTFDCGEP6yfVKqC/eqsoNFVlfSSipn0DQtJJzfKiZ9ARQZUEkbYipYrVfO8EgvIBcyy6bGgtnUedVr2N52XOf5Ho6nkohX2ga6TZM8bFpeT6FjSu9gqvyhHXMrNPB/Ja/C9qb2VMKxO6SfRmlLqbak3P9Yu+hL5zJIHHjLubkmSpgzZw7mzJnjuUwsFsv8c9V59913sXHjRmzfvh1nn302AODee+/FRRddhNtvvx319fVYt24dEokEfvGLXyAajeLUU0/Fjh07cMcddygviMc6ojsOYQtFDnOi6n1hJ+QZCqXdr4NQJ6nOodlPReqk97YiIRpSfsBnCqhB4Nttg6Yz8eOWoNtCKhWHI+bl+pfRXF0cYueVu9pUeUmbZ5zuJeE6BlcVYTh/On7cW6hd1s+5IW2XKTUPdYEBzM8sP1VA8k2+7V9jYyPWr1+P3/zmNygvL8/45FVWVqK4uBiVlZVYtGgRli1bhurqalRUVGDp0qVoaGjAueeeCwCYNWsWTjnlFHzzm9/ErbfeipaWFlx33XVobGzMjDR+5zvfwb//+7/jmmuuweWXX47nnnsOv/rVr/DUU0/57iuP+DFMQPHr3DzYqDY3XnjhBdTU1ODkk0/GlVdeiQMHDmTmNTU1oaqqKvPSBwAzZ86EbdvYtm1bZpnp06cjSsrizZ49G7t27cKhQ4cG3S+GYYJFvoPb1qxZg/b2dlxwwQUYO3Zs5vPoo49mlrnzzjvxpS99CXPnzsX06dNRV1eHX//615n5oVAIGzZsQCgUQkNDA77xjW9gwYIFuOmmmzLLTJw4EU899RQ2bdqEM844Az/96U/x//7f//OdygUYxIvfQH48QgisWLECY8eORXFxMWbOnIn33nsv180wDDPM9Ccw9foAg4tqc+PCCy/Eww8/jM2bN+MnP/kJtmzZgjlz5iD9ychBS0sLampqlDbhcBjV1dU5Rb0NJ2z/GGZk4Nf++UUI4fr51re+lVmmqKgIq1evxsGDB9HV1YVf//rXWQrIhAkT8Lvf/Q7d3d34y1/+gttvvx1hLan3BRdcgD/84Q+Ix+P44IMPlG34IWept9+P5/LLL8dll12WNf/WW2/FPffcg4ceeggTJ07E9ddfj9mzZ2Pnzp0oKipyWaM7VjjcVwGBDA2LsCZ1dJEs5jTClxTJVuRdPVM6HXYukRFzoXbZPqq0UaOCI51EBm6TEbtWL4nkVaJI1c0rMgAd0jcVzNaHvQ3Z6tUINyIbh9Vhd1O2fCrbeCF8SNJK5RBokrIhes8oJwBZcpNxuQzmbP9KtnhDhJ5IemTep6ulbgNKtJoWCUnXZ4q+buvIfC3frTrrluyXfQ53JpFKa5HiOZAUIYQ9a1X29X0wUW1uzJs3L/P99NNPx5QpU3DiiSfihRdewIwZMwa1ziPNEbN/ZcWw7Jhi85TMBQDCcXItEamXLmf1kNFZPVrXMtgcaosMkb9Z7U3yqI+KHoBPCTGrkcENRrH5cF9G75vBfijuLNqxoG4nSrQtveezqpXQbRpkWw8sQ/YHRZ71yAThK3uB4VniOc8U1atHEZsyQRjchrLcm0zPnEHg1/6NRHJ+8fPy4xFC4K677sJ1112HSy65BADw8MMPo7a2Fk888YRi+BmGOboMFLmrR7Xlm0996lMYM2YM3n//fcyYMQN1dXWKUzMApFIpHDx4MKeot+GE7R/DjAz82r+RSF73bPfu3WhpaVGySldWVmLatGnGrNLxeDzLh4hhmOHHEdaAn+Hkww8/xIEDBzB27FgAfdFqbW1taG5uzizz3HPPwXEcTJs2LbPM1q1bkUzK0atNmzbh5JNPxqhRo4a1vwPB9o9hjh2Otv07muQ1qrffx8bNB8fkf7Nq1SrceOON2TNCIcAKqUPLvepQuyARQ3ZHt5yRNsi7ekQRHUam0bdkO+F22T7UpTm10wTQ3WSeYYhY9GrtaaJpMo9GfjppOmyvnS6TvEITMPtJUqrNUyJ0iZzhV44wy64+h+eNEjSMkoLfwt5qAXiSnFqXwX2syyT70qi6rILrVEYjLy+giZ3JtRj+i/oiYMelS4LVk4A9hAzOzgD/eHN1bu7s7MT777+f+b17927s2LED1dXVqK6uxo033oi5c+eirq4OH3zwAa655hp8+tOfzjglT548GRdeeCGuuOIKrF27FslkEkuWLMG8efNQX18PAPj617+OG2+8EYsWLcK1116Lt99+G3fffTfuvPPOQRyB/JJP+ydsOythfehQl/LbotKtKSqUJpBPalIvdaPRXRpc1qsvYyn5d30kU/eIqh0UpgTOhgd2doS/e99MsnOWLTBJ0nS9ngn0c8dJ0OTc5PmRMriNeNh8s7xtziRhjPKm26HfPeR9NZMC2aTHM0e/towJqX2Qb/t3LHHU92z58uVob2/PfPbu3Xu0u8QwgSApQgN+cuH111/HWWedhbPOOgsAsGzZMpx11llYsWIFQqEQ3nzzTfzd3/0dPvOZz2DRokWYOnUqXnzxRcVncN26dZg0aRJmzJiBiy66COeff76So6+yshLPPPMMdu/ejalTp+J73/seVqxYccymcmH7xzBHh3zbv2OJvI749fvYtLa2ZuSb/t9nnnmma5tYLDZoZ3GGYQaPI2w4HpFrXvPcuOCCCzz/gT/99NMDrqO6uhrr16/3XGbKlCl48cUXc+rbkYDtH8McO+Tb/h1L5PXFb+LEiairq8PmzZszhq6jowPbtm3DlVdemdO6RCoFYdlqwlstqteUqNIYYZUVEUoioWjEFpXqaK1affuUFFlXt4wKVvqiDfurUb3u0V7KsL0+NG+qD2ka9tdQJWE6PE+PBWmvrcuUQNlvtJUiD/mUJxTpgWzHJNW6bFS2Ibng/EYLW3Dvp+lYZh0JKvVSqZ9eZ9Q9QYvEtNuJ3BdPwHI8oi4HIA0gnd1DZT7jn3zaPyudhiXSQMorqpZeJzK6W1C7mPCq+2qwGXr2g/7pHhGeqquIQYLVZD9j9gGfUqsx6S9tb8oikNXIPVG9V4YBo231kDr1hO4ZfCRDzuqPKYG/z7rJRpvrJe9T+2dI4O2JY4h49nrOKR1wd+8ZDEG2fzm/+Hn58YwfPx5XXXUVbrnlFpx00kmZdAb19fW49NJL89lvhmGGSNIJI+SYTUByiBUYRiJs/xhmZBBk+5fzi9/rr7+OL3zhC5nfy5YtAwAsXLgQDz74IK655hp0dXVh8eLFaGtrw/nnn4+NGzfmlMOKYZjhR8CC4/GPV3jMCyps/xhmZBBk+5fzi99AfjyWZeGmm25SSowwDFN4DJSdPtfM9UGA7R/DjAyCbP/y6uOXT6yQDcuyAZoOQ085QP3/qF8V8cUTvSRlgeYTQX02lFNMtiOKyT913adCz4Sf6Uva9XuWjwj1CzP5aygN9ILdxBeFrIuG/HulRlG2qWTuN/h+DMLpIavIN/XLoz4+NLWKh18iXW4w6SCMqQJoagjq4+QzHYNSuSPicVvRlBrU34/6ZZHULqJXq8yRIP1JpSDE4H38BspVNZLzWBU6orMbwk6pNsLrhZNeS4rvFPWR1q5Lcm2ZbJFyL+jt1Q64T/eyP4b7z+j7q2/Sq8KPaxfN6VyMKWgM28tub6hc4TO1lXFdOko6lYErpyj2EpovtMkX0JTOC+bKIcp1Qq5FvdqJsVqM0keD77m+nG3BEhbgcbi8CLL9K9gXP4ZhhpekCMH2LFk0SIvKMAxT4ATZ/vGLH8MEFAe2Z5LSkZzAlGGYYBNk+1e4L36OACyhhbZrsmFcDmMrVTEcd6lVr6Kg/LYN8l4Pkdp0Cc80vG7KiK6nSaDLUXmBSgC04LaHhGhKAWOF3LO79810H96nGeGVbehSk0nGoLJpRNtnU7Z8gwRhhfSbz2falv5V6X30KAAu23jIC6Q/tEKAei0ZJFxo8gidQVK7KH2MaCl0qBuDy/pzIS0spD3kDK95zPBihcOw7LB6z3pIvYp7h+masP09yEzpXHSM0rNPu+gn7ZNXChYqiZrW5Tedi6mKh/BSkE2SruUuIWdtR6k8YqicpO+Xweaa2mSluTLJu4bpWVI7TXVmkHe9KhepacMMzzx6zXu581g2hlKDIsj2r3Bf/BiGGVaC7OPCMEywCbL94xc/hgkoqQF8XFIj2MeFYZhgE2T7V7AvfiKRgLDUYWtHi3BUhpFpJJAp2taLNBl2pu3JcHbWsL2psLkpI7lXkW+CVySbgmGonE5X5Bht2JxKx3RfTNFaugQkFElAfnfiUnZXqmMAZqnBEK2WJbv6yUrvtzC5KeKQSuVespciD5HvNHJXr3aiVAsx9JNK7fo1R6Pk0mlgSFG93v9qR3D+0oJHxHshLM1NQLsXLINLhrG6Q3IQdtH2F6Hqp4qDqdJP30x32dEr2tYYlatIhaRfujRtG+yswa5k2X9TtRG/1UKEu7xr2obXdozVTvQIYVPlo5Bmp/vRbZTiRuR+/JRnjtbeihhcdRSp3D1yOLtvQzNQQbZ/BfvixzDM8BLkWpUMwwSbINs/fvFjmIDiDJC53msewzDMsUyQ7V/hvviFQoAV0qJVPd7ASSQvlcM8i2ybIjEpHgmYFRmPDEkrUgOVZ/SC27GY+3IGCTBLalXqVRvkZYpXFJ1BKkYo9wg/RQLQx8sNMqpjSCbrFdWlShqmZKha/xVJyXKfTs+5Lo8TeU2RLUyyfUmJ1ml6PZBjQ/ZZSZKqR2Lb+rEd/L/SpBOC5XjksfKYxwwvTk8cjuUo90JWAmHikuInEld3u1DsmSkS3StpNLWt1O3FR7QuAMUWmNxm/ET+Zjdyv68t3ZbRqFyaQJ5EwgrPBPzuy/nts1EqNiS2Hsy6slDkXfdt2vS5pK+LPoPpsQ0bJGD9ujS5JHV3y+/0us7KykDkcQxNiw2y/SvcFz+GYYYVBwNEtY3gf7wMwwSbINs/fvFjmIAS5CLlDMMEmyDbv8J98UunASutSqjaIpZFoyoNyXQ9Ejgr6+7pkcvRoW66uB5VZ5CHTXVzPWvl0iFwsl7LKyrNT61ZL0wRuyZ519ajgqXU4XTJoXqb1prVh+rJb4eeG8Mx9wqtUo6nIRLQCzUqjqzXqz6qSdI1tMmKvKTtyfETMbIcTdpdpB0XKgOHQ0A6Dhxy7dKABDmPVaHTV6vcw15oCJO8R6Ux/do1ybgmu6ZHqFObQeVhGgmc9JeM13Qv+3bbUKb7rcFrqBVslGC15iabY0qMrM2zTEqiVwJlQ8YCZfse9s/0bLCpSwp1ZylVXVWc8mL5PUZsHpGAe2uJ/de2Z6fkOYh9LLM/RFrIfnYclu21pAVZLgVDsFFBtn+F++LHMMywkhrAxyU1gn1cGIYJNkG2f/zixzABJchRbQzDBJsg2z9+8WOYgBJkqYNhmGATZPt3bL34aZnnHepLRX2slHQqtFKDPx85QSpPwCMdjDGE3kfIPABY9MJSUqAQHxevdArU34u6u1AfHY/UICYfRWPBbd1HkfTNjrqnNsiCrMM2nDPFF1PzN/Qsmt6/DPULimiXuFffMtug/krazU9TuBgqdCjXYkWp2p6cj1SV9JfpqS2Sm0zK/jtRdfvdY+S5SRVbSMd7gTXu+zEQQTZ8BY9l9X0MPqEAzJVfTKmdNFui+NWa/MKoj5ZeRYcuRlLFOD2kwhK1hXo6KpNtU3z3SDoVzUcvqyqFC56VMwwofoF+06QIQ9ouvY2P/pi2r88z4rWNCLFT1P+Y9rlc2iynRPUxTlZLm5WolHaup1qut6eGnHPNLTXSSZ4ZSXnNhDuk/UOn9BeHQ57FQHY6GK/KHgMQZPs3clNTMwzjScqxB/zkwtatW/HlL38Z9fX1sCwLTzzxRGZeMpnEtddei9NPPx2lpaWor6/HggUL8NFHHynrOOGEE2BZlvL58Y9/rCzz5ptv4vOf/zyKioowbtw43HrrrYM+BgzDBJN8279jiZG7ZwzDeCIg/VzcPrn+l+7q6sIZZ5yB1atXZ83r7u7GG2+8geuvvx5vvPEGfv3rX2PXrl34u7/7u6xlb7rpJuzbty/zWbp0aWZeR0cHZs2ahQkTJqC5uRm33XYbVq5cifvuuy/H3jIME2Tybf+OJQpW6hVp0VeknFbu8JDtlGzfNLu4V2oOP1nRfVeBIEPlafdlPGVH+p1m69dT0FCo1Er30yhBa+lYqPQSoe0Nx9xLQqBSJ52uy8mmqgBUEleKfGvbpMfZlIIh7FFRQ5HUDdUC9PNEMUlvpA2t1qFLTcmassz3rr+SMkpXndyX7rGyTcUpB5T2M4//n8z31z6egFRXvGCk3jlz5mDOnDmu8yorK7Fp0yZl2r//+7/jc5/7HPbs2YPx48dnppeXl6Ours51PevWrUMikcAvfvELRKNRnHrqqdixYwfuuOMOLF68OKf+FjT96awomquLsdqGYRnPykc0tRO9rmlqFj2djMF+KSmISJ+z7C+t3GBKk+SZjgW+5rmtS29jklCV6R6pWYx42S/DujxdZfzgIa8rXTGkjbLi5DrT0lGFO6T0miqWtrT4QJpMl7YwlFD3P9Yuf4fi5JrpkunUhPIs9TgWwjEfTx+w1MswTODoN3xeH6BvlI1+4vH4AGv2R3t7OyzLQlVVlTL9xz/+MUaPHo2zzjoLt912G1LkhaOpqQnTp09HlPiUzZ49G7t27cKhQ4NMaMgwTODwa/9GIjm9+K1atQrnnHMOysvLUVNTg0svvRS7du1Slunt7UVjYyNGjx6NsrIyzJ07F62trXntNMMwQ8evj8u4ceNQWVmZ+axatWrI2+7t7cW1116Lr33ta6ioqMhM/+53v4tHHnkEzz//PP7pn/4JP/rRj3DNNddk5re0tKC2tlZZV//vlpaWIffLC7Z/DDNyCLKPX05S75YtW9DY2IhzzjkHqVQKP/jBDzBr1izs3LkTpaV9kUBXX301nnrqKTz22GOorKzEkiVLcNlll+Hll1/OrWf2J1FtXnIAHUY3DNVTeSIrKsyQLd6IHqFlip4zyQ76dMsgw1AJxyCH6ihSp0GqtPRdpOuj8jId3afyjr75BEmrbqo2okMlXdJekbRpRZW0mrqdRg/6iaqGh1JgauMltdDtK/tp2GenvEj5bcfl8UyWyHkpGSyHVI3c59KoKu99pki+3LxujYdtDd4TRQgLwuNfbf+8vXv3Ki9nMVOVFZ8kk0n8/d//PYQQWLNG1amXLVuW+T5lyhREo1H80z/9E1atWjXk7Q6VI2r/XNClUsuQCcBckUe7gelyxfICFEXyGkeYuHD06BGWRJ481C6nGyqMZEf1GmwWtZNeFXkMVTCU+5dWAdFvayrVelXbMEFtBonEN9oiAJZlcD1yDO11hCHLgmLziAuUXm2F/qauA0T2Fd0yqtbSrjk7JW1WSTuJviXntux98gDRXRBS5JyT60n0kkhw4raV5Z5EM15gaPi1fyORnF78Nm7cqPx+8MEHUVNTg+bmZkyfPh3t7e24//77sX79enzxi18EADzwwAOYPHkyXn31VZx77rn56znDMEPCbwLTiooK5cVvKPS/9P3pT3/Cc889N+B6p02bhlQqhT/+8Y84+eSTUVdXlzWC1v/b5BeYL9j+MczIIcgJnIc0ltne3vcvr7q6GgDQ3NyMZDKJmTNnZpaZNGkSxo8fj6amJtd1xOPxLB8ihmGGnyPt49L/0vfee+/h2WefxejRowdss2PHDti2jZqaGgBAQ0MDtm7diiQZrdi0aRNOPvlkjBo1Kq/9HQi2fwxz7BJkH79BR/U6joOrrroK5513Hk477TQAfT420Wg0y1m7trbW6H+zatUq3HjjjcbtUAk0K6qMDs8bomKVaFNdFjMUA1eSEXsliKSyJY2Qst3lFaXANACbRr8ZpBplqFtP5kn30xSJSuWQkqgyS+hRgv3LUdk5VuK6DABYMSq7GuQRXTahiZqpbJvQqnH3L6NHNdOE0jQ5tela8Jt0lejYXkm3leTaVN6m8gTpc6i1Td0kkXcrd8vrrKhNfq/6QH7vrlBHse6uuExuM42+BM6DJO3YsDz8WNI5+rh0dnbi/fffz/zevXs3duzYgerqaowdOxb/5//8H7zxxhvYsGED0ul0xiZUV1cjGo2iqakJ27Ztwxe+8AWUl5ejqakJV199Nb7xjW9kXuq+/vWv48Ybb8SiRYtw7bXX4u2338bdd9+NO++8cxBHYPAcKfunRNjrUbmmBOL0mqffNanVKpLXoojJa84pk7Jvukzeo6EeVWq3e0gmhTjxVejqkuul9U69IjRNyfS9JFCD/VbtL7ExST2BvSFi10+0LmDM+GBF3DMs9P12XOcpUrfhWPR1kz6PSHvqh2OZ3W5MdlaR56mrTY9qX6wOw3NGkb3dpX4d05OVZujwxLIxlLGrfNu/Y4lBv/g1Njbi7bffxksvvTSkDixfvlzx6+no6MC4ceOGtE6GYQYm3z4ur7/+Or7whS9kfvff1wsXLsTKlSvx29/+FgBw5plnKu2ef/55XHDBBYjFYnjkkUewcuVKxONxTJw4EVdffbViHyorK/HMM8+gsbERU6dOxZgxY7BixYojnsqF7R/DHNsE2cdvUK+0S5YswYYNG/D888/j+OOPz0yvq6tDIpFAW1ubsnxra6vR/yYWi2V8iPLpS8QwjDdiAJkjV8N3wQUXQAiR9XnwwQdxwgknuM4TQuCCCy4AAHz2s5/Fq6++ira2NvT09GDnzp1Yvnx5VlDHlClT8OKLL6K3txcffvghrr322nwdEl+w/WOYY5982z+vykUA8K1vfSurKtGFF16oLHPw4EHMnz8fFRUVqKqqwqJFi9DZ2aksk4/KRTmN+AkhsHTpUjz++ON44YUXMHHiRGX+1KlTEYlEsHnzZsydOxcAsGvXLuzZswcNDQ259SydBixbiUrSZT9FXqTynKHuq9DDusiQuB2lCTQNtVo9koQak/56yRtU3jVE8tKhebtYjRBVZCAa1kakakUO1aMCidQDQzJnz1qISvQgjZ52l1Cz1+ee9FX0utdKBlzkfjdCZnnJJB0px4lKMHq0rilpLr3+4iRaWY+qI4lKY/8tb+gYPbf0/BdrkazatZlKx/EuBoeA9+kdyZnrB8ORtH+ZBPYGt5FPOpT5arQ/tL0uYSouHVISjddI2TZVSu6RtJrMt3ifvJbDne4ZAtBrzvmouHpQedBnVL6yLkOiZwuGyH8vTLV2dfuvPBsMdsHrmWGIxFW6orv3mDJRGJ5TjiabGmv9UjvnVSueLkevP/rMMRQDAKBGHNN9U+yy4VkMZEcvDyGBc77tX3/lossvvxyXXXaZ6zIXXnghHnjggcxv/U/t/PnzsW/fPmzatAnJZBLf/va3sXjxYqxfvx6ArFw0c+ZMrF27Fm+99RYuv/xyVFVV5aR65PTi19jYiPXr1+M3v/kNysvLM34rlZWVKC4uRmVlJRYtWoRly5ahuroaFRUVWLp0KRoaGjiijWEKjLSwAeHh4+IxL4iw/WOYkUO+7Z9X5aJ+YrGYcfT/3XffxcaNG7F9+3acffbZAIB7770XF110EW6//XbU19fnrXJRTnu2Zs0atLe344ILLsDYsWMzn0cffTSzzJ133okvfelLmDt3LqZPn466ujr8+te/zmUzDMMcAYIc1TYY2P4xzMjhaFQueuGFF1BTU4OTTz4ZV155JQ4ckCU5m5qaUFVVlXnpA4CZM2fCtm1s27Yts0w+KhflLPUORFFREVavXu1aqJ1hmMJBiAGkDtZ6Fdj+MczIwa/904OtbrjhBqxcuTLn7V144YW47LLLMHHiRHzwwQf4wQ9+gDlz5qCpqQmhUAgtLS2ZtFX9hMNhVFdXZ9SFlpaWLBcTWrnIb0qrQUf1DjuW7T+sHjCnAzClGdEw+46ZU3tYXv4f/W280hHQdCBaMezM9DBJk6AdDytMfPyorwDx11H8MLSrXJTSchE0BQrZDvW90f2IqI8h8SWxPHzUlOz/xBdOSTMQMWd+N1UiUM4fPRdZ15DBx4Ri8oMB1BQaEfdzRlEy0uvQftIqJqSKgn7OdJ8pyzGkZ/BBkKPaCh7hAHCUSg9e/sI0BYbiCx2mqaG01B7kfnaixC+LtOkeI++fWId6LaZL5PUfoj5eCZIOi/rE6v6ydH8M6UAsvxV1lHQ2ZIZPH21jOhfqk6a1tyPEttFtUt9nrfKE6tdmqBZiqEjit59qe39+jfRPjXIssxeUX+k2DWYoK7WLj/OhPLM1Hz5aIQXCyfbbz4EjXblo3rx5me+nn346pkyZghNPPBEvvPACZsyYMah1DhZ24mGYgJJ27AE/DMMwIxG/9k+Pus9X6chPfepTGDNmTCb3aV1dHfbv368sk0qlcPDgwYxfYL4qF7FlZ5iA0i91eH0YhmFGIkfb/n344Yc4cOAAxo4dC6CvKlFbWxuam5szyzz33HNwHAfTpk3LLJOPykWFK/XaVt+QORkOHlSQoSnk3i9pn+kAaOZ2OtRPZVNt2F8NoXe/ytR0NFo6ljD550GKqQv6vZikTIhoqUVSchg9NUrKi05ULmcn5P47MbW9HZfzwp1Etg27p6YBAJsO45Os8MbUMpoEr0hHhsojXlnkvQqoy81TecnDVSBNZFdD5n3fKSSipIpCFyl+rldr0GQQIYYi9XrLufzidxT5xNXFJMEBqtRmG6oVKe4Y+kiFkhqITI7Z5Lu8PpyQekE4VEam9wxxG1Hsl34vG+4ty5CChqbcylqfQQI1VlQCzNU+DOlc7Kj5XrZoOiZqc/T7n/aZ2K8hKJbZ+Exxoqa9Ic8MuKdZycKnDK9sk54Pv7aRoKSKSaYA2IPOO5Vv++dVuai6uho33ngj5s6di7q6OnzwwQe45ppr8OlPfxqzZ88GAEyePBkXXnghrrjiCqxduxbJZBJLlizBvHnzUF9fDyB/lYsK98WPYZhhhX38GIYJKkeyctGaNWvw5ptv4qGHHkJbWxvq6+sxa9Ys3HzzzYp0vG7dOixZsgQzZsyAbduYO3cu7rnnnsz8fFUu4hc/hgkojrBgeRg3TufCMMxIJd/2r79ykYmnn356wHVUV1dnkjWb6K9cNBQK98Xvk8odXlUYVBnUIJvS7/pQf67DzvoQOo2qotsJ+ciO7gWVDUmErhXXZD0ie4oSKTU4pfIfBJVt08Xq6aZSbaJKbiddRKTqtPkSSZbK6L0wKeAuyP5HOtVzFq6Qy0WpjNlNol9p4KpX5nuSy4hGxXrJYwoe14Zs7889wFTtw8sQKJHcRPZW+m+rkcNKVRqffTMi4C2TsNR79KGuLo7mtkCuH+WaoZGo9PrTpFZ6xdud8qYL9ZRkvkcPExuj2bVwD7m36fapq4lyL2sR+rT/CYPbBm2uV6EwVbEg302yMQBYEcMzg7rthM32T9k+de8ZUy27omVCsDtktR7R00O+E7cXD5tlqnZhkq0VG6m1t8MD26ksG0OfOT7lXWV99HiYbLuXVK3tpyUsYLDFOwJs/wr3xY9hmOFloHqUPOLHMMxIJcD2j1/8GCagcAJnhmGCSpDtX+G++PVHtRE51i5So9KUpL96W1+bMCQ3TbtHpTkJTWomUoGSWNgwHK4n81TaUNlPGKTqEpJwGWr0bmqUlGdERG4nUUGTqSrNkayR85KlRJ7tItsk3Qol1Tuhd5RcYfepcl60Xa6r6GP1X1PZn+X3cImUIZRoXxrVqkklFrkejEmfPQrDU5RzQzOwEklLjzzMjir7BNtdNsmKxDT1jcpg9Prp8Ujam0wOLarXsSE8It295jHDTH8CZ02qyxVqvywt4bggUaX0vgrF5bUY6ZLf9ftfKJGwVHZ0j4rNSnhukgotg/3UJVCDJOgrWhfwl+WB3ss0chdQbXPtmMzXnrFlsnlY3UbsY7mO0Id/ketO0Ahff1kBqAyr2CUq9esJlCkmlyQqIet6J40SN7iaeLm3GKOs6Tk3nT/oz9OhjcgF2f4V7osfwzDDSpD/8TIME2yCbP/4xY9hgkqAnZsZhgk4AbZ/Bf/i57dWo1K31TScrA/dGiKGhanuocfQsiLvGRIzW15RvbR9WamcrNfHpU2U5Myyn8kS2SZVTGTfMnX7qWL5u1cqFQj1UqlW9iuhSQPx0fK7EyH9d+gQvtrndJF7QmsasSyUGpQetR6VFbvX/dSPOY0MVGpSKtFmHrUiDdegqYawnmTaou4KNIErPf+OOUwtS0YeVFbz/nVxHr+CJRTKKtSanYzccO5N8qAe1UtdT8g1F+qRy6lRvdpmukl9aUOEKXXHyHJ7MF3nhqjcrFrppkh82sYrKwANyjUl2qfPFc1Nw64oz3xPVkgJt2OitMvxUWofx/yX7E/JQeK6Q91blOeP2t4k/aoZKmT/Hc1+qpIwdS8x3OvadCVjQcqQqJoec81++sme4XX+hirvUoJs/wr+xY9hmOFBCAvCCabhYxgm2ATZ/vGLH8MElQBLHQzDBJwA2z9+8WOYwGIhS4vPms8wDDMSCa79K9gXP5FOQ1i2v0zf8PCxUlaq+RtYxN+BTg/T1Cruxb8BaL4Ytvt02+ATAcAi6VloqgWTX5/Q0tmkaToUUoUjRHw80sTHL1mq9j9eTb7XkIzu3cT3Li37H5aJ5gEA0XbSN7L/4S453dayjYS7aeZ5cmxN/ia6TwdNKUHTQ9DUFCQFRpZfjqHaganyhp6535SqQPGXocvofklKZ8hxptcvba9dy1ZSTfsgfBZkdyXP/3i3bt2K2267Dc3Nzdi3bx8ef/xxXHrppXJ1QuCGG27Az3/+c7S1teG8887DmjVrcNJJJ2WWOXjwIJYuXYonn3wyU6vy7rvvRlmZTJHx5ptvorGxEdu3b8dxxx2HpUuX4pprrsmts4XOJ5WLvHzUKNR3SrlGacqjqJpOhfqbClIhiFbooFV8Qr1aOpcIrZxh6KepiogX1JZSfz8/1ZWyViXbex1Ls4822b6ezoW0SYySx+/gmbJN9Lhupcn+kPQLnLCb+BhTO0P9gm2PZw5B8VEkdlH3AvV1Drx82dOGVD2m5XUfvZAy07ANmk4t4rpM/3K+rynXFSCwI34jN1ENwzDeONbAnxzo6urCGWecgdWrV7vOv/XWW3HPPfdg7dq12LZtG0pLSzF79mz09spyVfPnz8c777yDTZs2YcOGDdi6datSgLyjowOzZs3ChAkT0NzcjNtuuw0rV67EfffdN7hjwDBMMMmz/TuWKNgRP4Zhhpd857GaM2cO5syZY1iXwF133YXrrrsOl1xyCQDg4YcfRm1tLZ544gnMmzcP7777LjZu3Ijt27fj7LPPBgDce++9uOiii3D77bejvr4e69atQyKRwC9+8QtEo1Gceuqp2LFjB+644w7lBZFhGMYLzuNXgFihECwr5CnvKtm+/ZwlTapVhq1N2eK9wsdNFUKohEen60PjdPtlUiqw4kTOK5ZyjKWlc7BTchg8HSOyATkWNpFGLT0Je4xMKCfywigib7TIiiBFB82yYvFfyPeP5fELd6l9Dh+SerF9mGjCVAanxdh1aYMewx5Ne3Zpo6e8oOfcmO0+7VM+VVIFGa4/PYWFSQamaX9C7mk2dCzLGpoXik+po6OjQ5kci8UQi8VcGpjZvXs3WlpaMHPmzMy0yspKTJs2DU1NTZg3bx6amppQVVWVeekDgJkzZ8K2bWzbtg1f+cpX0NTUhOnTpyNK5PzZs2fjJz/5CQ4dOoRRo0bl1K9jCj21EI06VNxL3Cs6ZEFTc5DUUE5UXrMOrWJTrF5tRS2GqhD0XtalShPGNE3kuy4NGlJ4UZSUTbbWnsrIUZJaxVBFxyrWKifFpP3tqpPH+a/PejfzfXn975U2X2r7rtxMpbSt9iFyj3kdM6+UYJkVu/cfAOBVySPT3sMo+LF5hKznp3CXik1pf7xS+FihECzhAIP1dmGpl2GYoGE51oAfABg3bhwqKyszn1WrVuW8rZaWFgBAbW2tMr22tjYzr6WlBTU1Ncr8cDiM6upqZRm3ddBtMAzDDIRf+zcSyenFb82aNZgyZQoqKipQUVGBhoYG/P738h9Nb28vGhsbMXr0aJSVlWHu3LlobW3Ne6cZhskDwscHwN69e9He3p75LF++/Oj09yjD9o9hRhA+7d9IJCep9/jjj8ePf/xjnHTSSRBC4KGHHsIll1yCP/zhDzj11FNx9dVX46mnnsJjjz2GyspKLFmyBJdddhlefvnl3HtmW33D2nQ4WR82dgyyGcVQnQNQI6kUCdBQPNoLYxZ9r2XodugQPJUgo+aoJqRItn0iIaYiJEKPJqGPq1eyE5W/Kytl9NmJ1R9nvr/5RxlxWaI9w0r2k8Lu3eR7l5Rq7bhWuaKXRBnSDP9UAqWRt92aNEElARq9SyN0E1ooMcUQSabICzBXiDHKEFSCoBF6+nVpknEsEn3olVFfy4ovhEc1m4EQVt/Haz6QedEZCnV1dQCA1tZWjB07NjO9tbUVZ555ZmaZ/fv3K+1SqRQOHjyYaV9XV5f1MtX/u3+Z4eKI2j/LBixbsxma24JH9LhcDzm/8bh5XqmUMe0EcdUgEf6RTu1edAyR7PSa9bC/flwqaFRolmytuEcYIky9KjdRDJG0yr3s4U7kEDN9Stm+zPdTo6o8HCojbjwhKluSvpXKyk1wtPNqknoTarS/CWOFIrLPwiHnWbeXdNWG6GuvZ6ZyPkFdckKuy3giHKM999fen/0bieT04vflL39Z+f3DH/4Qa9aswauvvorjjz8e999/P9avX48vfvGLAIAHHngAkydPxquvvopzzz3XdZ3xeBxxYpB0fyKGYYaJI+jjMnHiRNTV1WHz5s2ZF72Ojg5s27YNV155JQCgoaEBbW1taG5uxtSpUwEAzz33HBzHwbRp0zLL/Nu//RuSySQin6St2LRpE04++eRh9+9j+8cwIwj28cuddDqNRx55BF1dXWhoaEBzczOSyaTivD1p0iSMHz8eTU1NxvWsWrVK8R8aN27cYLvEMEwuOD4+OdDZ2YkdO3Zgx44dAPoCOnbs2IE9e/bAsixcddVVuOWWW/Db3/4Wb731FhYsWID6+vpMrr/JkyfjwgsvxBVXXIHXXnsNL7/8MpYsWYJ58+ahvr4eAPD1r38d0WgUixYtwjvvvINHH30Ud999N5YtW5aHA+Iftn8Mc4yTZ/t3LJFzVO9bb72FhoYG9Pb2oqysDI8//jhOOeUU7NixA9FoFFVVVcry1HnbjeXLlytGu6Ojo8/4fZLA1HPYmEZvmqLX6LCxti6HDI9bJnnC77CzqV8ekWfKvG4SoUqkTptG3mVJxTKy0om4R/gmykky56g6dO0Uyyv7b45/P/N9VFjKvs2jPpX5HulS24c7iaRLCruH2jrlQro8QhIqm4p802ORJY/T40HXTROteskzYcN1QiVYw/kDzImejbKbLu2Sfpoi0U3RxlmEQn1Sh49APVfyLHW8/vrr+MIXvpD53X9fL1y4EA8++CCuueYadHV1YfHixWhra8P555+PjRs3oqhIJsZdt24dlixZghkzZmQSON9zzz2Z+ZWVlXjmmWfQ2NiIqVOnYsyYMVixYsURS+VyxOzfJxgTC8N8/Vn0mqN2zSMZOc0YED4s71ErLZcJ9WhuG3HZRnQR+2WIqhdJrb1BdnTICChN4OtpP1Nk3UoyfffldYzHmUiJIq66kNDlyj+Uffv565/PfH/txBOUNqHdRFLvaZPrpq5G1OaRxNoA1Ihpuv9kn+lVIkiOTACqbVKOn8GIZGWiyNG1RHvmZkVWuyxnXAbZMvDQEjiz1Oubk08+GTt27EB7ezv+v//v/8PChQuxZcuWQXdgMKkhGIYZOpbITvGjz8+FCy64wNMQW5aFm266CTfddJNxmerqaqxfv95zO1OmTMGLL76YW+fyBNs/hhkZ5Nv+HUvk/OIXjUbx6U9/GgAwdepUbN++HXfffTf+4R/+AYlEAm1tbcq/3tbW1mF3umYYZhAE2MdlsLD9Y5gRQoDt35ATODuOg3g8jqlTpyISiWDz5s2YO3cuAGDXrl3Ys2cPGhoacl6vFY3AsqLq8L4elesRMSYXMsgeAOwQkRHoUDeNNvUY2ra9Im4z2zfUYAUgqNRM10W32SOH6i2tVi+I1GKSMeIVcv97R6vzBPlLk3Jk+w97pZN8qItINbYeFSzbhDq1iMF+tMg9ZUSI9pkcf1Wq9WhvqmnplcCU/k66J4rW6/NSTFG9NMLYrxxiOmdKMlNdnsujNbIwwD/evG1p5DJc9q/vuneUSFTf557Wc4a0K5ZlltAs4oKhJIqnEmhKbW91SJcOQaNPqf00SYjQbKuHe0U/ur2l6zbeS35tecR91JU+fyxdZiTfi1qke8xxW2QE/Hvvnai0GbWHSLq9xP6HDXWP9X0uVaOEM+3pOaNuQ1n2g2B0W6HnUpNqaSYMj3ObWcYjAbOynEGq18+rLgNbwhq0L16Q7V9OL37Lly/HnDlzMH78eBw+fBjr16/HCy+8gKeffhqVlZVYtGgRli1bhurqalRUVGDp0qVoaGgwRrQxDHMUCbCPy2Bg+8cwI4gA27+cXvz279+PBQsWYN++faisrMSUKVPw9NNP42//9m8BAHfeeWfGITsej2P27Nn42c9+NiwdZxhmiARY6hgMbP8YZgQRYPuX04vf/fff7zm/qKgIq1evxurVq4fUKYZhjgABNnyDge0fw4wgAmz/huzjN1yIRLJvpFVJh6KeCYu6RWgVDTLLhM3+AoovmOJXYEgh4+FvpqdaIAvJ77q/Am2j+I+Q70Uep4imMKFpQmhBEFJwobdO88kIye38buepme+RIurjI1fWW63uY6RL7k+EJvEnx8/q0dIJUL8QQ7USxRfTUvef/vR1X3qlIzBk6PdMoULOmVIAnqatoNeVV+UOx905xaJRnll+rZrPjbmnA2I5SsEQ1/nMsYFy/SmpQTyuRdqm292X2G7vksunvCpCSF80h/gLmq7xvnnmVFtuZFX6MKVnUap9mGysvm4faZo0H23ql03T3kR65PditRANYu3EThObp/h4k+MsilXfQ6dE+hJTH2ub+HuHPJ5LooOkpKHzqC2jy+s+2tR+m/zn6XWWVVnDvUKHkraH+vtpcms+07kE2f4V7IsfwzDDTID/8TIME3ACbP/4xY9hAkqQ81gxDBNsgmz/CvbFTzgCwhKwyNHPCu02SbI22S0y7Oz09CiL0eFlJUN7ikrFYdfpfSskqQJIV1QJ12O82JQ2hPaFpGaw9GFtktXdShKpghaRkEURUFJLZBsAPV1SRgh/JL8nKokEcZyUBtqFmkU+1CuXi7US2aGL9F+XZ2xyDkklEatYpimg6Uxo8fGseaZ0Kh4JcZUjaKiioVbO0M85uTai5qoCGfRrlq6bSmK0SDpNU2FyIfikz0NJXB/kqLaCp79qEZXKvCpPmCo/0GV0qVK5tsm90OPuApMFSeFCU1OZ0hllyXJZMqALFpWw9dQg7nZekRD9XsM0bUnIXR4W0LZPjh+VxEs+krYoUq6mY4m2kVRNSUMKsRJptKm0CwA9tdJOpmOyn+FuuZ0iWm3lL5pdst1dmuj1IzSbS1Geh0rlJHfZnrpa9W2fHlvqUkSvX/eUWa7z/FxDJgJs/wr2xY9hmOElyD4uDMMEmyDbP37xY5igEmAfF4ZhAk6A7V/BvvhZttUncwmz7GCMMDJEb3kV6VbwU7waUPtmkAqU4XBdAqERooaM5jRaLrufZJtkO+Ee2edEldyXhrF/Vpq/unui/EF2Jdwh20w+ZU/m+95RVUr7w4erM9/LPySRgIdlFnslIz3UiFeLhuiS5Zya4zLfQwdldQBAlbtF+2E5gx4LKlVome+tUNR9OWUhD6mCbidlqHDgEZWrXJtKVLApQtGj2oJlDS27/AA+LiPZ8BU8/ZU7KLpdE+4uKcoipupAAEScVOugEh51pyAo7hRaewXqtkDlTN3GKRkb3Ktw0AjPrHvER4UcRfY12NisNml3dw69CpDikkH6H/3wYOZ7RIvKpZWMLFOUNNlOslw95skyOa9njPwebZffiz4mx1+r9GHFyblNGs4zzbCg2Z8s15cB8JLn/Z4PE1YoBEs4wMAFRNwJsP0r2Bc/hmGGmQD/42UYJuAE2P7xix/DBJQg+7gwDBNsgmz/CvfFrz+qjaJH8JgSSJoSg+pDy6aEnjkmFvWLp1RB59Fo0U4pdVpFJEQXgNUrh+pFjLQh+xnqkd+7U6rUU1khI9ESB6UkkKyQ+z+2uD3z/YTSA0r7DX+sktuk0ac0AWpZidJG2Tcij/aMr8x8b/s0jbaW0wGg4k9yXL/4z+WZ73YXSRR9qIO014p6U0lLcQ8gEcJUXtfPme1+PVgk+lpxDzBFngOwUuQ4UdmZHkvD9oA+GWVIUb3MMYUiwUGVR/0kstXdVhRJlboqGFxdTBIwAGOEvNEuA+aITIN7j1eEp+I2QfQ7JRmwpbnNkL4p66L74uHqoxynLuLeQhJgW3q0Pz2HpgT2xGbYmrSajg4sjyqJnfWZKfdIYpNLiaerE8WHbJ81jxx/kySvZN5A9jUwlATOQaZwX/wYhhleAix1MAwTcAJs//I3nMUwzDFFfwJTrw/DMMxIJN/2b+vWrfjyl7+M+vp6WJaFJ554QpkvhMCKFSswduxYFBcXY+bMmXjvvfeUZQ4ePIj58+ejoqICVVVVWLRoETo71QDHN998E5///OdRVFSEcePG4dZbb8153/nFj2GCikBf4Kjpwy9+DMOMVPJs/7q6unDGGWdg9erVrvNvvfVW3HPPPVi7di22bduG0tJSzJ49G7290k1p/vz5eOedd7Bp0yZs2LABW7duxeLFizPzOzo6MGvWLEyYMAHNzc247bbbsHLlStx333059bVwpd7+dAaKj4C/dCxKwW3aXvcPUIp5Gw4F9YPQfVIUvxLir2AKede9RWnaA+pjQ9tHZDh/lo8O9csgbcKd0q8l0iH9Av+w6wR1+2nZ5zEH5PYTxK2uoeKDzPdvVagVx5+MnSX7FiZ+GcRfTcTUdATpUvk7fpzs28enS1+O5FnyH05psZoy4i/bR2e+16ak/2DRPpJFv0f62AitWoupGLmS9oVeC3rKBepTQn3xSqSPpOWRTgbdsj/Ux1C5Tqnvln7N0vQcIXtI6VyCXLLoWCSrOgz1kaK+U/T6pTZLv5Sp/aPTTR3Q06cY7JepjdB8/FT/L2KzaWoaxZZq/mLUzus7l5nh4SNrqJxh9EvUfMSVfiqVn0hfbM3HmPoP0tRWYff7P9StnnM7Sc4ZzZSTIn6N1N26V7WfwtBnixxbYaqIBO2YGaptGH3n9eUUDOfPozKHZVt9lVkGGYTh1/51dHQo02OxGGIu1aHmzJmDOXPmuK5LCIG77roL1113HS655BIAwMMPP4za2lo88cQTmDdvHt59911s3LgR27dvx9lnnw0AuPfee3HRRRfh9ttvR319PdatW4dEIoFf/OIXiEajOPXUU7Fjxw7ccccdygviQPCIH8MEFeHjwzAMMxLxaf/GjRuHysrKzGfVqlU5b2r37t1oaWnBzJkzM9MqKysxbdo0NDU1AQCamppQVVWVeekDgJkzZ8K2bWzbti2zzPTp0xElL+SzZ8/Grl27cOjQId/94Rc/hgko+fZxOeGEE/qSSmufxsZGAMAFF1yQNe873/mOso49e/bg4osvRklJCWpqavD9738fKb+RhQzDMD7xa//27t2L9vb2zGf58uU5b6ulpQUAUFtbq0yvra3NzGtpaUFNTY0yPxwOo7q6WlnGbR10G34oXKk3FAKskCov6MP2pmoXVAIxyb4ALDoMb8oCrwxha9unMoZShYGmkDGnI4ApWz1Jm2DRNnrmfVK5wiorlTNKpYRauk8+vZOV6um26Kq75HJFB2Sfuxw5pP1mgqRM0bCT7sXk9ez09GWCbp/KE+mUbN/dq0oNEdKFUC9dgaFaCz0ugJoehUqyVB4zTdch20yPItsh27A71WNGr1iLyr6KVETTwWjXLOnPkNO5uBSHyJqfA9u3b0eaXK9vv/02/vZv/xZf/epXM9OuuOIK3HTTTZnfJSVSrk+n07j44otRV1eHV155Bfv27cOCBQsQiUTwox/9KLfOHOu4pbPS7J1R3jXhUblIsU1+ZE9ASQ1CJcEsO9e/jN5/g22msrFpXS4rd29DpUKhSbX0eBiqMFke6ZiUyh00TRXx2bJK1MoZSkocQ7UV6upjJdQ/PaEEkXoduT/hXjk93Em2oaWDUvpJK3fQcyNIm6ShuhG01Fi6G0JmhjkFm3L+6fbpda+n49Ke7UL4vD7c8Gn/KioqUFFRMfjtFCA84scwASXfI37HHXcc6urqMp8NGzbgxBNPxN/8zd9klikpKVGWoQb1mWeewc6dO/Gf//mfOPPMMzFnzhzcfPPNWL16NRJeOeQYhmFy5EhmNairqwMAtLa2KtNbW1sz8+rq6rB/v+pHn0qlcPDgQWUZt3XQbfiBX/wYJqj49HHp6OhQPnFTjVZCIpHAf/7nf+Lyyy9XAp/WrVuHMWPG4LTTTsPy5cvR3S0T3zY1NeH0009XpIzZs2ejo6MD77zzztD3l2EYpp8j6OM8ceJE1NXVYfPmzZlpHR0d2LZtGxoaGgAADQ0NaGtrQ3Nzc2aZ5557Do7jYNq0aZlltm7diiQZid20aRNOPvlkjBo1ynd/ClfqdfpeuZXIKb1ItkHqUKN13SPfAI8II+FDAoY6VG3TYW+qvylyrvaeHSLD23RIPaJFgvaj+zoZqpI4JbJ9pEvuS+mH6v46VOkgf2/C3fL7PW99IfP9qZrTlfZFH8l9DvUQSTNhlgeo9FncIaXOvzpclvne899SXo5XqNVKKvbI9rE/kUoi9JgbstADUKME6fkwaab6dFrknEbypmi1AUPkr74+em0nDZU7NKklr5nqBzJuxLmZcsMNN2DlypWeq37iiSfQ1taGb33rW5lpX//61zFhwgTU19fjzTffxLXXXotdu3bh17/+NYD8+a+MBEQ6DWHZmjzqkdXAyyXGbRmv5YR7JK1uvwS55o1VPbxku5AhkpRIskY51mvdhsofOkY3IOp2QQ+ZHtVL10WiZ61iIu/qf5IiqutKBmozi8kx71Xv/1ibfAYkyuS6Qr2yz06RtCt2m3qDC1PlDttscyiKSwGNSibXhme1D1OUrkkC1it/aPMs4QCDdQH2af/80tnZiffffz/ze/fu3dixYweqq6sxfvx4XHXVVbjllltw0kknYeLEibj++utRX1+PSy+9FAAwefJkXHjhhbjiiiuwdu1aJJNJLFmyBPPmzUN9fT2APht64403YtGiRbj22mvx9ttv4+6778add96ZU18L98WPYZhhxW+tyr179yqSrFsqA537778fc+bMyRgsAEq6gdNPPx1jx47FjBkz8MEHH+DEE0/MfQcYhmEGSb5r9b7++uv4whfkQMmyZcsAAAsXLsSDDz6Ia665Bl1dXVi8eDHa2tpw/vnnY+PGjSgipVjXrVuHJUuWYMaMGbBtG3PnzsU999yTmV9ZWYlnnnkGjY2NmDp1KsaMGYMVK1bklMoFGKLU++Mf/xiWZeGqq67KTOvt7UVjYyNGjx6NsrIyzJ07N0uTZhjm6OPXx6Xfubn/M9CL35/+9Cc8++yz+Md//EfP5frli/5/yfnyXzlSsP1jmGOXfPv4XXDBBRBCZH0efPDBvu1ZFm666Sa0tLSgt7cXzz77LD7zmc8o66iursb69etx+PBhtLe34xe/+AXKysqUZaZMmYIXX3wRvb29+PDDD3HttdfmvO+DHvHbvn07/uM//gNTpkxRpl999dV46qmn8Nhjj6GyshJLlizBZZddhpdffjm3DdhWlkyWFeFlSGCqtCHTbS0q1qHJcA0Rwqbi0YAWyWaS4JQoJI9klHQIne4nlQO9ovzIvoTbpIQaLZPtqewLAKliub5wN5EKIqTI9zvyovvvFhmBCQDl7aRraXd5U3R2KW2UKGUi3UdIhHL4oBxdqujRpBIa8ddtiDKmRb6LValYkONs0XVTGYsmU9Vla0WGJTJ+F+kL2a+sIu00OTORjWliZmUftevKJI8NijxLHf088MADqKmpwcUXX+y53I4dOwAAY8eOBdDnv/LDH/4Q+/fvz6Q12LRpEyoqKnDKKacMrjPDxHDbPysShmWF1cwBupxqimSlTyxP2dNH0lxi/wZ3ORgiN2GO6jTtS5aNppIstdNhg6uMh9SsYJhu6W4b1KWEZm+gSeP1qFoqr9LnEbFTgtgip0KNCnZIovwIsdk0q4ITJn3Ror0tQZLbK9HPVPYlfdb3mbYxFUfwkNdNSZ+NEb4aepshub4Mk/07FhjUiF9nZyfmz5+Pn//854pDYXt7O+6//37ccccd+OIXv4ipU6figQcewCuvvIJXX33VdV3xeDzLeZxhmCPAMDg3O46DBx54AAsXLkSY/Gn54IMPcPPNN6O5uRl//OMf8dvf/hYLFizA9OnTMy9Ps2bNwimnnIJvfvOb+K//+i88/fTTuO6669DY2OhLXj5SsP1jmBHAEQzuKDQG9eLX2NiIiy++WMlCDQDNzc1IJpPK9EmTJmH8+PGZ7NQ6q1atUrJi647kDMMMD8ORzuDZZ5/Fnj17cPnllyvTo9Eonn32WcyaNQuTJk3C9773PcydOxdPPvlkZplQKIQNGzYgFAqhoaEB3/jGN7BgwQIl718hwPaPYY59jmQ6l0IjZ6n3kUcewRtvvIHt27dnzWtpaUE0GkVVVZUynWan1lm+fHnGCRLoC3EeN25cJqrXSbsnOdZRhoqpnAf3xKBZ6zNEG3lJa5ahviSVdJVIuIgWoWSoyarW/SXb1LdPI5lJomSrS0oNsQNSTnC07cc+lv1MK5HAss+xNrl8KK7+T4h2GO4MxxBhBzX6TRn2J5FwVieRSvQIMXrOqKRLj3+pXFf8ryqV5qki2T7cI49Z9MNDcl16fV5lB4Trd6uzm0w2R/UKEjEnaCQ03S/SJkteojjCHI3sg+Go1Ttr1ixX+WXcuHHYsmXLgO0nTJiA3/3ud7lv+AhxpO2fUt9Wk9AUeVRJOmyob+5R91SVjQ3L+I2qNUh9eq1eP33x3d4jUbOvNl7yZP/iHveaZZB9ddlYqclOXTqoLYhJVxcnovYrXiXtXLKEnH9b2u/ij+Xyib+qUtrT5M4h2k/6/Ii4J6Pu2w5pY3I1oVKtlzuKqdav13XqNS9HglyrPKcXv7179+Jf/uVfsGnTJiUSZSiYCh4zDDPMBNjHZTCw/WOYEUSA7V9OUm9zczP279+Pz372swiHwwiHw9iyZQvuuecehMNh1NbWIpFIoK2tTWlHs1MzDFNABNC/ZbCw/WOYEUZA7V9OI34zZszAW2+9pUz79re/jUmTJuHaa6/FuHHjEIlEsHnzZsydOxcAsGvXLuzZsyeTnZphmMIg33msRjps/xhm5BBk+5fTi195eTlOO+00ZVppaSlGjx6dmb5o0SIsW7YM1dXVqKiowNKlS9HQ0IBzzz03t559ks6F+ujpmdPhkeHbFS9/A1NqBFPKA2h+ZUo4vCGFi+4jYgpbN/lR6PtItm/RFCQ0hU279D3LGt4lbew48aUkqVmSJVKGoqkEAKC0lWyni/ju0fNSrBUppz5uZJugqSrIMpYuqVH/t1KZXsYpk8v1jpUpaNonqqkdkhWyfeygPH6je8sz30MHOuU24noKDVrMnPjoxN0Lnvv1a6KpOkwF6wGo14Nt+fdnciHIPi6D4YjaP9FXQd4rtYUwpdAwpDnxxt3OeVYOUbY58DWflc7FR98899/g/+h3+9SeKlWg6D1Fba6+XoOd93oWWTSFC7Xf1K+O2GUnqlVbIk/sBLFl9HvPcdJmd45X+xzuknay8gNpJ8s+lPYn2ipTa2G/ms5KqVbiJ52UVwoy0/n3qPaiLmb1natBvqAF2f7lvXLHnXfemck4HY/HMXv2bPzsZz/L92YYhhkqAfZxGS7Y/jHMMUKA7d+QX/xeeOEF5XdRURFWr16N1atXD3XVDMMMI0H+x5sv2P4xzLFJkO1f4dbqTaf7hnw9htqVbO0RQwi5Mpzvkc6FTo8YDos2tK0Uo/aRDkBPzWFKD6CkdokainoDSlUJQfeFyoaeUjEpBi4VYUQScr8qqRyrVy6Jk372uhdpz6o2oGTYD7tOR5RI6FrBcJMkoi4k+0mlXQDoOU5uJ3ZQTk+TwuYhKuHqBcuppNQrq5IoRcoTRHsYanUN7Zq3ikjm/Z4ej9wbftYNb5lkBPu4FDyW3fcZRPoKkwTsV2pVlvMpu/mRbbOWcajbApE9jVU8zOls/GxT375lqipCt+O1X3QebW+bnwW0Qo/Se9qGpnxJq9u33QtUISk9VdB7kkzBsmTqC8pyOw4fn/n+cpOshiNsaVeqeuVGQge1ZyE9HySFjfIs86riYbKHPp6f+nJDrtwRYPtXuC9+DMMMK0H+x8swTLAJsv3jFz+GCSoB9nFhGCbgBNj+FeyLn3AEhCWU4fisoX4iXSrVLgxD9b4if7U26gbV7SuSLC28QGU/Khvqw9KKVE0rf5DC7KTShS5BK/JuZ5frcoLKqXESeQvAsknELZWtSftQW7frdACw2g4b5xmh+0YlDdpP2hdd3k/R6GNy/FMyWq14r2wzRhANRCMUl2P50Y/a5bqIbK2fM9FNjjOJ0DNVa8mKfLPcXRKU65dGGIbUa87pkufDj9TlhSWEUj3AbT5zdBDptGrH4H2+TdG3nlKnIfpclVc9rg/bUO3I0M+sykdhd5vhJe+ayGeEsLJfPqVu5ZhTVxu98o5SecjwPCJycKhTdZUp/guR7oW0P+3FpJ+dcvoz+ycr7fd1yKogxa2yTbhX7lvosHuGBkC1TSZ511TFCtCOs6laBz3m+vnPa+WO4Nq/gn3xYxhmeAlyHiuGYYJNkO0fv/gxTFAJsNTBMEzACbD9K9gXP7soCtuKZkeFGlAkQNNQsx7VRtdtiH5TJQAtqjXknlzaoZFbEUPkqt5/JVqKbJMm/NSH3Q0JrBXZkRb/1ve/p0f+oPvfSeVdsv2EGuFKI9SUeV5Fuqk8rxRWJxFiJCo2SyohqxOGCDMclnJsSYf8DgCiSEZJWz1S0qDHQjlLSUMYHVQZHkphczJdi/AT2jHM9IVIuqpUrP7ttElUr9MbH1JUW5Cdm49FsqTaMHU1MESo0uU9onpVm2eOBFbaGyPWqd8Lle00twlT9DHdr5T7/dK3oFzOKM96YLafcrodpfeivgIPO5VZgdk9ibq0CLquuHxm2CC2GABNR2+R8xftkOtNvie32dY0TmlfFpdtSv8sbWP4ENnOQen2IrrJMwJQ7KzynKWuAtQmadKscj2ZZFuPBOS0vRUJ98mxqgeTb4Js/wr2xY9hmGEmwP94GYYJOAG2f/zixzABJcg+LgzDBJsg27+CffETaQfCGiA5rSIpqm1d16nJdnaMJMOlEaY0wpJKc15RvUTeoPKusi79LwQdtqZSAUlg7JUM1CLzlPameohaFJ0gMjBNDAwlGbFZajdKkjQqlxxjAGpksSEBqhLJqkViKwlQaSg1XS+VbXo0qYLIsNQ9QNlPQ+RxX9+ovE+jxx336boEZIp4NFx/WZHcmjxlCWdIiUZHspxxLGPZFizL8nQ1UaRSJSqSCoIetcZ9SsIeK3BtY4oKzup/itbaJdN91mA37j8GlnABs1SuSI3Ulul98fHMyarPTu9tOp0eP5rJQVtdKC3riIfa5He/9kdQ23qwTX6nNo/ui2M2Lia3laGiyLuaHEzdEOCkIITZFccPQbV/BfvixzDMMCNE9oNJn88wDDMSCbD94xc/hgkoQZY6GIYJNkG2f/zixzABJciGj2GYYBNk+1f4L37Ur0JPh2LK8G7yXYHmL2by6yN+HTatzqD7ewl3vzTqI0H9+vQqDMZUHIq/iUdmcbo+JfM+Cbmn/Y+r/nqKXx/df1MVipTqT0F7ZlF/SZolR/cxoX6G9DhRHzt6XmT2laz+KP4f9Nqgjht6DoaIXKGyP6bUFPo1F6bOSOSYEx9DJc2B1/lT/DLd/QV1v1TTtT0oAhzVVvBYNmDZSkWgLB81QwoWJQUKLWrvkU7KWG3Dw8fQtJw2w7WPAIyVK8z+guZKJlnrdumX7i9Ij5MVJYbG4HvslY5LsUVeFaJMlYuUhYjvsZ5CLEn22fD8ArXrKe2a6SHrpn0x+evp6agMdtJUrcq72pV75Q71PGnHUk8PI6zB+zgH2P4V/osfwzDDQpDzWDEME2yCbP/8ZbpkGGbEYTliwE8urFy5EpZlKZ9JkyZl5vf29qKxsRGjR49GWVkZ5s6di9bWVmUde/bswcUXX4ySkhLU1NTg+9//PlKpoUXuMQzD6OTb/h1LFO6IXzqdkTuMGAtok9QqNJxfS22gyLt0eJq2odP1C8EwpK9W6zCE2QOqvGhTqZgMhztmCYHKgMo2k2S9HpUnFKmFpkOhsq2hIgoAc5FuWm1EQxEuDFefmmZFlSCMMio9TrRIelTVikU3yVBvkGEVCaVIS0dD5RF6bC1DahsNYwocQ1909wC1n2lz9ns/DIPUceqpp+LZZ5/N/A6T83X11VfjqaeewmOPPYbKykosWbIEl112GV5++WUAQDqdxsUXX4y6ujq88sor2LdvHxYsWIBIJIIf/ehHuXfmGEak0xCWrdgvr8obCj4rV8Ch9mdojwI/sqvfyiHGah8eqT38pKDJkinpPWuypSbZFwAM+6mgb1OzR5ntUztL7a9eOSPqXiFIcbvplWm6vGwRkrTaksHVRLdLhuNhTKHm4Z7gp3JH9iyt+stQIm9Z6mUYJmj4lTo6OjqU6bFYDDE9P+MnhMNh1NXVZU1vb2/H/fffj/Xr1+OLX/wiAOCBBx7A5MmT8eqrr+Lcc8/FM888g507d+LZZ59FbW0tzjzzTNx888249tprsXLlSkQND02GYZhcYamXYZjg0Z/HyusDYNy4caisrMx8Vq1aZVzle++9h/r6enzqU5/C/PnzsWfPHgBAc3MzkskkZs6cmVl20qRJGD9+PJqamgAATU1NOP3001FbW5tZZvbs2ejo6MA777wzHEeAYZig4tP+jUQKd8QvFAKskCqt6QWbQ4Zi4ARlCN9nVK2x4HZIm65EJRkuEo8s6sp2LEP0GKnioUfVKu0jhmofHlKRAm1PI6yovKv3n8quRWQ0xiOqzaKRxUSqoFVFlH7aReoKkqR90l0q94RKD7Sf9DjRaF2tcomxQgpFiSTUrrmUuzxswktqEY4YktThN53B3r17UVFRkZluGu2bNm0aHnzwQZx88snYt28fbrzxRnz+85/H22+/jZaWFkSjUVRVVSltamtr0dLSAgBoaWlRXvr65/fPCyQ+C9abZFPPyh96xKTbdgwuNJ5tfGLqp7HaiGdUr6HPtLqI7ipjivg1RRL73UePSGRF+qTbJ/ZXsTl6VC2ptgRDnxXZNUveNtksQ7US3UYZrgfFPYlWYfKoNqO4YRmOrdcza6iVi4KcziWnEb98OG8zDFMY9EsdXh8AqKioUD6mF785c+bgq1/9KqZMmYLZs2fjd7/7Hdra2vCrX/3qCO7V8MH2j2FGDn7t30gkZ6n31FNPxb59+zKfl156KTPv6quvxpNPPonHHnsMW7ZswUcffYTLLrssrx1mGCZPOGLgzxCoqqrCZz7zGbz//vuoq6tDIpFAW1ubskxra2vGJ7Curi7rRan/t5vf4NGA7R/DjBCG2f4VMjlLvUNx3h4UVILTlQbT8DCN1qWhOdpQv2VIRqkkMCZD8FlRrXRI3FTMmm5TH7anEauGpMlqtKzZud0YlUYlgJR6vKyQQfakREiErk9ZMVVdKrehJ71OF8tNHjgsZ3SRaFt6KGm0MaDIq14F2DPTNalWOQemNh6R3EJR7g3JVE3JTAFzQnIPeciEZVsFncC0s7MTH3zwAb75zW9i6tSpiEQi2Lx5M+bOnQsA2LVrF/bs2YOGhgYAQENDA374wx9i//79qKmpAQBs2rQJFRUVOOWUU4bWmTxxpOyfZVvZLideBes91iOX106oIbmymkDZY90Gm2G6Fz0xJfBVouV9rtcy7MtgHuReUfOmogEe50WVN6mk6p4YPstG0eeM4h5kmK5fQ35sHsVnJLPyzPHYnuncWrbPBNiOmoBaeF2gAxHgqN6cR/yG4rztRjweR0dHh/JhGGb4scQAeaxy9B/813/9V2zZsgV//OMf8corr+ArX/kKQqEQvva1r6GyshKLFi3CsmXL8Pzzz6O5uRnf/va30dDQkHkpmjVrFk455RR885vfxH/913/h6aefxnXXXYfGxkajvHykYfvHMCODfNu/Y4mcXvz6nbc3btyINWvWYPfu3fj85z+Pw4cP+3LedmPVqlVKxOC4ceMGtSMMw+RGvn1cPvzwQ3zta1/DySefjL//+7/H6NGj8eqrr+K4444DANx555340pe+hLlz52L69Omoq6vDr3/960z7UCiEDRs2IBQKoaGhAd/4xjewYMEC3HTTTfnc7UHD9o9hRg5B9vHLSeqdM2dO5vuUKVMwbdo0TJgwAb/61a9QXFzs0dLM8uXLsWzZsszvjo6OPuP3SQJnz1qRhgTOgtbQjXhExZqGlGlUpyLBeUS1pgzD9nS1vapsaRweVxYyDOfri9H9VCKZPYbN6SgKlZSpvEv3S5O6qQyQri7LfE9WSkk6XqluP3pYbqc4QZOWym1ah+SoR1bCTh9VHOg+O17n3CtRaT9ZUgd1HRhYds6qVUy3Y4g+VPvrlcDZ6lvHYAtb5FnqeOSRRzznFxUVYfXq1Vi9erVxmQkTJuB3v/tdbhs+QhxR+/cJiv0LmxOj+5JBddnSjySqJFP2V7dV2QS9L1JaPViPiFvSGffv0ORpw3b8yOGAOSpV3Z5+Q6Rdv5pcbQDA6ZEJmen5VN2GzFkBTK4qinsSLQbgmcDfPZOE8lzTEzObomxNrip+k4kboqc9E0Bb9pCielnqHSS5Om+7EYvFsqIGGYYZfiwhBvwwZtj+McyxS77t37FUsnJIL379zttjx45VnLf70Z23GYYpHKy0GPDDmGH7xzDHLsNh/4YS9d9fsjKRSOCVV17BQw89hAcffBArVqzIy/5ScpJ6//Vf/xVf/vKXMWHCBHz00Ue44YYbXJ23q6urUVFRgaVLlyrO2wzDFBABljoGA9s/hhlBDIP9O1ZKVub04tfvvH3gwAEcd9xxOP/887Oct23bxty5cxGPxzF79mz87Gc/G1zPPqncYRHnCd3Hwo7SAUsa9k99pwxpAgBjCL2StoX6VCRVHxXTdWHyt7OL1SoUiv8C/W4bfFe8hp5p2huTv5juL0H3n+4z3Wap2XfJKZE+gskq+f3wX8l19Y5RfUIinbJvoXhJ5ntszyH3vujpYOgP4Z7CQPHX0VPwkPQudP/9pIbpW879OlP6RX1U9KtE+EhbQNsPNMw/pHQGwjtFD0u9CkfU/n2C4nvn4SNnwlidQptnrPyhpIPy5yOobEO5FzUfRa9UKW547K+pIoS6Oc2WDDHVi9Ev0avaFPXrS7v7CFIG8nFzbePl10ePucH/UXl+6ufIofYv7b6cZb7mFAw+hsp0/bjofv25XkMUn/Yvl1rl/VH/RUVFaGhowKpVqzB+/PgBo/7PPfdcY8nKK6+8Eu+88w7OOuuswe+rRk4vfvlw3mYYpjAIcpHywcD2j2FGDn7tnx5pf8MNN2DlypVZyx9LJSsLt1YvwzDDipUWsDwsH/v4MQwzUvFr//zWKh+OqP/honBf/D5J56LICRFVTnBI5QulwoZHCoysbfTjUWEjs15dYzdcAMr2I3Ro3WPYnqYAoMPeUZLmxK/0RrevSMBa/02SSDHZL5pCJqwu7xTJPifLQuS73K9UidIEgqwiUSHbx+j+U6mCpD/o6wNZjlb1oPsyiCgoo7yrT1dkaFrYnMi+pjQ/XpiuRa90FPZQ07mw1FuoiHQawrKNlQ76fg6cgkWpiOCBL9nT7/YNeMmWg6qqYViXNoN89TgWpiomio1U+2+yGbRN1jZzlCY9U5iZ1uvlAmBIgeZreX2W6ZnlgSLJgxxbpS+0WpdZKhaO8HZ/GrAz/uzfYKPtadT/3/7t32ai/umon16y8rXXXlPWMVwlK4cU1cswzDGM8PFhGIYZiQyz/cs16r+hoQFvvfUW9u/fn1lmuEpWFu6IH8Mww8pAuao4jx/DMCOVfNu/oUb905KVt956K1paWoatZGXhv/hROUCLVqLD4EpUJq1coQxHa0PbEfdM+Eq0Kx1qjmrLe2VY759O5VGhLVMko3wFlS3pBedVOYMuR/tCqmCo0bpeEgCN8HWXvZ0SVSpOlZMINZpQnrgzxGvVcxY5KNedKJON0mXywg73yGORJa8rRc5J9FxPL1zRpAIqnPiRd/XtmyKGaSScIu96SBX0OhOGzPVe1RZEMgUhhpDc0xGAlx/fEOU3Zuh4SaB+InG1BupvP1UVPKRBY0C5qY2+PeW3KULUQ5qk94LpWNBIaC/ZUqn8Qe4pKrV6VT7xmRXAtE2j7Kr3WZGkDVWtvI65YTvG6G8vOZjupinCWJf3TVVNaHvT9HyTZ/s31Kj//pKVV155JRoaGlBaWoqFCxcOS8nKwn/xYxhmWOARP4Zhgkq+7d+xVLKSX/wYJqgIDODcfMR6wjAMc2QJsP0r+Bc/RbbVIpxUqU0OD9NEyUrUjy77hQ3DzkRPVyRcS4uwCtPoXUPSZ4o27C16iaQZM0TS0nVpUrUgvxXZUElGTSQILSqX9lkQeViQdaUqZb8Slerl4oTlct1jZD97R5PtF2lFyiOkP3TXYnLd6aqyzPdQu3bM4wm4oVwLCfdl+hZ0j/4zya5Zso0pObOSjNQg20JLAC08JF0fWLYFS1hDKFLOUb2FihUKwbI8kt9CvTaFIfpbtZne6xu4Ux5RvSZ502fSZaWJ4s7hLwG1aZtW2ONeNkTywjZEUmupP/zsvzHaOGv7PqVWMs8OU0nbp8uHwbaZig5k9V/JOGBKukyexZp7lDEK16+8TyOmBdu/wVLwL34MwwwPVlrA8vhby3n8GIYZqQTZ/vGLH8MElQD/42UYJuAE2P4V7ovfJ7V6vYazFUmTSnVU6qNDwx5Fjq0SEopqiOTNkkrJb6eUSLWKbEgmJ7Uxaaoi0ATASRrVRCKXSbRr328SyRoj+0blXdssVStRunQe+U7l3HRUbS/I8H6IHHInKs9LuEitL5oqkZdcvEr2Mz5aHueSXnme9WNu9VAZnEYfk2NGorV12ddYx9MUiatLOD7q65oknL5+GupTmiQUnSxJeQhRbwE2fMciWdeSIarU8/ozoGRIMCRW9pQtDXV7fbc3riv3faGRvLQ2bvb2DbbAVJ9Yk61N/fHaT2GIWPUdlUvaO6Z1edXHJev2lQlDx08krlfSZZOMbLJ/+v7nM9NAgO1f4b74MQwzvATY8DEME3ACbP/4xY9hAkqQfVwYhgk2QbZ//OLHMEElwP94GYYJOAG2fwX/4kcrImT5DtDUGtSVjaT2sIrcfe+yoP4OZSWZ76kxMrWI0Hw3UiXuvgxORHYm3C19H7rGqqHtqWJ3H7niv0g/iGi7nBEKaelsqF9OyuAXmJD+Lk5lqdrPKAnhJ+t2YsQvkhz+aIfq72aniP+OoNVC5PRizcevs4JU7qiSfpXJv5AqHkXk/PWox8xS0tsYUrsoVUg8qp0MBkO1FiHcfVwsmNPBKAwiHYYVCcMSDpA0LuKNI7JSVGTNZ44Olg1Ytu8qEObV+POr8+s/Z2yjpN0g17/B3w8wV7tQ/Pp8VnFQU6uQbg3i+Ck+ckqlHM3e2O77SfHaZ+Nyjrst1/tjSnvj18fTipDnhDBcJ/rxM50DQ+UhvVgVRfH/tAzXksczv2+bQ/BxDrD9G8Z6KAzDFDT9/3i9PjmwatUqnHPOOSgvL0dNTQ0uvfRS7Nq1S1nmggsugGVZyuc73/mOssyePXtw8cUXo6SkBDU1Nfj+97+PlN88ZQzDMH7Is/07lij4ET+GYYYJ4WTXr9bn58CWLVvQ2NiIc845B6lUCj/4wQ8wa9Ys7Ny5E6WlcrT5iiuuUOpPlpTIEfZ0Oo2LL74YdXV1eOWVV7Bv3z4sWLAAkUgEP/rRj3LqD8MwjJE8279jicJ98esfhvWbAoBgmULDtariFnkYiVIpO6ZGy+mpYpJypFqVHWm1CkE2GWuT20ycIA9x+2fU7YfGyHQsqTaZWqVil9xO+Z/lNko/VP+BhHqJxmeTYXMij4tiUoWkV9UE06NL4IZNUhhQeTvcq1UOMZ0bspuJpFbtIyX3xybKCVUabJLOxkp6jPTYpnQM9LhoKRhItZTBXFu0jZKF3o8EApiNiVcKGQqVUZyUKjHniiMAr7pEOUodGzduVH4/+OCDqKmpQXNzM6ZPn56ZXlJSgrq6Otd1PPPMM9i5cyeeffZZ1NbW4swzz8TNN9+Ma6+9FitXrkTUIyXTiMK2AMuCBXc5FDBXjvArO5rShpjWK1Jae+pS4pVCxICyP4YqGl7rNVYuMaVJ8ZCKjVU0bEP6qKzm/lK7mNLbKMvZ7hWp/G7Tdwodk4zu9743HjNztRglVYyp8gdySG1lkqj9kGf7dyzBUi/DBBXhDPwB0NHRoXzi8fgAK+6jvb0dAFBdXa1MX7duHcaMGYPTTjsNy5cvR3d3d2ZeU1MTTj/9dNTW1mamzZ49Gx0dHXjnnXeGuscMwzB9+LR/I5HCHfFjGGZ48RnVNm7cOGXyDTfcgJUrV3qu2nEcXHXVVTjvvPNw2mmnZaZ//etfx4QJE1BfX48333wT1157LXbt2oVf//rXAICWlhblpQ9A5ndLS4vfPWMYhvGGo3oLF6+M4jSqUonKTRmyg+sRnmmDpEgLKvQSOcFWpV6b5PnpHuMeIdX1V2QIfJQaFVZVIUc6DpHpDtlPGlUrtAgvJZKXDtsTedPqlnKyHtUbaSfzikiGe1o5hMo+2vYFif5NFcl5sYNy+/GQKieHu+S8aIecXnyAngvDfulQh3/674z6beg3r0n68JuF3tAfRWozRAVm/aZSiSmj/UD/OofyrzQ9wL/aT47j3r17UVFRkZkci8VMLTI0Njbi7bffxksvvaRMX7x4ceb76aefjrFjx2LGjBn44IMPcOKJJ+a4AyMXkUhA6BGHXteSHj3evx6PqFhf8ixt41NVM8qT+vaViN+BxSe/EbIeK1B/Gu5ZkzyqP39oVSC/ffGKcnZbhlYeAfxJ+trKzPOo/aHVTrz2hfbNIs8ppY/UFpvdCywfdkRHqbDkDDEAw6f9G4nkLPX++c9/xje+8Q2MHj0axcXFOP300/H6669n5gshsGLFCowdOxbFxcWYOXMm3nvvvbx2mmGYPCAwQFRb32IVFRXKZ6AXvyVLlmDDhg14/vnncfzxx3suO23aNADA+++/DwCoq6tDa2urskz/b5Nf4JGE7R/DjBB82r+RSE4vfocOHcJ5552HSCSC3//+99i5cyd++tOfYtSoUZllbr31Vtxzzz1Yu3Yttm3bhtLSUsyePRu9vb0ea2YY5oiT53QGQggsWbIEjz/+OJ577jlMnDhxwDY7duwAAIwdOxYA0NDQgLfeegv79+/PLLNp0yZUVFTglFNOyak/+YbtH8OMIDidiz9+8pOfYNy4cXjggQcy06hxF0LgrrvuwnXXXYdLLrkEAPDwww+jtrYWTzzxBObNm+d/Y8IB4MCOyqFuZQgZUCIa6VCzRSP/6FCz1h4kUTA9yXZCDieni+X2iw6qEaaWEyZt5HSbKB1Uzuw+ICOHAaA7In+XkPajdsnt0ATQ4QOdav+ppEJlX4dEtZIE1la35pRP5oWIbG3FSdLnUjK6k5XAWh5nixzn2AGSmLpXlQ2KW0lyZ3I8Ix0kUfWBw7KBFtUrDPIulUqp1E3lGEBN7qxcT3TfHIPsCxilEzsmrwUnQWUT18Wz1mVczkvOcQSGlsC07x7znu+fxsZGrF+/Hr/5zW9QXl6e8cmrrKxEcXExPvjgA6xfvx4XXXQRRo8ejTfffBNXX301pk+fjilTpgAAZs2ahVNOOQXf/OY3ceutt6KlpQXXXXcdGhsbfUnMw8kRtX+fQKU+KscBUJMUKBG6VB7MPSrUKHX6jYI3yYtZstrA8qjfBM7G9l4JjH3Is4q0qkvVVIY1Rbhq21DOoSkZs2JzhpbAOwuDtGncFz2SnCa0FoZzQ68TvT0trkCPja9oX0B0ptR5Q4rqza/9O5bI6U767W9/i7PPPhtf/epXUVNTg7POOgs///nPM/N3796NlpYWzJw5MzOtsrIS06ZNQ1NTk+s64/F4VtQgwzBHAMcZ+JMDa9asQXt7Oy644AKMHTs283n00UcBANFoFM8++yxmzZqFSZMm4Xvf+x7mzp2LJ598MrOOUCiEDRs2IBQKoaGhAd/4xjewYMECJe/f0YLtH8OMIPJs/44lchrx+9///V+sWbMGy5Ytww9+8ANs374d3/3udxGNRrFw4cLMP3y3qDxTRN6qVatw4403DrL7DMMMmjznsRIDSCPjxo3Dli1bBlzPhAkT8Lvf/S6nbR8J2P4xzAgiwHn8cnrxcxwHZ599diaD/llnnYW3334ba9euxcKFCwfVgeXLl2PZsmWZ3x0dHX3pI/prVVJpTx9qp5IulfBoGxqtFdUipHp65LxiKbuGPpb/um1StzfUpR6ucKf8XZZy/3cgSORxxf9qUmmpbB/uIvJuh/QHssh6s5IZK3UL6f67RytbQkumSSJ+Rdhd9rB7iOxbrB6/yGF6buTXUJxIHXpgIhn5L/mzjGq2u6QMLaI0wljbZ5q0lSaqppHcVE7Qa10q0Xvy3DgksbNnVK6hjiTti+KeoJcaMyUXV6Rm6p7gIfUMQvqiCOFAeES1ec0LIkfS/lnhCCwr4h1tSWU3epn4lGpNUa1+6/aa6sMaZUuPqGQlUbKyDbJMxJyVwRhVT/s1iAhZswRrjtD1iso3Saqm755ytClDgIdUbKwVTI9FxCDHAi61cl36TKJ9oblnmBI4W6R6jzOqjDRQz0vo43a5ycOdsIUF+EsrmkWQ7V9OT46xY8dmOVhPnjwZe/bsASCj7tyi8kwRebFYLCtqkGGYI4AQfcbX9BnBzs2Dge0fw4wgAmz/cnrxO++887KKrv/P//wPJkyYAKDP0bmurg6bN2/OzO/o6MC2bdvQ0NCQh+4yDJM30umBP0wGtn8MM4IIsP3LSeq9+uqr8dd//df40Y9+hL//+7/Ha6+9hvvuuw/33XcfgD5Z7aqrrsItt9yCk046CRMnTsT111+P+vp6XHrppcPRf4ZhBosYwMdlBP/jHQxs/xhmBBFg+5fTi98555yDxx9/HMuXL8dNN92EiRMn4q677sL8+fMzy1xzzTXo6urC4sWL0dbWhvPPPx8bN25EUVFRbj37pEi5Z8i/KeomQnzEqO9bZ5eyGPUrEHGS9kPxV5Dt7YR6uEIHpf+NKHJPeyKoT1lCTccQIf23qL9ap/R9U/wS9X8g1P9EW7ecQS7eXs0ZgvrCkb4I6odB/AXtbi1zPkl7Ez4sB48j5SSFjJ5tn/rCdZNjTv0SD5PzpPvokf1Rzq1hmayAA5pqhfqy6P5D/QymYDlNMeDTD0/ZF+Hzn+YQ60kKx4GwgunjMhiOpP0T6TSEZXv6mxp99JJmv2jj9kz+eiafNPirvOHpO0jbJwdOLZOVmonaVoMv3mB89EzLeKWzMc7zOmc+tp9VrYS2ofvj1y/QgGVKweJ1/dBjEyL+9mT7dqlauUkQn3lRKu+J7r+Sfn0fT1F9MSnH7ZDLFX10GCIdB942d9GLINu/nEu2felLX8KXvvQl43zLsnDTTTcVRPoFhmE8SDuAh+EbyUXKBwvbP4YZIQTY/hV8rV6GYYYJIeCZwHQESx0MwwScANu/wn3xS6czKV0y6EW2LUOoP5UtbY+happqg0qqKXLCaTqUrHQqZHidSJU0hYddQqp1pDQJzyBVWyQFTFZRaopBnkZEDrsrEnBSk0qI/CSSRAJNUXmHyKYlqlxl0QoBKZqOhsixepobejxJ36gMT+VxZR8BVVKlKVxM8oZH5njl/CmyubZNZfNUajYYBo/M86Z5phREWWTJMINP6SIcAWHaBwycl48ZRj6pXESrcOhSpbJ4yuDqQVO+6LLhIOTR7D5mb0ddxOP6SrpX4VGWoZvXZVNTCpXByNumZUxpYjyWU7fvkU7FVEXDQx43bce3vGt6niqpgeg+a+0VSZlWyHJPc0XdrgBAlEg3oGS1fDYeOE0ul54qKzelU+q5/DhVmvk+9nAR0tojOReCbP8K98WPYZjhpf/lwnM+wzDMCCTA9q/gXvz637JTov8frHnEj86zlHk0gaa5vfKyT/9ZOWQkyRmoVmr2NoVD/jFRp2fH34ifMmJJ/3Xo/1CF4R+z6XoV2ogf6RvdDg30UEb80tqxSBuWs4nTtV4fOU2PLRnxc0jf6N9MoY1kKEEUhlEOuri2jGW6mQU9Fub1KsfJlIBVuWbNwSnKPOHuqJ3dASVTb+Y+Gcy/02S6F8KjFmgKAx9fJr/o9o/aKM+gH+M1Yx79soR7QJElDPbHc5vUFtP15h4cZcbvvogBp/uGjnB5JvtV70sTJpvhu88+jrk3puehew3erH1WjoehX7TuvaMGFDppObKXIqN5abJYmhQWcLQRv3RcPhtSqV6kUvFPNsn2LxcK7sXv8OG+Yd4X07/NreFgzlHXwIswI4whSANZDNcfwkH08fDhw6isrPS1bDQaRV1dHV5qGbgsWl1dHaK0Qg4zrPTbv5fwFCAwOLtG8Xoemq7fwdwjyp/oQbTPdRs6pm3msy9+j8tg+pnrMvp2huuYe63XdDx6yffD2rwPDW22+u5RBppRk+1fbliiwIRsx3Hw0UcfQQiB8ePHY+/evYHMZt9fuimI+x/kfQdy238hBA4fPoz6+nrYXv6sGr29vUh4+DL2E41Gc0/FxAwatn99BNkGBHnfAbZ/R4KCG/GzbRvHH388Ojr66uUGvYxRkPc/yPsO+N9/v/90KUVFRSPSoB3rsP1TCfL+B3nfAbZ/w8nQqrwzDMMwDMMwxwz84scwDMMwDBMQCvbFLxaL4YYbbkAsFht44RFIkPc/yPsO8P4zfA0Eef+DvO8A7/+RoOCCOxiGYRiGYZjhoWBH/BiGYRiGYZj8wi9+DMMwDMMwAYFf/BiGYRiGYQICv/gxDMMwDMMEBH7xYxiGYRiGCQgF+eK3evVqnHDCCSgqKsK0adPw2muvHe0uDQurVq3COeecg/LyctTU1ODSSy/Frl27lGV6e3vR2NiI0aNHo6ysDHPnzkVra+tR6vHw8eMf/xiWZeGqq67KTBvp+/7nP/8Z3/jGNzB69GgUFxfj9NNPx+uvv56ZL4TAihUrMHbsWBQXF2PmzJl47733jmKPmSMB2z/JSLcB/bD9Y/t3JCm4F79HH30Uy5Ytww033IA33ngDZ5xxBmbPno39+/cf7a7lnS1btqCxsRGvvvoqNm3ahGQyiVmzZqGrqyuzzNVXX40nn3wSjz32GLZs2YKPPvoIl1122VHsdf7Zvn07/uM//gNTpkxRpo/kfT906BDOO+88RCIR/P73v8fOnTvx05/+FKNGjcosc+utt+Kee+7B2rVrsW3bNpSWlmL27Nno7e31WDNzLMP2j+1fPyN539n+HWVEgfG5z31ONDY2Zn6n02lRX18vVq1adRR7dWTYv3+/ACC2bNkihBCira1NRCIR8dhjj2WWeffddwUA0dTUdLS6mVcOHz4sTjrpJLFp0ybxN3/zN+Jf/uVfhBAjf9+vvfZacf755xvnO44j6urqxG233ZaZ1tbWJmKxmPjlL395JLrIHAXY/rH9E2Lk7zvbv6NLQY34JRIJNDc3Y+bMmZlptm1j5syZaGpqOoo9OzK0t7cDAKqrqwEAzc3NSCaTyvGYNGkSxo8fP2KOR2NjIy6++GJlH4GRv++//e1vcfbZZ+OrX/0qampqcNZZZ+HnP/95Zv7u3bvR0tKi7H9lZSWmTZs2IvafyYbtH9u/fkb6vrP9O7oU1Ivfxx9/jHQ6jdraWmV6bW0tWlpajlKvjgyO4+Cqq67Ceeedh9NOOw0A0NLSgmg0iqqqKmXZkXI8HnnkEbzxxhtYtWpV1ryRvu//+7//izVr1uCkk07C008/jSuvvBLf/e538dBDDwFAZh+DeC8EFbZ/bP/6Gen7zvbv6BI+2h1g+mhsbMTbb7+Nl1566Wh35Yiwd+9e/Mu//As2bdqEoqKio92dI47jODj77LPxox/9CABw1lln4e2338batWuxcOHCo9w7hjmysP0LFmz/ji4FNeI3ZswYhEKhrMil1tZW1NXVHaVeDT9LlizBhg0b8Pzzz+P444/PTK+rq0MikUBbW5uy/Eg4Hs3Nzdi/fz8++9nPIhwOIxwOY8uWLbjnnnsQDodRW1s7YvcdAMaOHYtTTjlFmTZ58mTs2bMHADL7GLR7Iciw/WP7x/aP7d+RoKBe/KLRKKZOnYrNmzdnpjmOg82bN6OhoeEo9mx4EEJgyZIlePzxx/Hcc89h4sSJyvypU6ciEokox2PXrl3Ys2fPMX88ZsyYgbfeegs7duzIfM4++2zMnz8/832k7jsAnHfeeVmpK/7nf/4HEyZMAABMnDgRdXV1yv53dHRg27ZtI2L/mWzY/rH9Y/vH9u+IcLSjS3QeeeQREYvFxIMPPih27twpFi9eLKqqqkRLS8vR7lreufLKK0VlZaV44YUXxL59+zKf7u7uzDLf+c53xPjx48Vzzz0nXn/9ddHQ0CAaGhqOYq+HDxrVJsTI3vfXXntNhMNh8cMf/lC89957Yt26daKkpET853/+Z2aZH//4x6Kqqkr85je/EW+++aa45JJLxMSJE0VPT89R7DkznLD9Y/vXz0jed7Z/R5eCe/ETQoh7771XjB8/XkSjUfG5z31OvPrqq0e7S8MCANfPAw88kFmmp6dH/PM//7MYNWqUKCkpEV/5ylfEvn37jl6nhxHd8I30fX/yySfFaaedJmKxmJg0aZK47777lPmO44jrr79e1NbWilgsJmbMmCF27dp1lHrLHCnY/j2QWWak2wAK2z+2f0cKSwghjs5YI8MwDMMwDHMkKSgfP4ZhGIZhGGb44Bc/hmEYhmGYgMAvfgzDMAzDMAGBX/wYhmEYhmECAr/4MQzDMAzDBAR+8WMYhmEYhgkI/OLHMAzDMAwTEPjFj2EYhmEYJiDwix/DMAzDMExA4Bc/hmEYhmGYgMAvfgzDMAzDMAFh2F78Vq9ejRNOOAFFRUWYNm0aXnvtteHaFMMwTEHB9o9hmELFEkKIfK/00UcfxYIFC7B27VpMmzYNd911Fx577DHs2rULNTU1nm0dx8FHH32E8vJyWJaV764xzIhCCIHDhw+jvr4etu3/f1xvby8SicSAy0WjURQVFQ2li4GD7R/DHBnY/g0SMQx87nOfE42NjZnf6XRa1NfXi1WrVg3Ydu/evQIAf/jDnxw+e/fu9X1/9vT0iLqakK/11tXViZ6enkHZgaDC9o8//DmyH7Z/uRFGnkkkEmhubsby5csz02zbxsyZM9HU1JS1fDweRzwez/wWnwxAfj70dwhbEcAib/G29g84nc58tcIhspxsIxJJOd3y949A0PVG5CESyZSynKX3J0eEI1yn0/XSZaxQSFlOJMk/Fjo6QAdx6XR9/4Xj3jGynNc+Kn0z9DlrG6ZzQJfzeZ5MKH0h5xJQj6Gp/2q33M+R13ascMS8fdNx8rFeALCiUTkvmUJKJPGSeBLl5eXGfuokEgm07E9jd/MEVJSbj3XHYQcTp/4JiURiZP7rHQbyZf+mF89F2Ioo9suKRZW2IqVeG654Xb+RkPv0aMR1OsLq9q0i+bvz9LGZ7wcnS5sZa5Pbr/xAHWGJ/eGDzHdBbRa55un+2yXFSnt6b4i4XDd9Fog0uce1/RVpd/unDLTSUSRHW94wzyF9sYvV+0YkiZ2IyuOk2HZ6//fKawMAQJZTbAEZvaLT6XcdkSTXVnmpnEGPiyYICrI/Fumb6CXnltpy/ZjRddE+0+csOef6ObJC5NkUjSAlEtjS/ijbvxzJ+4vfxx9/jHQ6jdraWmV6bW0t/vu//ztr+VWrVuHGG2/M7pgV6XvxC7kbp76FiIGiD0iHnEyLLKOvy2QU6XrphRvSDG96YMOr3NDaC40QhvaO4cZztIs0RC5GerNRg0SmZ7040pcV+kJE90u4r6uvEZ1Hp5OvIfWFyvwiNfBLaN9Pwwuaqc+2dokrm3dcvyovvmHzMVPOE90OfYf1uH6FkH8krLD7rSi0/lsO2f9QFJawgBQGJQuWlvV9TKTN7wyMgXzZv1DKRsiyYUXky47QT4jpj0MsJtukyDVmme9F5QUhTl8IyAPV0f6ExOTLQqpGfu89WS7XS5YftU+9liMV1XLVHYfJiskLHbFlVlq1BU4v6WcoRubI/bTC9A+x0hzCIX/k6QsVvRep/Q2bBx4EWXm4VJ6zLJtrkfNhesGmNq9Me9mlfwSoi35pifxOz7mtvfjRa6BEnlunShoCq0e+kDnl6guPnSDrJsfccrpIJ+WxEN096vbpCx49IWR8BjZZb0y9ZpweeUVZcZH5w8D2LzeOelTv8uXL0d7envns3bv3aHeJYQJBCukBP8zwwvaPYY4OQbZ/eR/xGzNmDEKhEFpbW5Xpra2tqKury1o+FoshFotlTWcYZnhJC4G0R2yX1zzGHbZ/DHNsEGT7l/cXv2g0iqlTp2Lz5s249NJLAfRFqm3evBlLlizxvR4rHIJlqd0TXifC5AtI5NEsqYMONVO/iiQdziZD9ZrUSX25qO8BlVdUOdTs76Cs1yS76sspvmADr1eXWU0ytEV32Yec/cnK3SdrzU3Sp7KcX19Mk9RFj18qaZ6nS+eu/fLy0TOcW9L/rGNuUxkq7L5cHv0dvXAg4Oj6lzafyY182T+RTkPoriH6tUhkM5u8PDrEZ9A0HVDtodFHjNg1aG4P6Uop78ar5LouOeeNzPcIkW2ff/1cpX3JO4Zrm7hQeNq/iPvjyyT7OQnVFthUaqXuMVTCJT5m+vbU40SODe2zZu+on6LolbKl8swpIn8EtH1RzgeFuvTQ9jGz1CvoM4tMT9VICThVqsnzh+UxDFMtlBxL0dXtOh1QfTGVvlB5mhxXKu32NSFthNBdEHMiyPYv7y9+ALBs2TIsXLgQZ599Nj73uc/hrrvuQldXF7797W8Px+YYhhkEDgTSATV8wwnbP4YpfIJs/4blxe8f/uEf8Je//AUrVqxAS0sLzjzzTGzcuDHL4ZlhmKNHUjhIeti2pM8RakaF7R/DFD5Btn/D8uIHAEuWLMlJ2mAY5sjiwBhLnZnPDA62fwxT2ATZ/g3bi99QEeITHzzH3Q8P0PR+kysUeWsXwjLOU3wBDX59ur+WHTX49dFNaD5mCoZ8eV65+5R1G/xf1JQn7nnr9O177aecobcnX02+ex7bNOch9JeCxhcePnJ+curpeOYodFlvVnvaf2O+RPM5y/o9BCeX9ABSh9c8Znixo2HYVkTxMbNpyg5A8SVT0lwQHy9luuajpuaepOmIqI8puS61yggWyUmXJm5lp5d8mPm+O35c5nuyXLe/NFWV4V6KGHLdQfVLNKX9oveHnlNP2R+S045OtyLEj1v3HaTHk84z+eEBcKj/G0HxFyyR51m0d6jLUR9BmoePBghRG6OdM0HTqRTLbcZr5Hrjo+QyyWJ1nyOV8jjHyuRyxXvJM4s+lw93qv2nvoA0NQ1NJ2S6LgHlmrEAWH6c2w0E2f4V7IsfwzDDS1p456oayXmsGIYJNkG2f/zixzABJQULSZhHJ1Me8xiGYY5lgmz/CvbFz4pGYFlRNbTfIKcCHpm7acoMvUSPMQWMcF3G0tQEr/64biNr1sBlzkSKSt1aByx3edooL3uUbPMloerbd2jmeo8KK3SThmF8k9TqKU/TyXT/qYSs99lr3e4LmbfjIx1MFqb0PpYhiz/M6WQA9FXuGKQziqN5UrjNZ44u9F62kh7XG72WqARoSHkCmCtUqHIcSfNSrFaRoCW7Sj+S27/lpS9nvodKZV9GH9DvZXItm+RJkuZEaPeCcv8aqnAo6DaObkdx73GXLaHnW6SpmYoMuRj1dCy0qgqtakGfBT1kui5PG9atpEOhcrBeeaiI2Bmyn+lieSx6RsvvKVLJDQDiKbnNaCdJAVMptxnpJilYdKmWyrtEEne65D4rFU28ztkQCbL9K9gXP4Zhhpc0LKQ9/tV6zWMYhjmWCbL94xc/hgkoQTZ8DMMEmyDbv8J98Uun+4p1E6nXLlGj2pxOWRhaqZyRdpcwbT2LOJVqfVRhyMIUoWobqn3omfh9RIjS4Xxd5qPtTdGiXhilTpMcmVW5xEflCX3VJhnG7zE3VchQpCJztRWTPKtWQTEfSz/ysCpnq9ecZRvkXdP+Zx1LNeJ3KFG9SWEjaQyHh2eOK2aYsW3AspVox6xzTaP/6XI02pVcS3apKtUqdpLItsp9nSZuI0nVtcVKS3tcsVtKdaliOT1ZKq/xyg+0iFYayWuSWoldVyI/AQjDPlumSGQ9KpjuM90OkbSp7JoVVU3W55AqJg6RU+24eszsAzJK1yJVNZQKIYbIVwBAlEQ506oc9FlA5X09wphELDglcjupImJLSZP4KPWaixyWx7Z3FInwJTK+IP23tGtW2R/qqmRwSdDdqZRrIBQChD8XIzeCbP8K98WPYZhhJQ0baZgN38gtUc4wTNAJsv3jFz+GCShCWHD03JbafIZhmJFIkO1f4b74WVZWRJQS7QQ1IacS1URXY5CAAU3SMCVgprKdnpiXDPWbZU8aIaw2V+VF2md/yZC9EgW7tteLvBMZUtk+7ReNKjZFTmuoka8eCYgN8qZRdgU8j+dAffHavp/j74Ux6baH7G2OpCbXnEf/LdsaUlRvkH1cCh2RTENYmsyly3Yhcp9QGdbgKiE0qVZJVEztJLWFSpJ8bb1EXrV7ZJvSFpJYOkJcVTT7K+Jx8oNIhaSfqv3WonpJP5U2NIE1kXN1Vx/l+UHtCrX5NJJZuxed0RWZ771jy1z3JdytPmJD5BiG2mRyY4tKoCQS1/IZxSqKSVSxIqFrSbfpcSbzQgk5PT5KLp8u1ooWkG6miiyynNxPu0T2xaIRvgBAzwG1xdQ9geyzXV6uNFfcGBzH074ORJDtX+G++DEMM6wkRQhJDx+Z5BCy4jMMwxQyQbZ//OLHMAElyP94GYYJNkG2fwX74mdFo7CsqBq55CU1pkgy4a4u92X0CCM9oXNmO1R29IjK1aUTN/xGmJoiVD0iXM01dQ11L3XZMOUeYeU/Qjb3BMh+MErlAPzW9M0sosvbynIh1+U8ayWbkl6b5DUPeV6R6o2JnTWpxh68tKGTFjbSHlFt6SFEDDNDxP7E1UW5frVzRSQxpe6pR31bCnWd8VvrlULr2Nqdcl2xg+6PldABtW6r6rZhsO3UbYRKw1Dda6i8q0rFpL1+PRskbZiihcu0bMY0QjYs23fVyn7FDqvHovRDkqXiMHnOwICHe5GIkajcKhlxHO6Q8qqIqOc/TSJ5RYRIqiSEtfQjkti5SNs+8XsL98h9CXfSROPk+tGjcqlLFDmfpqh03b0rK0rbw34NRL7t39atW3HbbbehubkZ+/btw+OPP45LL700M18IgRtuuAE///nP0dbWhvPOOw9r1qzBSSedlFnm4MGDWLp0KZ588knYto25c+fi7rvvRlmZdCV488030djYiO3bt+O4447D0qVLcc011+TU1/ylwWYY5pjCgTXgh2EYZiSSb/vX1dWFM844A6tXr3adf+utt+Kee+7B2rVrsW3bNpSWlmL27Nno7ZUv6vPnz8c777yDTZs2YcOGDdi6dSsWL16cmd/R0YFZs2ZhwoQJaG5uxm233YaVK1fivvvuy6mvBTvixzDM8JIUYSQ8fVz4xY9hmJFJvu3fnDlzMGfOHNd5QgjcdddduO6663DJJZcAAB5++GHU1tbiiSeewLx58/Duu+9i48aN2L59O84++2wAwL333ouLLroIt99+O+rr67Fu3TokEgn84he/QDQaxamnnoodO3bgjjvuUF4QB4JH/BgmoDiwB/wwDMOMRPzav46ODuUT11wO/LB79260tLRg5syZmWmVlZWYNm0ampqaAABNTU2oqqrKvPQBwMyZM2HbNrZt25ZZZvr06YgSaXz27NnYtWsXDh065Ls/hTviF4kAdkT1aSjRClbTqhZxEuZN/bBoIWzdJ81UBYIWRqfbT6lZ1PWqDK7b9/IXM/jVKWlWtG2atm9KDaL0X1/GmEIF7tNTur+de798+f5lN5KrpcfJNl+ipu14Vc5Qzi2ZZymujIaKKDD75SnHyWP/TfNM29fTiOqpbsQQIs/SwkLa41+t1zxmeLHCIVhWWC1yr/nb0coTNvFxM5FVBYGum6b5oKmxyANGTycjkuReOiz9qiM0hQdJTUL7C0CtBEKrdRAfRVOlh74m7ilYKKaKEIBHhQzqh+txXKn/HE1bkyqlNkJtEyuR/QmRddNUN4Ics6yUZsXkfKRkm1AXObZJ99RmfROIzzzxUYx0kjZjSEWONnUNxa2yTYgcMof4C9LKKdQPtK9v7s8z6sunXKfaM1N5NiSTgDA/HwfCr/0bN26cMv2GG27AypUrc9pWS0sLAKC2tlaZXltbm5nX0tKCmpoaZX44HEZ1dbWyzMSJE7PW0T9v1KhR8EPhvvgxDDOsDJy5noM7GIYZmfi1f3v37kVFhczZGIsN/Cer0OEXP4YJKEkRHiCPFY/4MQwzMvFr/yoqKpQXv8FQV1cHAGhtbcXYsWMz01tbW3HmmWdmltm/f7/SLpVK4eDBg5n2dXV1aG1tVZbp/92/jB8K9sXPsixYlgVnlDzgiRo1nD5VIk9a8T4pNdhUaiBZzLOG/ck8KhsohaCpVBvWpAYqLxikSq8qDookaZCUPatgGNKxKMt4Sc2GvpjaK6ld+maS7z4rfFB51E8KFj0djCHtianCiEgSFwBA2QejjG5KrQKApoDxlNEN7ZV9NmzHmOZF72YIsIQD+Mgq5IYDbzk3f4ljmJwRAoBQbQS1S4B6bRlsmWK/POyfYidptQqa5iihu7oQeZje8zRNFnW10SuPEJQULFF3Vxeb9gtaqhUqW5OKJspxMVRn6luBZfjucf+R40yrWFhk923NxNhpak/lV1FE0pnQ54d2zEWUyOAktRNNzSLKSUUSPRsLeYalSuV2UsVyeqRH9jGRUFfg0Ecj9a6iUq/idqWpBtT+ketEkdTT5Pxr7gFURhahEODx4jYQR9L+TZw4EXV1ddi8eXPmRa+jowPbtm3DlVdeCQBoaGhAW1sbmpubMXXqVADAc889B8dxMG3atMwy//Zv/4ZkMonIJzL6pk2bcPLJJ/uWeQEO7mCYwMLBHQzDBJV827/Ozk7s2LEDO3bsANAX0LFjxw7s2bMHlmXhqquuwi233ILf/va3eOutt7BgwQLU19dncv1NnjwZF154Ia644gq89tprePnll7FkyRLMmzcP9fX1AICvf/3riEajWLRoEd555x08+uijuPvuu7Fs2bKc+pqzZd+6dSu+/OUvo76+HpZl4YknnlDmCyGwYsUKjB07FsXFxZg5cybee++9XDfDMMww05/A1OvDqLD9Y5iRQb7t3+uvv46zzjoLZ511FgBg2bJlOOuss7BixQoAwDXXXIOlS5di8eLFOOecc9DZ2YmNGzeiqEiO0K5btw6TJk3CjBkzcNFFF+H8889XcvRVVlbimWeewe7duzF16lR873vfw4oVK3JK5QIMQurtT1J4+eWX47LLLsua35+k8KGHHsLEiRNx/fXXY/bs2di5c6eygwNSHAPsGHqPl0Wa2z6tRggliOxeXiWXG0Uyh1tUDtGHzenQP5XqfFbEUCU59whbc7Smtmofsm0WdDmHhuK6D197VrHws02PKhxKRnYqL2mZ59WqHO7Rz96VK9yjj70qjBjbk8oppqhcL3ncT1WSrGopyrEZuAqIpW9eqxwylKjepAgh7OnjwsEdOkfK/jm9CTiWQKhCZuzXpVYl4wGVzYik6qQSrtN1aHs7Ku+FNI0cLi1R29Drg8p7JveahHqtOt3dcjkqY5ui8jW7plR7MLjNKHK2buPoPNqGPheohBzWXV3k/ofjRPYlinS0XW2SKpLrCBPZNl1KpE6qmher7k2hHtm3eK3cUG+1XC+twmFrmRhohZF0TH6PV8nvSbpJ7VGSIMtVvm+wDzT6XH8W0YhfIuk7ve7uWXalfK73dYBGX9tDqtyRb/t3wQUXZFeHIViWhZtuugk33XSTcZnq6mqsX7/ecztTpkzBiy++mFPfdHJ+8RtqkkKGYQqDgaPaeMRPh+0fw4wMgmz/8rpnfpIU6sTj8awEiQzDDD+OsAb8MP5h+8cwxw5Btn95jer1k6RQZ9WqVbjxxhuzZwgBCIFEuXw37ThRldaix8tI3p4eOSRcRRJrWmR439GLfCvDzu5Fok2JQbO6S6UGKm/mUXb0jBAliY49o2L9QGVj2z2KVe+buZ/mBJxGeQbmaFljAmQ/EjB0qdWYgdq1L159Np0zT3ndNN2Q2Durb5YNwMZg0+05A/zj5eCO3Min/bPsvqwGVIJ1tAhHmrTZSZJ55Fq0S4g8q99LNJMBlYeJBGtHDUnqAThdZDmajJi6fdA+68l8FVcVQ4YFn5HA0BKbZ9pTqVG/30l/lD6TZMJWJZFgU9q9TBIoU3m16IBZaqWJkmmEbbpYbp8mg7bSavvEKPmc6j6OROWWyDZheVqUdQFAmARZd46T8xKVcl/SFeT49arHP9omf/eMlt9LPyI2q1iLPidY9HpI+Xg2aZHYyrmNhGENQeoNsv076nu2fPlytLe3Zz579+492l1imECQFKEBP8zwwvaPYY4OQbZ/eR3x85OkUCcWi42ITNgMc6zhCBuOxz9mr3lMNmz/GObYIcj2L68vfn6SFPrGsgDLgiDD86M/c0BZZN6E5sz3NbtnZ747JFrKpnUnw9ru0vqUeh1JN3SZziQDG+r+uqyQ9MVdXjRFDuttjBKoRz1fY5SxPbCEmTXPKNtqXTbI0CJliL7zkLepPO67PrDhOCvtLY/1GuaZZGM96a4iTymrdT+WLgsqbSxhDTrTaBpA2lRwGXqVYGYg8mn/rGgElhVVI2R1VwtyndjFOWRM6Ide2xGze0Vm+9pvpT4w6Sd1qbHJS63TQyI3AV/3vyB+DEJ31aF1hGliX2rX04YIY0BNTp3UokX7oVGket3elPtxsmkJYu3dwSYZJ4RBxqaJlYsOJFyXAYCiNrlvkb1yo+li2T5Rpm6j5zgiLxfJ45QeTYoGUE8lbZuxA3LdJX+R2w9308K95Jh3a+ec2jnyzKWSvkWixwVNAA6XJOZDEC2DbP9yfvHr7OzE+++/n/ndn6Swuroa48ePzyQpPOmkkzLpDGiSQoZhCoOkE0bIMZuApN+X6QDB9o9hRgZBtn85v/i9/vrr+MIXvpD53Z8xeuHChXjwwQdxzTXXoKurC4sXL0ZbWxvOP//8rCSFDMMcfQQsOB7/eIXHvKDC9o9hRgZBtn85v/jlI0khwzBHn4Gy03PljmzY/jHMyCDI9i+vPn75RBTFIEIxOMStbeHEV5VlLip9N/P9Z8dPl21DBn8rDx+ZrFD/DB6RPYq/lXvmfCsis6tn+XcRHxfFd8GQGkVPbUD9Yjx9ATOT9SLtPoayPdLB+KlwkVUYnabQMbXx8Bc0+h8Z0sFkY0gnQysE+PCdzO6A+7WgH2NjChnDMll+lVnHbAjpDAbIVTWS81gVPP0+ztTHLOtepAXvie8YfTGl149eRYf4H9MqCnYxKT2hOHx53As0VUvC4JemX/uO+7VL+6JU8SC2FNDsacT9WJjtuk88Kjo5ZdLnj1bBCMWpv7C6uvho2SbcJdcd6k2R6eT+1/rvROQxK26V/nOhTukvJ4iPe3ySrPwCqFU50uSRY3WSZwN1/exSz1G4R7h+p6ltrDitfKLZK3I9W2WyM4KkEBK0CozH+RPxOIQw+0AORJDtX8G++DEMM7wkRQi2Z8miQUaNMAzDFDhBtn/84scwAcWB7ZmkdCQnMGUYJtgE2f4V7IufFU/Asi3YROl48dBJyjIXEqk3HScpSNIkhQsJwacZ2QEAJKu6krmdDkd7ZY6ns2hqESqJ+EzNoSxHZUM9BQ1FKUZO9oVKujQjflr7B0P/0dA0KURCobJjlsxokkTpem2fbQhKCho9HY6S7X9oAfdKapgklRfM/wKVY+sjnY93Bwxpa2hFED2pAD1+6TSE8EoX5E1aWEh7yBle85jhRaTSEFZKkbqskJbKwjFcM7bh+nPMqZGUa5nItqbqHIBuM+X9Q1Or0CogejqsLNcTt77QfbG065HKgI67ewW1H3a5rO4EaHZasaXUfvmTuqMdRGonbcKduv0ikjCRd1NlRGpPmbcTOyQl3VSpbEMrf9BqH7F29Zx3/pU8nkUfy76ki+T+h0jWnKKP1b4UHZLrCyWIvJtyT+GiP3Mtcm2JXi3VSz/0madLvSQlkBUOwxrCqFyQ7V/BvvgxDDO8BNnHhWGYYBNk+8cvfgwTUFID+LikRrCPC8MwwSbI9q9wX/yEAIRAtFMOoW/7r08ri/yfj/8x873kPSJD2GTYnVbkyKrCQN7oteLPmfZUwtBlV5O8aYoq1atQKOtzl2eUguW61GHYvhLt5jcq1xo4QjdrXYZIVlpRw2v7yjxTtRMv2ZRm6zdI5X6xIlJG89w+lZGUyh3uslsWJnXaqw1Bj3i2hAO4FwMZEEd4/6sdwflLCx9HAJZQI1xNEi7UqhYWicpVqiPolSdMEfI08l7JFqBFBRvkYUXe87oXqasFjQSmEcrkIrSjarYCy+SeQt1zbHJf61It3Q6tgkKqjSiVP7T2oQOHM98VEZ6cJz3DhKVUKCGScIc8T7TyVKpc3edwm+xnlErFlbLP3bUkcrhbtb9V78v2yVLST3LIaFRy0SH1Ggn3kOjjdvJsJfslYrLPlp7VgVyD1CWBVuiwIvRZoLWn7gGGKkh+CbL9K9wXP4ZhhpUg16pkGCbYBNn+8YsfwwQUZ4DM9V7zGIZhjmWCbP8K/sUv1CuHkEv/pEoVXW2j5Lw2Od0ihbBB5YEeddhakQroMD6VOmjkmi4VGCIxlW1QOVKTPbKGsQdYV5bUk/azfdJ/LapXkSd9+DNkJROOUKl8wOb9Gx14EXpevKKiTev12pdByMAUpT8med8gVQF6xLWPRLtaf62wz/30QdIJwXI88lh5zHNj69atuO2229Dc3Ix9+/bh8ccfV2rUfutb38JDDz2ktJk9ezY2btyY+X3w4EEsXboUTz75JGzbxty5c3H33XejrEwmon3zzTfR2NiI7du347jjjsPSpUtxzTXX5NTXQseKhGBZYdVG6NcSsW1KAvgkiWQtlbJvuqNTaa9Lp/1Q2dWmSXap2wygSppE3rVLSuR0pf/a9Zp0j0in7Z0eQ+SnB4o8S2VffXvUnpJ7lm6THj89CtWy5Dy7g8rbhmhjQJUqqdsImR4iz69Qt5qgOF0iz3O4g0S4kgjbaLs85rrUXHSASLXdNJJXtneIXQ/3as/MJDm29DlLXZJSZLpHVgphSuZ8WEroWfaa2rxYDHAG/3KWb/t3LDFyxzIZhvHEgZWJbHP95PiPt6urC2eccQZWr15tXObCCy/Evn37Mp9f/vKXyvz58+fjnXfewaZNm7BhwwZs3boVixcvzszv6OjArFmzMGHCBDQ3N+O2227DypUrcd999+W28wzDBJp8279jiYIf8WMYZnjId5HyOXPmYM6cOZ7LxGIx1NXVuc579913sXHjRmzfvh1nn302AODee+/FRRddhNtvvx319fVYt24dEokEfvGLXyAajeLUU0/Fjh07cMcddygviAzDMF7k2/4dSxTui98nUb00GWVJqyp1hLvliaGJJe1eMoRMpVYtYahSB5NKpVQSIHKApQ3bC5o0lQ5pk2FvszSoyjP+atBq86I00bG7JET9U7Nq/dKIJpPUqMhLWh9NSaeVCFct6ayHDJqZPohavUY8pF0lYlGpiex3iH/g5bLWZYo+ptcGXcRLKkkNTer1m8eqo6NDmR6LxRCLxdyaDMgLL7yAmpoajBo1Cl/84hdxyy23YPTo0QCApqYmVFVVZV76AGDmzJmwbRvbtm3DV77yFTQ1NWH69OmIkntn9uzZ+MlPfoJDhw5h1KhRWds8FhHJvgTO9J51Uqrsp0T8UjtHXVKonGZKmKy1sQyJ4bMg9tBoy6jNjKjSspIxwRDhq9oCj3vZMM8o+wKqSw+N5DW54OjHgkrtKXfZM8s9p5fsG6ljqzxbEjRaWj1n4TZS05bUJw4f7Mp8Dx2WbZwy1f6GDpGE3KOlvGqTaF1BomrtblUeVyKbU4bzrCyjHksletuQgNuqJvewh70X3bm7AVCCnMePpV6GCSgpJzTgBwDGjRuHysrKzGfVqlWD2t6FF16Ihx9+GJs3b8ZPfvITbNmyBXPmzEH6E+Pe0tKCmpoapU04HEZ1dTVaWloyy9TW1irL9P/uX4ZhGGYg/Nq/kUjhjvgxDDOs+I1q27t3LyoqKjLTBzvaN2/evMz3008/HVOmTMGJJ56IF154ATNmzBjUOhmGYQZDkKN6ecSPYQKKp2MzkUEqKiqUz2Bf/HQ+9alPYcyYMXj//fcBAHV1ddi/f7+yTCqVwsGDBzN+gXV1dWhtbVWW6f9t8h1kGIbR8Wv/RiKFO+IXTwK2hWirDO2u1NKpxKukjwUNYbc7SZFoGoKv+UsZfUasgX3vAM3/ylBYXFlGr7xhWpcB3feEtjH5GCrt9X3x49fn5fvmJwWMll2d+hlZhhwwwsuNz086FiU1j9ac7gOtdjIIH0tf+K1cYvCryvI3ovtv2RjKf7ej7ePy4Ycf4sCBAxg7diwAoKGhAW1tbWhubsbUqVMBAM899xwcx8G0adMyy/zbv/0bkskkIp/4jG3atAknn3zyiPHvo1DfO5tU5OibMPC5p/df1jVO70Xqo0f9sBzDNQoPn0HFx9hgC/V+knQwtC+2R+USU1UlxceR2DUnofmrhaiPoim1DfGRLC5S57UT31daxSdG/Opimo+zY0h7QvtGpoti9U+WRVNypd1tvkXOuS1d+j7ZvmwfIv57NO1L6FAXfEF9JDvJhsg+C80v3iqVqXoUO02vU1r5o0P1a1V8AUM2rCGk5zra9u9owiN+DBNQUo494CcXOjs7sWPHDuzYsQMAsHv3buzYsQN79uxBZ2cnvv/97+PVV1/FH//4R2zevBmXXHIJPv3pT2P27NkAgMmTJ+PCCy/EFVdcgddeew0vv/wylixZgnnz5qG+vh4A8PWvfx3RaBSLFi3CO++8g0cffRR33303li1bltdjwzDMyCbf9u9YonBH/BiGGVYEvP1Yci1V+frrr+MLX/hC5nf/y9jChQuxZs0avPnmm3jooYfQ1taG+vp6zJo1CzfffLMiHa9btw5LlizBjBkzMgmc77nnnsz8yspKPPPMM2hsbMTUqVMxZswYrFixglO5MAyTE/m2f8cSBfviJxwHAg6sHpktPvKx+gYe6pJDwvZhIunS4WAqj3jIdoKkcFGG8JUNeqTmUCREn5eMQUYxyYtZ033IkIocEtVkB7rPBnlEJGmaB23dXqle+tvY2o1F25BhemFIc5JV+YL2zSBJw/Y4z6ZUMRbZT4/KGerKDDKuVzoMsm66fYdURVAlNI9rzqsPPsi31HHBBRdkV7chPP300wOuo7q6GuvXr/dcZsqUKXjxxRdz6tsxh20BluXpwqFU0jBcVwiTcxj3uFaILaLVOhxS7cPW7AetBBKqrKBzSF/I/aO51lhRaZtp2i0nHnedrkvVvtJhUTlSk3OVa5W2V2yR5T49a0OGdDKdqmxqkZQ29JlD3ZDoMvT5p/fBcsj+U9meXhe6OxORy+120jf6LKL7rN/PVG6nknRVOVzRJXQq6dJ0NnSbdL2lqnsDlbHRG/d0nxqIIEu9BfvixzDM8BJkw8cwTLAJsv3LScRetWoVzjnnHJSXl6OmpgaXXnopdu3apSzT29uLxsZGjB49GmVlZZg7d25WFB7DMEefIPu4DAa2fwwzcsi3/Uun07j++usxceJEFBcX48QTT8TNN9+sjCwLIbBixQqMHTsWxcXFmDlzJt577z1lPQcPHsT8+fNRUVGBqqoqLFq0CJ2dnfrmhkROI35btmxBY2MjzjnnHKRSKfzgBz/ArFmzsHPnTpSW9skDV199NZ566ik89thjqKysxJIlS3DZZZfh5Zdfzq1nqRRg2+pQeViVvUJ0GJxWhCgh0VekTWKcGvWXKpLzom1SEo3sIRFiNNpKk9VEnEQcmWRfileEcJF7igxFGtCjemlaDTrkTeWNFM1Ir27fJC8qciidrkfo+ol41aVI+tsgjyhyrp75XbhLWoLepI5BqvG7Tbr/YY8i4SZMEjQA0H5axCXBECFpaf1XqsVYFizhAIZCAwMhhKVWb3GZz0iOpP2zrL7zS69//VowVXtRrnkqzelRuSb3FEO1DCXaF4BNIjQVlxIt+lXO0KReatuInaVSs+iRLjz61WiUd2mEr6kKhw6tKpI23ONeVUzICVAkXO2cOV0y+tUqIsfJR0UjALDI84xK/RZ9FlEbcbBdW4HlupzRPUl75qqVWKi8TCqS0GdGifpcc0Jyn50oaU+27+g2l2CTakUiZCOV6gUGmbc93/bvJz/5CdasWYOHHnoIp556Kl5//XV8+9vfRmVlJb773e8CAG699Vbcc889eOihhzBx4kRcf/31mD17Nnbu3ImiT66H+fPnY9++fdi0aROSySS+/e1vY/HixQO6wORCTi9+GzduVH4/+OCDqKmpQXNzM6ZPn4729nbcf//9WL9+Pb74xS8CAB544AFMnjwZr776Ks4999y8dZxhmKER5ASmg4HtH8OMHPzaP78lK1955RVccskluPjiiwEAJ5xwAn75y1/itddeA9A32nfXXXfhuuuuwyWXXAIAePjhh1FbW4snnngC8+bN81WvPB8MSctpb+/7N1FdXQ0AaG5uRjKZxMyZMzPLTJo0CePHj0dTU5PrOuLxODo6OpQPwzDDT5ATmOYDtn8Mc+zi1/75LVn513/919i8eTP+53/+BwDwX//1X3jppZcwZ84cAH3prVpaWhT7UFlZiWnTpmXsw0D1yvPFoIM7HMfBVVddhfPOOw+nnXYagL5amdFoFFVVVcqytbW1xjqaq1atwo033pg9Q4i+oXWqjPVqyRypDFEmZQc6hBwfX5n53nKuGpUWP1HKCOGPZPva18Zlvpe/e1BuXy8KTWQEZaCcDodTqUUrUk5lFCX6mMp+SQ+phybKpMeCTKdRUFaXTJIKADaRZLwSVRuh0a+G9lnrJXKPEiWsJFMmi2tJX4UfSYRE9WZFFZsiiekifpM2U+nKcCyy+0/20yCveG2fFnMXacczinYg0o4Ny8OPJc0+fkaG2/4JAQgIVbbUEhAbMwFQ+6N8164VGvFL/ZCUqFB/2QqsEpqYl2yzSkb7Wtr2lUhUel+T7dsVMlrUOaz6OWXZw34MEbpZCaSJbXaID5VdViaXoZkPdHtB160kwCZJn7WoVqUP1CVFSaZvPs6il0jXZN2im9h2UzJ+AKAjVVQqLnJ3Cco6xlRqpu4x5Pkbr5HfU8WqDbFTsj/dx8ljYZPsEaGE/N47Sm3fPVZuM9oBpOM28CoGhV/757dk5f/9v/8XHR0dmDRpEkKhENLpNH74wx9i/vz5AGQtcbda47QW+UD1yvPBoC17Y2Mj3n77bTzyyCND6sDy5cvR3t6e+ezdu3dI62MYxh/9Pi5eH8Ydtn8Mc2zj1/75LVn5q1/9CuvWrcP69evxxhtv4KGHHsLtt9+Ohx566Ejuli8GNeK3ZMkSbNiwAVu3bsXxxx+fmV5XV4dEIoG2tjblX29ra6uxjqZJL2cYZngRA8i5/OLnDts/hjn2ybf9+/73v4//+3//L+bNmwcAOP300/GnP/0Jq1atwsKFCzM2oLW1NVOmsv/3mWeeCcBfvfJ8kNOLnxACS5cuxeOPP44XXngBEydOVOZPnToVkUgEmzdvxty5cwEAu3btwp49e9DQ0JBbz9JpwEqDJrBVomihRZxVykiwVJU0pF1j5XB46Aw1wukXZ/wy871xx9dkmz/KYd3SvVIODelSr97f/n7R4X2THAiotYPJELpTThKbpslQvVb3kEoV8TopT6SKiQRE2pf8SRvgpXWMu4kkTKNlqVSsRZ4q8/R9kzPcpwMw1QH2lJ2pVGzYptpelU1FSpPL+tcVJrIJPZe2z1q7yibpvmi1Kum1YajvrMhr+rHQpbchvJwJeOcaH8mZ6wfDkbR/fXVIQ8YIWwCq64jJvYRG+Hu4mij1dek2qTuIbn8NtXdptCqt1euURt0W7yNEJOHDMvJVT4BMobV3bSpVUrtEXqqzpHJaB9kg75qW72vkHvGsyL5dWrFcmpyZyqjUtpJz4XSr7W36J6GH2IaIwSUgK+k1uQaoVGxIBp5lf2ifSXLlNDm3yTJpo3or1Wu2p8Yiy8n9TNM6C72yTWjSYaX9V058M/P9pf0nItUVB1ZjUOTb/nV3d8PW6kmHQiE4n9ybEydORF1dHTZv3px50evo6MC2bdtw5ZVXAvBXrzwf5PTi19jYiPXr1+M3v/kNysvLM5pzZWUliouLUVlZiUWLFmHZsmWorq5GRUUFli5dioaGBo5oY5gCIy1sQHj4uHjMCyJs/xhm5JBv+/flL38ZP/zhDzF+/Hiceuqp+MMf/oA77rgDl19+OYC+F/2rrroKt9xyC0466aRMOpf6+npceumlANR65WvXrkUymcyqV54PcnrxW7NmDYC+0kyUBx54AN/61rcAAHfeeWemxmY8Hsfs2bPxs5/9LC+dZRgmfzjCghXQzPWDge0fw4wc8m3/7r33Xlx//fX453/+Z+zfvx/19fX4p3/6J6xYsSKzzDXXXIOuri4sXrwYbW1tOP/887Fx48ZMDj9g4Hrl+SBnqXcgioqKsHr1aqxePcjxV4ZhjghCDCB1sNarwPaPYUYO+bZ/5eXluOuuu3DXXXcZl7EsCzfddBNuuukm4zJ+6pUPlcKv1Uv9qOJaweoS4gvXQ3wsHDk9eli2P/QeLSQOLLXmZb73fCR9PKr3E9+zHuIvoVW+UELlDWkThCD+JrpPDEkH41TJ7ffWynD4cJdcJnxY3f90ifSr6BgvvzvEjSNEmkQOk5QLAKKHSM6wsNxPh2bLp36U2p2gpJAwphAw++sZ07HQlCue2fLJuhRfKFrRQ2tv8BE0ttd9ZEypVsi6lGUszceP+vLQovf02qDXuYfjv1VSAttJAHHjIp5w5Y7Ch95z1HcM0Hz06PVDbKZDUjhl+ejSa9uUGiXlYb8My4Gk9hBF0hglxqj2x4nI/sc+lv0MtbuXp9LvvVCFtJlZ/nv9031W7lCqklBbQO8/zf6ZfJEFvX81+2OB9NPkC0j9ALVzTu2MWlWKXCfUZut9pPtgOGYWqZxirGICNW2aIKmB0lH5PVWqXlfdfyX7M2GyTE/S2i7T9pxSK6evGLdBaT8lKkfG3hm1DZ2HHfy1sYfeBNn+Ff6LH8Mww0LasdUScm7zGYZhRiBBtn/84scwAYWlXoZhgkqQ7V/BvviJVApCTwWiDfXT4XGLhOBHSdqV6B45bB7pPE5p3/OmlH5r/yyH+qN/bpPrPSzTCSjZ0aHKCDTzuUKSpuxQh45p2gNamDpZTlK7RIk0qckGTlQulyyT6+4aJ5crbpHTK//XXPlDyeJOQ/4NxdsBTR6lw+JeKVfoORXuMoJnkXIqddDlDGlj9O0rlT+o0uU3nQzFJG8TeVeRTbR+KlIdLVhfSVJLaJn/nRiRgRwHIh0HPvbXXZ0+w+cldQxuvUz+UORV/bo0yLv0WqTyrqW7DdA2phRCituCdq3QeVRSpcuR7+mYeo+mi0jajjJpi0IktRXdR122VbwoaF+ShtRUjib7+nA1gWIvzG4b5ipA6j4rlXt016X+NnraLqW9QZ4nbRyaWkavHETtPD1mNO0Nfa5qKYAoNk27E6HPKbmuogPqvnQflsv98QNZwcJKyH1p7jgh8/1r+xcp7S884d3M97JwHPHOJIB9xj56EWT7V7AvfgzDDC9B9nFhGCbYBNn+8YsfwwQUTufCMExQCbL9O6Zf/JRhdDK8L9Ik23tc7mLJTnU4vrhIygtWrxweF4dltnBhyGgPQK3QQCOkaPF0kvk+CzI8nyJSR7JE7leqSG4/3K2ernCX3GaKBMyli+V600WyL7rUooxl00gwKql4ya5KFQm/si2Rh6lUknSPvvOSao0Rtobls9ZN2ysF78lCXlHFjnsknSqPacecStXlUgZOjyKVZ8i1EK9Wz3kqJtvHOhykkhHgLXMXPRHwTk8/gqWOYwWlCkQi4bGkqT2R6vSo3CRZn+XuqqGsS5f9lMpD5F6m13iYunaY+xluJ7InvReJ7Ks3p9kH1Kh6w72YMFceUWRcYsuUUR/Nxik2y+T2EVFtFLVmiqsQPc/U/mZVziCSasT98U3XZWnyPI0SV7I0kCpO1AUpC0Nkt90tn0UlH8l1JcvVa6ammbg0FdMKM2RdKerCIKN9AWDTX5FE6BaQjvcC+J25v14E2P4d0y9+DMMMgQGkjqGUg2MYhiloAmz/+MWPYQJKkKPaGIYJNkG2f4X74uc4gOWoCUz1YWtD9JMFQ7SZVnybRk9RqVaRbU2JTf1CJQS9yDpBhOR2EhVUXpDfy/6sJQONSxkgTPJ/ijK5z6lSIg1kqa6kbyn3SDgaOpdVucAkgxJJJCtpLJXkafSdHv2bWZXPu4/KU15Fxg0ofaF9NvQL0Iusk2hbep61yD2rUkaS0wL2doJGSJPi5VHtmg/l71+ocGwIj1xVXvOY4cWKxWBZUUVay47Q7HWfFyPfHXL9JzWpOEKi+sl1qrhH2O7uNABglZMEyqS9Ra/rw6SPY2RifQAId9HoYfd7lsrbuv2nbjRKtD61+T1qJgaKMCQ9BmgCZGIjNQncT1RvlguLwSVGkbfpc01P4GzlZtscrwT0luU6nV5X+jPLKpfSq5V0j+QOt8nJkQPE7QqAoNsnbgCCtHeK5XG1k+rxqviAZk+wkEr34r8xOIJs/wr3xY9hmGElyP94GYYJNkG2f/zixzBBJcDOzQzDBJwA27+CffETaQGh1TlVorhgjmoyJiBFb9aicmVEEqXRXh6RdMqwOZVaaL9oXxLa0HyxlD4ibbJvRQelbGjTwLG41p4GryXIVdoj+xU74CEN+one9ZB6jBgSoPbNMiRgHgRKe0Hledv9u7Z943RlvR7JVA3yDN2rrASu3SQ5KpXXk1K2inZKeSraosl7VJKJhJBKD7JQL4Kdx6rgsW3AtpWoXD3hrxWL6q0+WZC4WtBoUc3VRXFjoImeaSYCaiNsLYqeRtgTW2Zyj4h0mhMo290J1+lecqYir1LZltpiKo3aHrKeaTtebiOG+uxKhLHunkTzL1OpmCRW9tqm0SWFQtvotYJj7s82oyXW3Qs6pXRLk9PTrBgWKaAA7Rq1EiTpc7lMRWGT9nacJBpPeWRliCcgHLZ/g6FgX/wYhhlehLAgnGAaPoZhgk2Q7R+/+DFMUAmw1MEwTMAJsP3jFz+GCSwW1JSybvMZhmFGIsG1f4X74mdbff4ZHpUadP+JDIaC40L38SA+Gko4O/UXoeH0uu8K9R+jvmBKIW2aZsTsL2Z3Sl+Fsj3EryfsnvKjb4KcV7Jfrjvxv/K0xtpI5Y8uzcfHUPlC8XEUHv42PgqTOwmzj58vfz8PHzu1ve06PWt1hnNjF5Ei5dSv06PyhgJdL73mHO0YJ7Rz0I9H2gmKRX1R02nYIvdqDhkC/I+30LFiUVh2LMuvT4HaKVptgfqeUR8tQ/orwKUqRz/Ud08LcxTd5JqlaU+qSLUFYgvSMfVeCJNqD0ZfLsVGacukSH/ovlFbTvrl+YinbagfHfXR1f3dqP8j9ff18itM0xRixC/OYHOzUthQn0/TcmSbwlH9KpU+0xRUdN9o5ZKUlsKHbp/6+1FfPtqXuGafYu7VspRn8WGSm0yv3ET8B8WoCoj0EIxUgO1f4b74MQwzvDhW38drPsMwzEgkwPaPX/wYJqAEOY8VwzDBJsj2r3Bf/NLpPpnNUDAc0GRIJQWHeahcW4H8TtMZ0GVo5vwSNfO8MBQDF0VkCD1Fq2NooflUqiTtQ1SSJRnthS4zkt+hXrmdSCeRA2nGAU1qocPr6rE0yNYeKFJtauCKHC4rkN99pmOh21Smm6R2ZLsL9OOQdAo0TUJWOgYqfZB1C8NlamVVOyHHnKYnotuhbXT3BvLT6emFIwzSsR8CLHUUOiKVhrBTqgSry4ZRd3lWhInsSFwLrNISt8X7iLvLbvRazJL9qLxHvtPLRrFrWjoqWnlIsZndHmm3lBWQe4beJ4a0LXr/lVVRO0/suul+B1Q7Q10wqM12SPomALBotRTLfTuKXdPOsVJJxFTtiKZp0dO5RAzpXKjsbLCRAADHPVWZ8dimVfcCi9pmU9odRbZXX1GUc9N+GHDY1WUwFO6LH8Mww4rlWLA85AyveQzDMMcyQbZ/ORWjW7NmDaZMmYKKigpUVFSgoaEBv//97zPze3t70djYiNGjR6OsrAxz585Fa2tr3jvNMEweED4+TAa2fwwzggiw/ctpxO/444/Hj3/8Y5x00kkQQuChhx7CJZdcgj/84Q849dRTcfXVV+Opp57CY489hsrKSixZsgSXXXYZXn755dx79onMK1JEqtALVpNhbGXYHUR2paqhHtWmDC+T4XUiiTgkQi1VSSLnACTL5OFrO1H2LUmC2kpa5XqLP1aljtgBKS+G20mEHPmnYXWRoeywOgTvlBB5JSzbxDrkNqMdcp/DB7TI0bC7pOn7eqcRphEf0a5+1+VTHlYj8chxIhUGvNalRLIZqpgI4dF/WiHBco/K0ysCqFVhiEwr3KMS9WopelUQS1jAYNVeYfV9vOYzGY6k/bP+//bOPkiq8sr/39sv8/4GI8xABHayEgGFqKA4Qd0ECbMW+lPhZ9YsKmWoUEsGFagYi10VxQQMWxFDCkFdFk0Zlyy7MfFdEZVEGRDHnxWQFJKoGSL0jAozzQzz0tP3+f0xzr3nPN3Pne6Znhfmnk/VVPX0fXvu7XtP377fc74nFIQVCPEKzQIt1SSLXL+t5Pynch6TQzWpMkyuE5reEG12Z6JVmFr84fIwiZ/0vKZVoNq1aOe500InyLpYqgaJS3pFPJlGx2+TalMqdQZyefxOWF/38qSS2kv2DGQTJwB6zdNUo7DWuYJ+Nsyxgszn2S2KnA+0Qph+tDSWasPnVblE3iX7Yu58pREwpKewDi/8O5d1j6HnD03VISkwenoVc0UIWECfXA38G//SuvG75ppr2P8/+clPsHnzZuzduxdnn302tm7diqeffhqzZ88GAGzbtg2TJ0/G3r17cemllyZdZ3t7O9rJhRaNRtPdB0EQeoOPc1x6g8Q/QRhG+Dj+pSX1UuLxOLZv346WlhZUVlaitrYWsVgMc+bMceaZNGkSxo8fj5qaGuN61q1bh+LiYudv3LhxvR2SIAjpYKfwJyRF4p8gnOH4OP6lXdxx4MABVFZWoq2tDQUFBXjmmWcwZcoUvP/++8jKykJJSQmbv6ysDJFIxLi+VatWYeXKlc7/0Wi0K/ipriPP5F1dNqSmmaBVXUQC8Kj2ovImrVBTueSxN1mko5hXWLWUu4evebz786CzmDzCJ1VQwQ6+/aym5Pfd1mkiNVCpT5P9AmT8uRFXxg21uPsSbCMVtm3cDJY2BlcmA2IvA2eDaalX9ZwRahrqYcbMK3mJ1BpKfionVLVRSYHum8mMW5c6DNI1q7bzMJ1WJhmF7LOp4bu+fRXX9iFdfCx19JaBin8qLxcqmM2qXVU2jz+BqHvNd5YWJF1/sJWkyrRzaZNW3CKXmK7nlbrbICa7lu4lTWMmMUCnUq8iFa4snQVgX6xWlMizHT3Lvl2DI7InjW0sLpmrkikm035u5qwNn1ZMh1P7KjWZQ9P3veTVlLbpZWDfYUidYlKtoapZn49ghagTgcd3Roh8t8bIZxYgqQas2tejkjqcDegG+eng4/iX9o3fueeei/fffx9NTU34n//5HyxatAi7d+/u9QCys7ORTfMLBEEYECzV9ec1XeBI/BOE4YGf41/aN35ZWVk455xzAADTp0/H/v378fOf/xz/9E//hI6ODjQ2NrJfvfX19SgvL8/YgAVByBA+znHpLRL/BGGY4OP412cfP9u20d7ejunTpyMcDmPXrl1YsGABAODw4cOoq6tDZWVlnweafOPk8byp2glUdtUqjKg5Kqk2YgaipJItp4FLFYFOt0pMBd11xckj+JxGd5u5n/PH5kFaVUX7E5Kx0CoovZ8mlVQCMbf6KZtIQLSSz2rVpF6T9EGlBlpF5SF7KpPRttcydnKplfbNtds8epUSjL1+vaDVu6R6nFXF6T/7qOkqlTGUYXkPCYjJPilKRbz3cw9SRU+rQg+/eHu9Zv/QX/EvNroQKpTDUk30Xrexs133gbYRRKolYSJIQll2lMe/YEfylIR4truunAb3+gt/1sxnpJXAVKqkfVdPm69fJj3TNBwaIzyuERrnqQQaLMh33/fqdWyQRC2TMbSOIaWDpb1oYZH3xE3edIDGJTuumWYb0mvo/rPqZQ9XBRa/DN+lOsyVwGTgbEgbArSYQl0ZqARNt9FmNvNWrW1Qfajq9XP8S6u4Y9WqVfj973+PTz75BAcOHMCqVavw5ptvYuHChSguLsbixYuxcuVKvPHGG6itrcWtt96KyspKY0WbIAiDSHeOi9ef4CDxTxCGEf0Q/z799FPcdNNNKC0tRW5uLqZOnYp3333X3aRSuPfeezFmzBjk5uZizpw5OHLkCFvHiRMnsHDhQhQVFaGkpASLFy9Gc3Ozvqk+kdYTv4aGBtxyyy04fvw4iouLMW3aNLzyyiv49re/DQDYsGEDAoEAFixYgPb2dlRVVeGRRx7J6IAFQcgQPpY6eoPEP0EYRmQ4/p08eRKzZs3Ct771Lbz00ksYNWoUjhw5ghEjRjjzrF+/Hhs3bsSTTz6JiooK3HPPPaiqqsKhQ4eQk9P1pHbhwoU4fvw4du7ciVgshltvvRVLlizB008/nf4+Gkjrid/WrVvxySefoL29HQ0NDXjttdecoAcAOTk52LRpE06cOIGWlhb85je/kfwWQRiqZNi5/ve//z2uueYajB07FpZl4be//S3fXIZ+7f7xj3/E5ZdfjpycHIwbNw7r169Pb6C9ROKfIAwjMhz/fvrTn2LcuHHYtm0bLrnkElRUVGDu3Ln4+7//+67NKYWHH34Yd999N6699lpMmzYNv/zlL3Hs2DEnVv7pT3/Cyy+/jP/4j//AzJkzcdlll+EXv/gFtm/fjmPHjmVox8+EXr1enR+oBQh9LJtCRwVAaxgdI3kZMfeLhuYFBonlAADkfubmKOQeIblfOcTtntghQM9XM7i9gziXM0dzzc6ANRZnXSBoOT05RppTPbNNYDkmJmuSFPNdLIM1iQa32qEO/ST3McUuHsZteC1PbX9CJDHKy46FdpJh+T/kNbNpMe9/gLroG+xgdJsalcHHcJbd9ec1PR1aWlrw9a9/Hd/73vcwf/78hOmZ+LUbjUYxd+5czJkzB1u2bMGBAwfwve99DyUlJViyZEl6Ax7CtJVmIRTOgk064sTD2kzk1O7MI/leNEWXdBFqHcWv384C9/8ACU1ZxEPaihPLjyBZGYBwgxsnFcmFpjHT8sq9pbnM8eQWSvTqVR75vjSvTRk6XyRcS8zaJJz0fWYfEtDjr7sMywuk+YraWNj6TFZldP8DfMwsf5DEbJoXzWK5lqPI9pnm8gWTx8mEbiemz4Bux7SP0HIByWtuZ5NaXjnCYUD13s4l1finm6qbKvGfffZZVFVV4YYbbsDu3bvxla98BT/4wQ/w/e9/HwDw8ccfIxKJMK/P4uJizJw5EzU1NbjxxhtRU1ODkpISzJgxw5lnzpw5CAQC2LdvH66//vpe7y+l1wbOgiCc4WT4F+9VV12FH//4x0mDU6Z+7f7qV79CR0cH/vM//xPnnXcebrzxRtx+++146KGHensUBEHwIynGv3HjxjGT9XXr1iVd3UcffYTNmzdj4sSJeOWVV7B06VLcfvvtePLJJwHA8fMsKytjy1Gvz0gkgtGjR7PpoVAII0eO9PQDTRe58RMEn9LtY+X1B3T94qV/7V6VkgZ6+rULoMdfu93zXHHFFcgiTxKqqqpw+PBhnDx5sjeHQRAEH5Jq/Dt69Ciampqcv1WrViVdn23buOiii7B27VpceOGFWLJkCb7//e9jy5YtA7hXqTF0pV4rkODa7SXBJSybDE02Zg80DGX7KnrKvBlqL0BlhObkzue6BGGxcnYyjY6F+gF0aM73rPNEzxYE6vTppO+njIdsw+1UzPKIcT4ilXpZszB5lUqiVCqmNi165w6DDKsMKQW0OwjA5R2TDMQsKHSp2UpuO2SSytk8+nxxAMojFaInUnSu19uIrV69Gvfdd19am8rUr91IJIKKioqEdXRPo4nUZzJ22IIdtmDF3XO0dawm25F/s6LufFkkU6RpIlnn17RUlRxXUouecC1Q4kdJ5woiNZY283MtXujKgIE2IiES2yhF0lasHC6PsXObxslWEueIhVVCqg6VEWM8jcWZh0qjHcnnAQCbjJOmYJhswnT4tWyWWvkyhphjkHOT/d+NTY5ZINe19kqwU8nS8wW+XC89NjSWNfNzxijpUqsxInXrdjpMbg9Q2ywSh5hNFt9fZlsDgNlopUuK8a+oqAhFRUU9rm7MmDGYMmUKe2/y5Mn43//9XwBw8n3r6+sxZswYZ576+npccMEFzjwNDQ1sHZ2dnThx4kRG84WH7o2fIAj9Sqo5LkePHmWBTzpNCIJwppPpHOdZs2bh8OHD7L0PP/wQEyZMAABUVFSgvLwcu3btcm70otEo9u3bh6VLlwIAKisr0djYiNraWkyfPh0A8Prrr8O2bcycOTO9AXkgN36C4FdStDNI9RevF5n6tVteXo76+no2T/f/UkErCELKZNjOZcWKFfjGN76BtWvX4jvf+Q7eeecdPPbYY3jssccAdD3VXL58OX784x9j4sSJToHb2LFjcd111wHoekL4j//4j45EHIvFsGzZMtx4440YO3Zsr3YzGWfUjV+CbEelVvrYOZS8kjehqos+RjZUmKXaeYFWz7KqWFrhpT+21yuUnHUZnM/1JuUG53WEiYRJq7ACXAJn8rLJud3gFA8AqjO51GrsbpHifCbZ1hMq7ytT5S2M6QJGqViXY9Jt4Ojl/G/oYqI3g+fbp/uZ5k9SnR56VWbSxy9Tv3YrKyvxb//2b4jFYgh/ec3s3LkT55577rCReQGgtTSAYFYAASL1dubyeQK0WYyhCY/V6Z7XpcVctps5+q/O6zfgasLNjW7Myz/mLt+Zx0/MMCl2DERJGgmt6iUxRzXx6kiaHsNSYmjMNki4gFb9b5B9beZ2wK+XAHlyTWVoJjXTLjxaRwtl6LbBvn80eZnJ3TS20GWIPKp/Z5m7XRBJnH4v6ZXIZMy0KxKrCiafn96RiR4zKuOyz4J8T+hVvUySp/GPfub69xzdPv2c4nH9KzU9Mhz/Lr74YjzzzDNYtWoV1qxZg4qKCjz88MNYuHChM8+PfvQjtLS0YMmSJWhsbMRll12Gl19+2XE1ALoK2JYtW4Yrr7zS8QXduHFjmjvnzRl14ycIQgbJ8C/e5uZm/PnPf3b+//jjj/H+++9j5MiRGD9+fEZ+7f7zP/8z7r//fixevBh33XUXDh48iJ///OfYsGFDeoMVBMHf9IOB/dVXX42rr77aON2yLKxZswZr1qwxzjNy5MiMmjUnQ278BMGnZDrH5d1338W3vvUt5/+VK1cCABYtWoQnnngiI792i4uL8eqrr6K6uhrTp0/HWWedhXvvvXdYefgJgtD/ZDr+nUkM+Rs/JgHqsplBBrQ7kkt9Sq+ApNOovBs0SJBeZpKGCi0qYSQ89qaPusljdyYvG6qo9DGzadQkkz42t/mZzPaHnOWm6jWv42eqkNWPGZ9GNm+QgL1kTyaPBujn51FJxyRVQ4WwyZg5RVglsP6ZsTGnYE7dVzl3APnmN79prDoEMvdrd9q0afjDH/7Q63GeCYRaFYJxhTjxz82L8GPbOpqkJ9CQcdqdL3TanSfyt5Fs+edPuobM8UY3NuV97l5/uV+452+wXTsXqSRIDZyJ1KhozNGKgmjFKIuNdL0elbgsTptMmz1SdWBwVTClCulxkUm/4eRxmhq+A4AVJ+uOmfR5cyUxr56lsV31/D4ARZwUuOl1cklc/86i1c/M9Nok1WvfOczAmaYRmWK23rSAfp4dgNUXVwMfM+Rv/ARB6Cf6QeoQBEE4I/Bx/JMbP0HwKVYPyc3p1rEIgiCcKfg5/smNnyD4FQXAS0kexoFPEASf4+P4N3Rv/JQNwDbmYQEwNry2LEO+g56vZWiMbczL8ygzN+UIsnn0Btd0bCzHjbym5e9h7rpuykthNe7MckA7fimW0Lszaftl7HaRwroAmLpVGOcBeF6Il+u6ATY2Q/5cqjmKxm3QPBTdgiiQfJ/p+555pQnHrPddF/38i3eokx21EQrbsE6YP4TcE+7rthL3PAl2kC4ep9zXBR/y+BFuds/TAEmRC7e651juZ+6E8Oe884/1RWPScbE8LpZvzM9VKy/PXeYU6ZBEz3mPfDW2Tdoth1x/NH7reYAsX43GfzJMUx40oMVPw/usiwaQEIPdcRrsvDSMuYw035FtP4fNpwx56TxmkTFq8Yfl7Bm+f71y3xPsaZKMy+u7iOfvB/qUA+3n+Dd0b/wEQehffJzjIgiCz/Fx/JMbP0HwKX7+xSsIgr/xc/wbsjd+ylZQlgJglr2sEHkmb5IBPLowBAzl6Kyc38sFncqObMVEwqPWBNpPCCYv0O2k2OTbMrm4U6k5YJYCTc3AU21MTmEdNqgdQEiTd0xdOUzdNjR5iEk6BguYlCRkD5iFTIpSgmWyhkjRzsZT3jWgOmNQfWlSbsM7x+XMcZIZduT/tQWhYCfsXCJbdmrWHuTyCbW6VimnR7nL5H7hLpP3Gd9G9klyzcWoNYt7zYQ/cy1XlBZLmLzZaYhfLP5ymdKi8Zh2+KCxjEqgHlZBgXxXNmZ2Kh7XIvvf1G2JWX5psiXtUEElTBpXO7llC52PfWcY9k23RzLZ3rB5yDjt05o8b5JaqYRMj4uWnkQlYRazDGNJ2I4hJcpoLaOvl8Xj3qe5dK0bvo1/Q/bGTxCE/sXPv3gFQfA3fo5/cuMnCH7FxzkugiD4HB/HvyF742cFg7CsIJdXU6ioBMzdEfRqU1OXAe7WTpzOg1pVLR0P3Sabh0oIWrWSnfyxt+kRvhesKstKfswSZANDVxA2Zibb8tNFkapaC7RCmsoRqV09rPk3c+vXPnMm4xKpnsoOHpW7qXTuYPJOzOOYUdk6Zq5eZMtnGY6N6eelPn4qHQWCAAK9D1A+DnxDnpAFBAMIRklHH+36tXPd8z/7WLPzOuskuS5oNkRMiys0I6SNnFc0/pDzOtDSyhZX1HGAdusgsiFLIdE7F5mcDJjbgUdcNMVvQ4Wo3inD1CGJpf3QdB5dJiXbZxXCtKrYo9sTPR52O/mcvRwW6DE3HBvPY06PB5PUk1c/W1pVMp1G5Vm6/2xzHvI6i2UeHVrY8vr+qD7IvT6Of0P2xk8QhP7Fz70qBUHwN36Of33KjnzwwQdhWRaWL1/uvNfW1obq6mqUlpaioKAACxYsQH19fV/HKQhChunOcfH6E8xI/BOEMxc/x79eP/Hbv38/Hn30UUybNo29v2LFCrzwwgvYsWMHiouLsWzZMsyfPx9vv/12ehtQ3SU35NGwh2zIHsnTp8teBqC04oxKgOQT51VMKVYumarP9IbZ9LbbYCZNH/vrj9P5Pic38PQcZyrSOdmG7fU4nkrCrMm4Vgln+Jx4tZfZtJvJu6QBuhXiMrxx+1SeNS1vSBXwwvhZ6OeM6XMOGEyftf0P5JDqt7gNS9m9rz7zsdTRV/o7/gU/jyIYaIfKJ1KbJnUGWpNLrfTnPH1qoXL5NRJoduOJCrvnYuAEMVP2cAVg26TncmGh+z41ZtagUiOr1qfXD60q1V0VTPKkoXJVl4Ytkl7CrjMP03u2OlaVbIgT+vKB5HGajZ+MS5d9mYxrkHeNY9QwNRpg8m6Mx3wml2cbGgDQRgP68oaKb4QMx09vWkDOBybV9wYfx79ePfFrbm7GwoUL8fjjj2PEiBHO+01NTdi6dSseeughzJ49G9OnT8e2bduwZ88e7N27N+m62tvbEY1G2Z8gCAOASuFPSEDinyAMA3wc/3p141ddXY158+Zhzpw57P3a2lrEYjH2/qRJkzB+/HjU1NQkXde6detQXFzs/I0bN643QxIEIU38LHX0BYl/gnDm4+f4l/az0u3bt+O9997D/v37E6ZFIhFkZWWhpKSEvV9WVoZIJJJ0fatWrcLKlSud/6PRaFfwCwa7tEBTtaaGUV7zkM2YPKH38e2Gbl+XEAJmSdNZxtQDUcN4jpFtMJNSIOExuoOph6JHr14mexsk0IQKtRQqrhMqqcm6ea/aXvTdNfWHTHX5kKEq2MtAOYXeoZ5SO5XBY8mrB00Vxl3j1CqupVflgDJg8a89BgQsWExa0yoa20n1bFG+85oZPdO+rZ/zqlxaSWkZDIxZ5aXXNUbOQ9XSknwWQ5/Zrm0mN5Nn57dt7hXOrx8iQVI5V5OtmbxKK3ENZsIJ1baG65x+T9BqXQAwRjnLcMz1/sYmeZZW69K0mSxNKmWuAIZYROfXUlXocdLNoZMtn4Dp+9Qgr+sG2LqTglLpx31n+z6Of2nd+B09ehR33HEHdu7ciZycnJ4XSIHs7Gxk04tTEISBwcc5Lr1B4p8gDCN8HP/Sknpra2vR0NCAiy66CKFQCKFQCLt378bGjRsRCoVQVlaGjo4ONDY2suXq6+tRXl6eyXELgpAJfJjf0lsk/gnCMMOn8S+tJ35XXnklDhw4wN679dZbMWnSJNx1110YN24cwuEwdu3ahQULFgAADh8+jLq6OlRWVmZu1IIg9Bk/+1j1Bol/gjB88HP8S+vGr7CwEOeffz57Lz8/H6Wlpc77ixcvxsqVKzFy5EgUFRXhtttuQ2VlJS699NL0RmYnCvC6nQtzAac5AqY8LL2jAs1ZMXVbsDxsUkydO2hehakjhjZOlq9G81VMeXz6fDSvJddgAaE3Wae5FNTF39BFI6F83pTz45F3xnJxDLYvzEJHywtiVj1k88qQ12jpiRqGsRnz+vTzwjacZ/RzJt0+vPIFA+Q84ecWbR6vn/N0PIEuOxctDSZV/Jzj0hsGNP6FgkBAu95Oa50z6DV/klQDk9wp2l1D/zhZzhqNpW3ENipAzkUt34pdm3R5Q+eMhHM5h0jcLE6Sbkl5bl6znu+lDPliptzfhFhC7WBobKa2VV75vgbbLdO4uiaSY0A+G9oFw9Q5JGHdhrw+Fpe07yxTXrEpF13PKWRxisRGNn6PXE5jzqUpr08//il2gkoFP8e/jHfu2LBhAwKBABYsWID29nZUVVXhkUceyfRmBEHoKz7OcekvJP4JwhmCj+Nfn2/83nzzTfZ/Tk4ONm3ahE2bNvV11YIg9CN+/sWbKST+CcKZiZ/j35Dt1avicSgroDW81mai8ip9pE4lSOJIn/AImsp4VAI0yb76Y2bWTDz543Umx+hSKZVhTa/p43DNTsDkXM4f+xM5NUE2JY/6DdtkUoMu1Ric89nx021aDG73luJl+knXBQ/bFYNNCmytc0eYyEAm2xSvFACTvQS1pjF1joEmz6TQYcVk3wCga8zKQ4rqie7mOF7ThcGhMw4EOqFYXNDOF2IVoojUhuZm56WV79q86DYrypAqQjtyqE4i+3p1kUjlXM7h1cs0ZtBrlqVA0Hm0VJlAUYE7jXR0MNm0UNkYgFFepnYuntIis0YhscxkDYYk9iTdy1CpnNm5eJij0O8GZfgu1BfJMVSQ0/MsnPz4d82X/PuMWrtYXlXq9JhTSZvGRboN/VDS42xZXd8bHtlQnvg4/g3ZGz9BEPoXP//iFQTB3/g5/smNnyD4FR/nuAiC4HN8HP+G7I2fFQzC0jt36I+wiYzLHpWTWZRXhZbpMT6R89g2ded3o+zoPo6m1U4Jm9GrfLsXpw79XuMnMqBFm1l30nJXc4UW69ZBH+nTqi4mu5gbdvNjQWbSC39NnSsMnTsS3rfIfrJ9M8grXh1BqIxrkHf1jixMXqfTDFKxFeTdFpSpEtzQeUZpHxk7zztiUKqXJb3okue8JLpU5Duhf1CnT0NZnQCVzbQuEExqbW1L+j6IvJvQhcFOLu+yeWiFsEGm7JoxeaoGk3c1hwIq71mkKxF9n3a+SKgwpY4D9PozXfN6RT+VDQPJq4JpVbQef1mHC5NsqR0zKoMqKtWn0IUEgLnbBZVQ6bi0z9VUPcxikYd2yr4P6GdDK6kNXTgA83ceguQ7k5wz+vj1Di99CVF+jn9D9sZPEIT+xc8+VoIg+Bs/x7+0OncIgjCM8HKt94F7vSAIPqYf49+DDz4Iy7KwfPly5722tjZUV1ejtLQUBQUFWLBgAerr69lydXV1mDdvHvLy8jB69Gjceeed6PR60t5Lhu4TP/VlyQ157G1rUiOr+CWPoK1c0rCcLKN0qcTu+YCyhtfaNGZOSmUL8jidSSW61AJDJSytth3hSiB2iVvFBoA1Y48VudtsPyt5VVX2CV6hFTrhykCBxlPudppJ9R+r9tWOAJMqk1fYJsgrJnk2hfcBTRIxVVV7mXYbxsLNwQ3bSHXdBjPbhOXZ+A0VegnyPk9v6EtVm5+Tm4c6SikoKICYKSekasSIvBcwpC0wtwMtVYOZNhPZjsZVjwpRhsHM3WjmDPBznhpNk7QVKk3aRM4GAIvKsFQejBtSdbz2xWTsXuB+l6CNf3+AVBUj6lZSsxQcrcKVmmObji3dT8+qfnKcTAbWdoITBRkblaTpXQ6dR9skrzg2pO3Qal/tO5tVFduGR2qm96GlusQ6E6TwdOiv+Ld//348+uijmDZtGnt/xYoVeOGFF7Bjxw4UFxdj2bJlmD9/Pt5++20AQDwex7x581BeXo49e/bg+PHjuOWWWxAOh7F27dreDcaAPPETBL8iT/wEQfAr/RD/mpubsXDhQjz++OMYMWKE835TUxO2bt2Khx56CLNnz8b06dOxbds27NmzB3v37gUAvPrqqzh06BCeeuopXHDBBbjqqqvwwAMPYNOmTejw6IbSG+TGTxB8SneOi9efIAjCcCTV+BeNRtlfu6YcUqqrqzFv3jzMmTOHvV9bW4tYLMbenzRpEsaPH4+amhoAQE1NDaZOnYqysjJnnqqqKkSjUXzwwQcZ3POhLPUGg4AVZI+jA/Sxu85ZI52X8bMK3dV8QcxMTzRqC5FKOENVVUJVkQFWvVZS5Ly0yfuW9gjbanLHxiqkqLxR7O5z81fd9QJA61nuffuJae66J0751Hnd1O6uK/L/RrHlz3rfHVvRYXef6a8Bu4n0ANVh8mqKvyHSNc3W3rcCBnnWINubqoX1ddP1emGqvmV4mb5qBqQO5JyjBrY6TFLJyurq1dsHRM4d4rDKce0aoZIckfpsKttSOVGXWk3V+53Jq/V1LENKg6nCPsGwPJbcABmtpCcx6TuuS8VWoRvnqZmylU33mRqra8ePuieYUjCovKvvFz3+pCqZVgInyLl03cyxgfS9pZW/bZq8bTJ0Zn2HSa9jzVXC1EeXSeoeZswmedgkSSe4WpjOJ82twFmvFgt1Z4m+kkr8GzduHPt/9erVuO+++xLm2759O9577z3s378/YVokEkFWVhZKSkrY+2VlZYhEIs489Kave3r3tEwydG/8BEHoX5TyzpEZxnYGgiD4nBTj39GjR1FU5D50yU7SmeTo0aO44447sHPnTuTkmC3chgoi9QqCTxGpVxAEv5Jq/CsqKmJ/yW78amtr0dDQgIsuugihUAihUAi7d+/Gxo0bEQqFUFZWho6ODjQ2NrLl6uvrUV5eDgAoLy9PqPLt/r97nkwhN36C4FPkxk8QBL+Syfh35ZVX4sCBA3j//fedvxkzZmDhwoXO63A4jF27djnLHD58GHV1daisrAQAVFZW4sCBA2hoaHDm2blzJ4qKijBlypSM7TcwhKVeKxjo6txBcwq0/IBAoVtOHy90cyzaR7h35NkkdyOk5+ulkr9nstwAeM4MdZsvdsdyepybo5fzGc+vCLeRZuIk30aRcvh4vpu7Ecvn+R3tI9z/v3be35zXvzv3t87r/2l2fync/bf5bPm2ke52cke6Y85uOOmOi+ZYaOkhLP/RlGvmZadiwDNfKIW8PJr7p7R8O2NeEjnmXh1FmFUEzfdThnwX7ZxhuVQpnH8WyXECAKuAu/pbdgA4id7h45ZFZww0/ul2IuTcUn3N1yM5YswahNppaXYqCsmtWvRuM0ZM+a7kiQq7lrK1HG+aZE8taKjUFjbnOKpA8pjNhniaxOg2LQDSfc6hx4/EmJDW7SNOPhv6Pv0saY6mnu9L4xn9PGmcUjQPWes8ROMJ7fZBcv9YXp8mhbIOJYZ1sfk9LNhMsHl0KVY7Z/piZ5XJ+FdYWIjzzz+fvZefn4/S0lLn/cWLF2PlypUYOXIkioqKcNttt6GyshKXXnopAGDu3LmYMmUKbr75Zqxfvx6RSAR33303qqurkz5l7AtD9sZPEIT+RXz8BEHwKwMd/zZs2IBAIIAFCxagvb0dVVVVeOSRR5zpwWAQzz//PJYuXYrKykrk5+dj0aJFWLNmTWYHArnxEwTfYtmK92tNMl0QBGE40t/x780332T/5+TkYNOmTdi0aZNxmQkTJuDFF1/s03ZTYeje+NlfiuzUnTxba3hPHgPbucl3RYWoo71XY77kjbWp1JHw2J0+fi10ZYhTX3Ul6Ka/d5cPVvAxlr/tPh4PfUoetRMJMNDuvs4/zp9px8Pu8fi4ZrzzemrDYud1Z5s75qI/8fGXHHElhazPSDN36qJPxuLVMJvZuXhZjJgsXAzLeMlTpm4fVJ7VpV6KyeqFSQ1e208FXV4yyLv6uW1CkZQG2Aoqntw6I7WVQaTeoUo8DlhxbnOht26iKQkGmyGWwqBZeQSIVMekPlN6jXa9mOyILCoh0ljq1TlD60jjQK9fbf+tPCI10uNEZFcq4VpxfkLHSlxJOJ7tHr9Qmzv+eAGxSdH2P1bg7k+4mcRssrze+iJ0klil0K5SVBL1Ok5x8hkauhUZPz8A9im3Q5Px8/CodA3kkU5S7QbbIEMKjT4fS0Og++9hwWW0s+kNPo5/Q/fGTxCEfkWkXkEQ/Iqf45/c+AmCXxEfP0EQ/IqP49+QvfFTqssZnMkGp1vZPPSxcTjS5LwORt1H+FQ2pY3AAU36MDSvZo+ww1yOs4gMHSeSQuM5ruyQf9lnzuvPP3G7iwBAwd/cZYqb3H2zSFVX8HO3c0bwBGkEDiA74u5n6UF3bB2kqjnU4u5/sOkEWz7Q7MoOqsmVAOhxYfKSLsdSeZc9njdINYBZ3mXVvz13AUjYDkUll7oA74pdd/Nk+x6yC+vckcK6AHBJK8sg71LZKp9X9dq0elApqHjvg1NPlgVi5zJ4qLgNZcV55aXWKsqi8YjGL7oerdML34ahEjOevELY0ucn26QVvwHaxYhV0Wudi8LJq4cZNL1G/yImXSGoE4LKJU4Ixe48baX8Wm4bQeRxtnl3m7FC92i2j9Ck4tHu90m43t3n3AZ3maK/8mOW35o8jShw0o3zrHOFVhWsbFM8pPKyh6sATU8yfOclpBTQ7Zum0c+GblPrVsUqw2n8N3z+eucPu4XcAygbSvU+FcfP8S8tr4377ruvq4Sa/E2aNMmZ3tbWhurqapSWlqKgoAALFixIMCQUBGFo0C11eP0JLhL/BGH44Of4l7bJ2nnnnYfjx487f2+99ZYzbcWKFXjuueewY8cO7N69G8eOHcP8+fM91iYIwqBhq57/0iATN0Z1dXWYN28e8vLyMHr0aNx5553o9HgCMdBI/BOEYUKG49+ZRNpSbygUSto+pKmpCVu3bsXTTz+N2bNnAwC2bduGyZMnY+/evY5JYcrYXbfc1CTU84M44brYBlqTV6vZugEqwVg9Sr50AnlcdmNN08lj4SxXNcWp0+RRtTb8UBupxGonsnMnkXdok+6AZgZKJIFgszst97PkTcZ1qdymX6i24bl23CAhwFxJyNDl4VQMncky+pN8kzxLq3ctQ7Ub4CEpGeTdhP2iBqImo1xm5uwhVdNjS7c/gjR81yrJO4tdqSYQsxHv7IMe0Q9Vbeeddx5ee+015/8QOZYrVqzACy+8gB07dqC4uBjLli3D/Pnz8fbbbwMA4vE45s2bh/LycuzZswfHjx/HLbfcgnA4jLVr16Y/mH5gwOLfl7C0k8JCPpGmrlADeHr+0XNUN9M1GY1nEXmWVvvqaQ/knKXyLkuhoYbr2rnMKo6ZaTGRpOn1p2+fxElmgE+k3niOu/3To/m1eKqCLFNOth9wj9/IYtft4L6Jr7DlL8g+5rx+7MRlzuv/rrnEeZ1zgm8zh1QJh6JubFcFpPo46qb0KD0u0+8AGlup7G+T46JJpew40/hNU6I8Kmd5xTU5fqbzRIt/locM7KyLunVopuGJRvt9aD7m46retI/akSNHMHbsWHz1q1/FwoULUVdXB6CrV10sFsOcOXOceSdNmoTx48ejpqbGuL729nZEo1H2JwhC/2Mp5XhZJf3rRXJz941R999ZZ50FwL0xeuihhzB79mxMnz4d27Ztw549e7B3714AwKuvvopDhw7hqaeewgUXXICrrroKDzzwADZt2oQOzYpksJD4JwjDg/6If2cKad34zZw5E0888QRefvllbN68GR9//DEuv/xynDp1CpFIBFlZWSgpKWHLlJWVIRKJGNe5bt06FBcXO3/jxo3r1Y4IgpAeqea46Dcm7e3mJ+d9uTGqqanB1KlTUVZW5sxTVVWFaDSKDz74oB+OQHpI/BOE4YOfc/zSknqvuuoq5/W0adMwc+ZMTJgwAf/93/+NXK2naKqsWrUKK1eudP6PRqNdwS9gdT1ypnJYQt9WalRJHhu3tiZ9X5c6GLQSlEoNBgkFAJNRg5+7VcUlf3Yf258IufJMfjNfPvcY+XVPpF5ebZyiVEgfz9NKwFQqTwGzUayHNGuUd70wmTvT4x8KJ58n1XWlYAydgKn6UFvespIbkJqMRRN6ZVIZmUpyNI2g0/C5Agh0uNPaR2ajM9b/Uq9+M7J69Wrcd999CbN33xide+65OH78OO6//35cfvnlOHjwYEo3RpFIhN30dU/vnjbYDGT86+5VzvpJa9IYi0eGNBhjtS146gursE0l7UPbvmUnj5/MAD5BajZUuFMDdvIjI6Ab+NPUnVEj3GEWuPtJjZmDHfwYBdvd7XS0kr7lI9zvj3NKPndeH2w9my1fGHDnayU9eENRYtqvbdPOIrGJyvhUajWZWUMz1292P1t2zHuTE0s+S69e6SzmUXm/1RBI9F6/pnXTOEermvXevnSZjo7U43vSscG3Um+f7FxKSkrwta99DX/+85/x7W9/Gx0dHWhsbGTBvb6+PmlOTDfZ2dkZb0AsCELPWMpbzuiedvToURQVFTnvm67X/rgxGspI/BOEM5dU499wpA+ZkUBzczP+8pe/YMyYMZg+fTrC4TB27drlTD98+DDq6upQWVnZ54EKgpBZrLjq8Q8AioqK2F+qNyr0xqi8vNy5MaLQG6Py8vKEKt/u/71ungYLiX+CcOaSavwbjqR14/fDH/4Qu3fvxieffII9e/bg+uuvRzAYxHe/+10UFxdj8eLFWLlyJd544w3U1tbi1ltvRWVlZa8r2gRB6EdUCn99IN0bo8rKShw4cAANDQ3OPDt37kRRURGmTJnSt8FkAIl/gjCM6Of4N5RJS+r929/+hu9+97v44osvMGrUKFx22WXYu3cvRo0aBQDYsGEDAoEAFixYgPb2dlRVVeGRRx7p3cji8YT8soQG94a8FtpMm+WRBPn6bK9cgm5I+blqbmGTTHkVOcdcP5dRbW6+X6Cd58jQrhyKWTNQF3Q6Fp7vxXJ8SF6jseQ/oYtG8rxAU8NtPceRHluWy0PX5ZVXaFE7GHJsFHWu1/L9Usjp8Nq+0faF7qdpHsDcdJ7mntDcJ31wBrd81oCeva/72bjTQqfjidPTIcMti374wx/immuuwYQJE3Ds2DGsXr066Y3RyJEjUVRUhNtuu43dGM2dOxdTpkzBzTffjPXr1yMSieDuu+9GdXX1kJBDBzT+fUmA7Ld9+jSfSK1SaPyi+XZBs32G0YKFHmuDTZEO6/ZBh2gYF6DlH2q2I87ytDuH3vmD7tsp99gE8ty4nPMZmd/WOuWQLhjx46RDSac75oP5k53X75a6npQA8GT+Fc7rcNTd6xF/cecJtWr7HKJ5fSTmkI48qtBNi7BaeTW7dYrEtsICd72nXAsYljunx19TXjydxWDZAvC8Ppt8H1o0lSNmzqX3Wrc7j+F7Adq5FQrBUjbQW5tPadmWGtu3b/ecnpOTg02bNmHTpk19GpQgCP1PppuU9/XGKBgM4vnnn8fSpUtRWVmJ/Px8LFq0CGvWrOnN7mUciX+CMHzIdPw7kxiyvXoFQehfrLiC5RHd0s1xycSN0YQJE/Diiy+mtV1BEIR0yXT8O5M4o278PGVDA8yyQHcRpxYG9BE4lZSpbKxZa1CrASpJ0MfzoVOkEXeb9kyaro8+VqYSIrU5sfjHZbRTMZXz68dPEanEUGbPu3topfm2Qd5l1ihmKdIKU6mVvE/k3YRH/dTqgUqyhg4ZCcsHDTI4TQkwNTzXlzFhssMAeJN0ui6DbY/VzOW9QCGRvgIWAn3q3OFfqeNMgXWE0c7lQG6WPnt669ZTZ7pJ9Vo2pYcEUksdDxS5UiWziqFxxjKkvQBctix0U2poCo1V4m4jqKXa5HxmslYhEmzInaezQOs80umOLUBjMb2s2/kxjue564iNSF7pHmom1l76Z0xlfPL5We1kPiqVat2aWPeUjuQWMmwbmgUQk/RDyWV8k81PAjSNynAu6ikANCVBxW3P9IMe8XH8O6Nu/ARByCA+9rESBMHn+Dj+yY2fIPgUP/tYCYLgb/wc/4b8jZ8yVO52kbx6U8V6lgABrZIt1W4RBPaom0oFp91qtaBXdwu6TJhsn1ay0cq1Nq3CyyLSRTaRDegJSzuCtGvLExmDNgM3yrO6VEylVkNVtKW0Zah0RBt7GyTYhM+PjoFIzX1ycNeh2/SQqpnMkEIXD0BLDyCyL2+YTqvNtfOS5J0E2jsR6I1Lfze2YutLOl0YFFTchrLi3JVAi1HGzhumqnz9XKFVwbSjjKlCV78W2dio1EtisVe3JHJ+0QpfK8UKeXp2Wk1uVSvdTyrB0spZALBIJxAqSaowlbfdY5R9mu+LovHbcJNApWKAO060j3Kv/44C0mEk5sb/vHoes7OjWmV3N1TC9YhZLHXFFKfIvtgtXCqGwTHDuE298wd10qDvk+UD+a5sr5+zLOYGLED/fkkHH8e/IX/jJwhC/+DnX7yCIPgbP8c/ufETBL+i0ENy84CNRBAEYWDxcfwbujd+wSBgBZmcl6oZsGVWd/kiVDoxVXh6SMUM8ghb0bHQqiatQoo+ardHu03GbWJASqVe/am2nU0MSHPINslT91CzO65wg2ssDQBWtJnMSKSetuSyC5PGgcSKV2cwHlWxKVTiGo2dAVgBImnR88EwFlY5rI2NyVs0AHhJJaz6zRAZgmSbHhWOpmbqVIJCSJfX3HUHOuK8mjBdfFzVNtSxrMSUAd2AnlZosupfmnZAY1mWuULUWB1Jr3/tfKXm0mx5Ui1q5ZEUFP18J9cfHRs3nfYwjSZxCja5ZkmFvGKuDtrxozI0TYMh1cYWvf46dYcAEqeoPJztfi6d+VyejxW5850a575umuqOJbeOfK4W/8wC7SXO6/DRL8g4SSyjUnex22MbAOInTrrL6OeD83446WsARnmeScB0LJrUz1KCyLkVMBjb658+uyaCwS4D53b0Dh/Hv6F74ycIQr9ixRUsj5+1w9nHShAEf+Pn+Cc3foLgV3z8i1cQBJ/j4/g3dG/87C/7qbBqzRRlVxN65adJqjShVyjRijP6eDxoWK9mZhkfVey8Pn22W8nUPIYYKJPejtGvcalhytQ653VDiytPfPFhqfM6j/SgPOuP/LF97l/I+EklMkjlKaucC5lPF3oseK9b8zE39sT1qNClRp8BcsxtU/WgZnDMzKlphVmASwgOutRMZQhlMLCl6AamtErXy9y0exu61EunhYNQKZrlJl+BfwPfUEfFFZRlw6Kfr1eFpCnmUPTl6blNUyAMEmBA65dskoeZSbmp8hfgUi9Jb1AtpHKVDtmrcp8aABsMGlSTlupSkJ98LHRd9LW2v4pWBZ92Y2acmKzrT42ay90dip7jHvPJ53zqvP7rSDft57PiQrZ87hfuzoWIaTWP3yRGtXEdlEnqBnmYnVfaZ0bPGd4TPXkleYIBNHVyMLzPUor0pgusuUEP8asnfBz/hu6NnyAI/YuPA58gCD7Hx/FPbvwEwaf4OcdFEAR/4+f4Jzd+guBXfPyLVxAEn+Pj+Dd0b/yUDcBOcKtns3TSvK7kjcVNOWVdk+yk89GSdUXsZAIeOW4sF4zmcdFG1AV5YJB8sY58d75Yvvt+8znu9v/vJfvZ4v9e/v+c1yfjbl7M94v+j/P6/XfOcV7burWJodsGy92h5fNaFwmWP2JydM8wKeXoMbSxUKsdPf/wS2geod6RhFlakHWxsdAuCvqxYFY3tMMB7SJDtqnl+Fl6zmJf7Fy682i9pguDCsuj0jstBJLbBrE8KpLTpVp5FwaWy2eKbTSnS88ntQ0ddug5bpP15ru5bwB4/pwJui79WqKde5jtlCH3McxzF5nVC7UtodZcuZoFF4VcmzbN64u5Y+4s4cvTyy1Q6n5Oi7/ylvP6cOkY5/Xjn/0DW755jDvOnE/J50+7rTCbKi33mXQFYp2jDJ2D9O8I1nmIxjlTF5CYtn363RrX7MG612Wy2dJQ8ThUXzo2+Tj+9SEzXBCEM5ruX7xef4IgCMORDMe/devW4eKLL0ZhYSFGjx6N6667DocPH2bztLW1obq6GqWlpSgoKMCCBQtQX1/P5qmrq8O8efOQl5eH0aNH484770RnX1pzJkFu/ATBryi766mN6S+T/Y8FQRCGEhmOf7t370Z1dTX27t2LnTt3IhaLYe7cuWhpaXHmWbFiBZ577jns2LEDu3fvxrFjxzB//nxnejwex7x589DR0YE9e/bgySefxBNPPIF77703Y7sNDGWp1wp0/SmDHAuPzhsUKkFqrS+49EuaROtu5d3z678AmNSR3ALBJKcCYJ04sprddbW1u/uZc9xd/n8PXsiWf/eL8e4yne58kb+6di4j/uxuJHRa60hBpBb2CD+YvHOG3rmDyVBUUvWyYzFZuNDPln5m2qN4vZNHj9vQ5SHT2EwSsP643yBpMUmYyhnQ3f6Ty+Bsedp5IdrCZ8wjklJnHAG7t7b13eP0p9Qx1LGCFqw07KaUqSMNTVvQrTnotKDBNibsYVPFrI3ccyVgsElJsCYKGyxUmIRNxqxJw0yqptd1jMrDNIXHHDtUO1meyqYenZcU6fbBpM5ccsw6tfQiMoScXHf5qrwG5/XMnGPO660F32DLh9poJycSJ8mxZHFaT2+ix4wuQ9N2yGeu28GwdbGUKio79xyjAW77w7qAUJs0TUJmqTbxOKBS21ZSMhz/Xn75Zfb/E088gdGjR6O2thZXXHEFmpqasHXrVjz99NOYPXs2AGDbtm2YPHky9u7di0svvRSvvvoqDh06hNdeew1lZWW44IIL8MADD+Cuu+7CfffdhyyD1VK6yBM/QfAryu75TxAEYTiSYvyLRqPsr709tR/bTU1NAICRI0cCAGpraxGLxTBnzhxnnkmTJmH8+PGoqakBANTU1GDq1KkoKytz5qmqqkI0GsUHH3yQkd0G5MZPEPyL5PgJguBXUox/48aNQ3FxsfO3bt26Hldt2zaWL1+OWbNm4fzzzwcARCIRZGVloaSkhM1bVlaGSCTizENv+rqnd0/LFENX6v2yqjfxPfqvQdKj81GpMqGq1yA1Umglm97FwSAJswozOo/W5DvQ4f6f3ehWPxWScRX+jSxwgG+vpXCs8zrU5u7bV4j/UPZJ97F/9rEoH38bcUs3OLczOVuv3DIdc3ostc/MeMzJfCqmkr4PmCu2+TbIMql2a6Hjss3jZ9Os5OeGZ1UalY5Msi/tYqD9uqTT+nxzFu/hqV4KnUWE/kEpQEGZqyUB74rXpOvU4p9J3qXLUNlQk5mYdEw7L5BKTna+6hWi2UQSjbquBBaVGsm6lJbgbnQPoDGbVZHyCtNAvuuywOIfTbWAR1Uv2U6gxa2YtoPuZxaI8X3OOeleUydOuev+LO5u8w+tf+euq5nH/GAHLQsmEwxxOiE6GORd5pbQnvz9hHXT6vHcXPd9evy085eltMSTO3Gw7kw0bQCAIpKwlZ3dlb7V27qHFOPf0aNHUVRU5Lydne1xTnxJdXU1Dh48iLfeeqvHeQeDtJ/4ffrpp7jppptQWlqK3NxcTJ06Fe+++64zXSmFe++9F2PGjEFubi7mzJmDI0eOZHTQgiBkAIUefvEO9gCHHhL/BGGYkGL8KyoqYn893fgtW7YMzz//PN544w2cffbZzvvl5eXo6OhAY2Mjm7++vh7l5eXOPHqVb/f/3fNkgrRu/E6ePIlZs2YhHA7jpZdewqFDh/Czn/0MI0a4vQXXr1+PjRs3YsuWLdi3bx/y8/NRVVWFtrY2jzULgjDgiNSbFhL/BGEYkeH4p5TCsmXL8Mwzz+D1119HRUUFmz59+nSEw2Hs2rXLee/w4cOoq6tDZWUlAKCyshIHDhxAQ4Nb7LNz504UFRVhypQpfdhZTlpS709/+lOMGzcO27Ztc96jO6eUwsMPP4y7774b1157LQDgl7/8JcrKyvDb3/4WN954Y8rbUraC0io6Ex47E0mPN4wmj6NNVaSp4iXNUamDyn70cTZ9tK499m4rdx9jK7LqUKu7TTvkLtM2km8/TvxQO3Pd+fLr3X0OthE5SJOajRVb9LG7l4GsSd6lxz9mvnhMBsr889MrCU3bSf68X//Mmek3k2oNy+jScKDn6jUmdaRq+k2P+WlXNrLyuek3a2Afj0PZyU1QU8JOkk6RMF3oZiDjnxUMwLKC3lXsNB7RNJaw+77FZE8tVYZ+sVF5j8h29JpPSG3xMDp3oDFHT7XpIPIqq+SnaRcGM3mAp/GYjhOtHNazNqKn3Glk31iqBpUz9e8fum+G7xYV1OIP+ThCx9wnR79svMR5HSNfBlY7jz+h07T6maadJK+wThhPR8w4zVlVKLkcC4BXeeuG3smW90h1UbR6Opg8rtunSbwDEoy6leqDv12G4191dTWefvpp/O53v0NhYaGTk1dcXIzc3FwUFxdj8eLFWLlyJUaOHImioiLcdtttqKysxKWXXgoAmDt3LqZMmYKbb74Z69evRyQSwd13343q6uqUJOZUSeuJ37PPPosZM2bghhtuwOjRo3HhhRfi8ccfd6Z//PHHiEQirGqluLgYM2fOdKpWdNrb2xOqZgRBGAC8PKy6/wQHiX+CMIzIcPzbvHkzmpqa8M1vfhNjxoxx/n79618782zYsAFXX301FixYgCuuuALl5eX4zW9+40wPBoN4/vnnEQwGUVlZiZtuugm33HIL1qxZk7HdBtJ84vfRRx9h8+bNWLlyJf71X/8V+/fvx+23346srCwsWrTIucNNVpViqkhZt24d7r///l4OXxCEXiM+fmkh8U8QhhEZjn9eT1q7ycnJwaZNm7Bp0ybjPBMmTMCLL76Y1rbTJa0bP9u2MWPGDKxduxYAcOGFF+LgwYPYsmULFi1a1KsBrFq1CitXrnT+j0ajGDduXNJ59cf5VJLrs7zLqntSqPAFmNEu6wNJ+2aSR/CxUVy2o9Lt6dGkQoystsMtJsLpCv6YvmhUs/P6VJMrz3QcIia/tjuubIusDEBWqyvvqJihbyKTkzwqZFklNZ3F4/inYFBreRUrGj5nVr2dYPptqCQ2XeR6JTmRrtmxMUhVSu+lazoetHqS9kTW+qtySS/Upzw8pWzPXpd96oM5DBnI+Kc6Yl0G74bUBk/I+UeNcRPkWHou0XOZ9Wo1m/maTMvpOclMjvWqXvo/lXHp8vS60M51No3GZkOFaKqwVI0suv88T5OlYTD3B3ecNFUHAGsNS9N76kmgP3a62Hmd8xmPX3aYxq/kx5x9Fro8T7+zlOHzZxK67spgSG/pMJhZe8BMp+l3O00v0g2LaWzt7ARUitdEEvwc/9KSeseMGZOQYDh58mTU1dUBcKtOklWlmCpSsrOzE6pmBEEYAJTq+pIw/UlxB0PinyAMI3wc/9K68Zs1a1ZC0+EPP/wQEyZMANCV6FxeXs6qVqLRKPbt2+dUrQiCMESIx3v+Exwk/gnCMMLH8S8tqXfFihX4xje+gbVr1+I73/kO3nnnHTz22GN47LHHAHQ94l2+fDl+/OMfY+LEiaioqMA999yDsWPH4rrrruuP8QuC0FtUDzkuw/gXb2+Q+CcIwwgfx7+0bvwuvvhiPPPMM1i1ahXWrFmDiooKPPzww1i4cKEzz49+9CO0tLRgyZIlaGxsxGWXXYaXX34ZOTk5HmtOxAqHYFkh3khct+ZIN5dPzykz2ZFQUnDEB8CtRejrHPcQd+bydbWNcLcZK3Tf78x39ytW4v7quPDcT4ybPxpyvcRO5bnH2g67Ywm2aKX8NBeD7L9FElFUijYBqdqssFw8gwUPxZh71zXRXT5ILSxoHgjfZ5PbvzFfSZ+PLm7aT5O1BbT8P1OOMfNODgAACyhJREFUDe1WAN1Cg+yPUlCqZ3sGE8q2oXSPCzp9GOe49IYBjX9ZYVhWlqedC81/MubC0WtEb3hPv/RYXpihu4JmTcTOeZLjZtG4HPYQlYiFh0XzjWlemcEypGs+MjY6wWDzoo+f/U/HbLKTydKuazo2+j1FLFOC7fwa0nP+utl7fILzOi/LXb6jhC8fz6Exm7w2WXPpnX/IMadRjp0/9JjleFiI0FjE8kXJuLTPz/SZsWNOz+t+fOrm5/iXdsu2q6++GldffbVxumVZWLNmTcbLjwVByDBxO9HcjDKMA19vkfgnCMMEH8e/odurVxCE/kUpeBqYDmOpQxAEn+Pj+Dd0b/zi8S75kN116507DBYurJyflJl7dVGg2wkY5otpslqQPAan228nTcrbXAkgHOXL50eIhUvMfR3PJnYMn7ljOfzXiWz5jhHuNgPkiX5hnft+bsSdEGjm1iD08T5rUm4qzdcfu6di56LLnnQd1E6FLhOi8qZm4UMlUdXz58/sW/Rxss4dRB4yrCthedJVJFWp2CiX0+2TeSwvE9F4nB+4NEnWHYdNH8aBb6ijYnEoq5NLtZpzP7VXYRIaOWcDBQXuAlr8ossEdNuPblinBM3yySTDmp6U6F0jaLcGKlXadF+INKlbi9B4Ti20yLqYVKnvP5Wn6XaobEuv/06etsI67FDbEY/rJp7lxqwAGU4w4C7zaV2p8zr7NJeGw820Ewo5Htlk+80txu2zY0iXp2OmdlJa/KFxzm6jyyeP5Z43TwbbK9pdJJDLUySY1Y5lofdmLv6Of0P3xk8QhP5F9dCyaBhLHYIg+Bwfx78hd+PXfZfd+WXSuiI/HyxPs0WVdD6a/G6leAfPfwRQY1Ht6RM1j6QPkuiPqrj760n7wYhOYgYc7yBP/Mg26cOjuDZ8u4322iTzkR/mnZ3EwDWuJQCTPq9K0dfkmJHZVcLTJcMTP4r+vqJPtpI/rWImpwnH3PAr0/D5e4/HYObstS7j8skNaBO3n/w3Kj/O5H2P4wcVINdJ+r9OY/E2KJifGHai94UjQu/Q4x974qedO7RPKb1OAuxcpE/I+edpk+UDrCCELkPPce18YNPIU3ZFCz1oP1k90Z9MorHIjiWdKSHZnsUC8sSOxXx6LPTx0+ucLk+eKtHLytauXfI0jBa0KBKoafwFeGy2yaT4aTc2U9PteBv/iu4kTyM7STwP2OTpL+3frcVPZYifMH7+2hM/8r9Nj2cqcVGDf0+bzmXtnFG8OETiX+8Ycjd+p051Nc7+Q/zZxImpmrCbvvdTXT7V+dp6nsX39KaHttf1lsqPsEz+UBvsH32GYj2dU6dOobi4uOcZAWRlZaG8vBxvRXpuC1ReXo4s3T1f6Dec+Nf528SJqV5Lp3ueJYHhGsu8Ykkq+2xWTVPjL9r/e/q2uo/6tvjQIpXYluLxl/iXHpYaYkK2bds4duwYlFIYP348jh496ks3++7WTX7cfz/vO5De/iulcOrUKYwdOxYBD+sLnba2NnToOVtJyMrKStuKROg9Ev+68HMM8PO+AxL/BoIh98QvEAjg7LPPRjQaBQDftzHy8/77ed+B1Pc/1V+6lJycnGEZ0M50JP5x/Lz/ft53QOJff5JWyzZBEARBEAThzEVu/ARBEARBEHzCkL3xy87OxurVq5Gd7dEyZhjj5/33874Dsv+CnAN+3n8/7zsg+z8QDLniDkEQBEEQBKF/GLJP/ARBEARBEITMIjd+giAIgiAIPkFu/ARBEARBEHyC3PgJgiAIgiD4BLnxEwRBEARB8AlD8sZv06ZN+Lu/+zvk5ORg5syZeOeddwZ7SP3CunXrcPHFF6OwsBCjR4/Gddddh8OHD7N52traUF1djdLSUhQUFGDBggWor68fpBH3Hw8++CAsy8Ly5cud94b7vn/66ae46aabUFpaitzcXEydOhXvvvuuM10phXvvvRdjxoxBbm4u5syZgyNHjgziiIWBQOKfy3CPAd1I/JP4N5AMuRu/X//611i5ciVWr16N9957D1//+tdRVVWFhoaGwR5axtm9ezeqq6uxd+9e7Ny5E7FYDHPnzkVLi9uZesWKFXjuueewY8cO7N69G8eOHcP8+fMHcdSZZ//+/Xj00Ucxbdo09v5w3veTJ09i1qxZCIfDeOmll3Do0CH87Gc/w4gRI5x51q9fj40bN2LLli3Yt28f8vPzUVVVhba2VLrLC2ciEv8k/nUznPdd4t8go4YYl1xyiaqurnb+j8fjauzYsWrdunWDOKqBoaGhQQFQu3fvVkop1djYqMLhsNqxY4czz5/+9CcFQNXU1AzWMDPKqVOn1MSJE9XOnTvVP/zDP6g77rhDKTX89/2uu+5Sl112mXG6bduqvLxc/fu//7vzXmNjo8rOzlb/9V//NRBDFAYBiX8S/5Qa/vsu8W9wGVJP/Do6OlBbW4s5c+Y47wUCAcyZMwc1NTWDOLKBoampCQAwcuRIAEBtbS1isRg7HpMmTcL48eOHzfGorq7GvHnz2D4Cw3/fn332WcyYMQM33HADRo8ejQsvvBCPP/64M/3jjz9GJBJh+19cXIyZM2cOi/0XEpH4J/Gvm+G+7xL/BpchdeP3+eefIx6Po6ysjL1fVlaGSCQySKMaGGzbxvLlyzFr1iycf/75AIBIJIKsrCyUlJSweYfL8di+fTvee+89rFu3LmHacN/3jz76CJs3b8bEiRPxyiuvYOnSpbj99tvx5JNPAoCzj368FvyKxD+Jf90M932X+De4hAZ7AEIX1dXVOHjwIN56663BHsqAcPToUdxxxx3YuXMncnJyBns4A45t25gxYwbWrl0LALjwwgtx8OBBbNmyBYsWLRrk0QnCwCLxz19I/BtchtQTv7POOgvBYDChcqm+vh7l5eWDNKr+Z9myZXj++efxxhtv4Oyzz3beLy8vR0dHBxobG9n8w+F41NbWoqGhARdddBFCoRBCoRB2796NjRs3IhQKoaysbNjuOwCMGTMGU6ZMYe9NnjwZdXV1AODso9+uBT8j8U/in8Q/iX8DwZC68cvKysL06dOxa9cu5z3btrFr1y5UVlYO4sj6B6UUli1bhmeeeQavv/46Kioq2PTp06cjHA6z43H48GHU1dWd8cfjyiuvxIEDB/D+++87fzNmzMDChQud18N13wFg1qxZCdYVH374ISZMmAAAqKioQHl5Odv/aDSKffv2DYv9FxKR+CfxT+KfxL8BYbCrS3S2b9+usrOz1RNPPKEOHTqklixZokpKSlQkEhnsoWWcpUuXquLiYvXmm2+q48ePO3+nT5925vmXf/kXNX78ePX666+rd999V1VWVqrKyspBHHX/QavalBre+/7OO++oUCikfvKTn6gjR46oX/3qVyovL0899dRTzjwPPvigKikpUb/73e/UH//4R3XttdeqiooK1draOogjF/oTiX8S/7oZzvsu8W9wGXI3fkop9Ytf/EKNHz9eZWVlqUsuuUTt3bt3sIfULwBI+rdt2zZnntbWVvWDH/xAjRgxQuXl5anrr79eHT9+fPAG3Y/ogW+47/tzzz2nzj//fJWdna0mTZqkHnvsMTbdtm11zz33qLKyMpWdna2uvPJKdfjw4UEarTBQSPzb5swz3GMAReKfxL+BwlJKqcF51igIgiAIgiAMJEMqx08QBEEQBEHoP+TGTxAEQRAEwSfIjZ8gCIIgCIJPkBs/QRAEQRAEnyA3foIgCIIgCD5BbvwEQRAEQRB8gtz4CYIgCIIg+AS58RMEQRAEQfAJcuMnCIIgCILgE+TGTxAEQRAEwSfIjZ8gCIIgCIJP+P9icOY2NXwLWAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 8 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from utils.visual_utils import show_train_img\n",
+    "show_train_img(image_num=4, camera_params=params.Camera, psf_params=params.PSF_model, train_params=params.Training)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65765be1-1156-4299-9bb4-dab248c92cad",
+   "metadata": {},
+   "source": [
+    "## Train Your LiteLoc Model\n",
+    "To train the LiteLoc model, use the <span style=\"background-color: lightgrey;\"> _liteloc_train_demo.py_  </span> script along with the parameter file you saved or one provided by us. The command for training the LiteLoc model in the terminal is shown below. Replace <span style=\"background-color: lightgrey;\"> [_folder\\\\parameter_file_name.yaml_] </span>  with the path to the parameter file you selected."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4700bedb-edfe-4a21-9196-0afb5d355490",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! python liteloc_train_demo.py --train_params_path [folder\\parameter_file_name.yaml]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06a669cf-e5a0-433a-8df0-23272861d9c9",
+   "metadata": {},
+   "source": [
+    "## Model Inference\n",
+    "Similar to the training process, parameter setting is the first step to apply the pre-trained model. As single molecule localization (**SMLM**) technology involves a temporal and spatial trade-off, the number of input image frames is typically large when implementing 3D localization and synthesizing 3D super-resolution images. Device settings play a key role in accelerating the inference process. To define your own parameters, use the following code, similar to the one provided above."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88510c03-4077-48cd-8a9d-6abf89359f34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils.gui_utils import Infer_GUI\n",
+    "infer_params_dict = Infer_GUI()\n",
+    "\n",
+    "print(show_confirming_string(infer_params_dict))\n",
+    "\n",
+    "infer_params = dict_to_namespace(infer_params_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c08df480-365d-4221-8a58-6d04ae98d0ea",
+   "metadata": {},
+   "source": [
+    "Alternatively, to run the pre-trained model we provided, you can load the parameter files stored in the demo folder, along with the downloaded model and dataset. The parameter files are listed below:\n",
+    " - demo\\\\demo-fig3a\\\\infer_params_demo_fig3a.yaml\n",
+    " - demo\\\\demo-fig3d\\\\infer_params_demo_fig3d.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ce5314c5-ba8a-47cc-8e25-355a57e923bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from utils.help_utils import load_yaml_infer \n",
+    "infer_params= load_yaml_infer('demo/demo-fig3a/infer_params_demo_fig3a.yaml')\n",
+    "print(infer_params)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e233194-72a1-4836-ae61-94f2584f5f52",
+   "metadata": {},
+   "source": [
+    "The inference process for the LiteLoc model is implemented in the Python script <span style=\"background-color: lightgrey;\"> liteloc_train_demo.py </span>, along with the selected parameter file. The command is shown below. Replace <span style=\"background-color: lightgrey;\"> [folder\\\\\\\\parameter_file_name.yaml] </span> with the path to the parameter file you selected."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "52cbb30d-e74b-4ca1-8932-26354bebf28b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! python liteloc_train_demo.py --infer_params_path [folder\\parameter_file_name.yaml]"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/liteloc_infer_demo.py b/liteloc_infer_demo.py
new file mode 100644
index 0000000..bfac78a
--- /dev/null
+++ b/liteloc_infer_demo.py
@@ -0,0 +1,51 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ['CUDA_VISIBLE_DEVICES'] = "0"  # If certain GPUs will be used, please set the index. Otherwise, delete this line.
+
+import logging
+logger = logging.getLogger()
+logger.setLevel(logging.ERROR)
+
+import torch
+import time
+from network import multi_process
+from utils.help_utils import load_yaml_infer
+import argparse
+
+if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-p', '--infer_params_path', type=str, default='infer_params_demo_fig3a.yaml')
+    args = parser.parse_args()
+
+    # yaml_file = 'infer_params_demo_fig3a.yaml'  # remember to change p probability
+    infer_params = load_yaml_infer(args.infer_params_path)
+
+    test_model = torch.load(infer_params.Loc_Model.model_path) # suitable for both DECODE and LiteLoc 
+
+    multi_process_params = infer_params.Multi_Process
+
+    torch.cuda.synchronize()
+    t0 = time.time()
+    
+
+    liteloc_analyzer = multi_process.CompetitiveSmlmDataAnalyzer_multi_producer(
+        loc_model=test_model,
+        tiff_path=multi_process_params.image_path,
+        output_path=multi_process_params.save_path,
+        time_block_gb=multi_process_params.time_block_gb,
+        batch_size=multi_process_params.batch_size,
+        sub_fov_size=multi_process_params.sub_fov_size,
+        over_cut=multi_process_params.over_cut,
+        multi_GPU=multi_process_params.multi_gpu,
+        end_frame_num=multi_process_params.end_frame_num,
+        num_producers=multi_process_params.num_producers,
+    )
+
+    torch.cuda.synchronize()
+    t1 = time.time()
+
+    print('init time: ' + str(t1 - t0))
+
+    liteloc_analyzer.start()
+    print('analyze time: ' + str(time.time() - t1))
diff --git a/liteloc_train_demo.py b/liteloc_train_demo.py
new file mode 100644
index 0000000..f3db2dd
--- /dev/null
+++ b/liteloc_train_demo.py
@@ -0,0 +1,39 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ['CUDA_VISIBLE_DEVICES'] = "3"
+
+import argparse
+from utils.help_utils import load_yaml_train, writelog, setup_seed
+from utils.visual_utils import show_sample_psf, show_train_img
+
+
+if __name__ == '__main__':
+
+    setup_seed(15)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-m', '--model_name', type = str, default = 'LiteLoc', choices = ['LiteLoc', 'DECODE'])
+    parser.add_argument('-p', '--train_params_path', type=str, default='train_params_demo_fig3a.yaml')
+    args = parser.parse_args()
+    
+    # if args.model_name == 'DECODE':
+    #     os.environ['CUDA_VISIBLE_DEVICES'] = "1"
+
+    params = load_yaml_train(args.train_params_path)
+    
+    if args.model_name == 'LiteLoc':
+        from network.loc_model import LitelocModel
+        model = LitelocModel(params)
+    else:
+        from network.loc_model_decode import DECODEModel
+        model = DECODEModel(params)
+
+    # liteloc = LitelocModel(params)
+
+    show_sample_psf(psf_pars=params.PSF_model)
+    show_train_img(image_num=4, camera_params=params.Camera, psf_params=params.PSF_model, train_params=params.Training)
+
+    writelog(params.Training.result_path)
+
+    # liteloc.train()
+    model.train()
\ No newline at end of file
diff --git a/utils/gui_utils.py b/utils/gui_utils.py
new file mode 100644
index 0000000..4b344f0
--- /dev/null
+++ b/utils/gui_utils.py
@@ -0,0 +1,943 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Mar 21 15:10:12 2025
+
+@author: Spike RX Wang
+"""
+
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import yaml
+import recursivenamespace
+from types import SimpleNamespace
+import os
+
+def load_yaml_infer(yaml_file):
+    with open(yaml_file, 'r') as f:
+        params = yaml.load(f, Loader=yaml.SafeLoader)
+    return recursivenamespace.RecursiveNamespace(**params)
+
+def dict_to_namespace(data):
+    if isinstance(data, dict):
+        return SimpleNamespace(**{key: dict_to_namespace(value) for key, value in data.items()})
+    elif isinstance(data, list):
+        return [dict_to_namespace(item) for item in data]
+    else:
+        return data
+    
+def namespace_to_dict(namespace):
+    """
+    将 SimpleNamespace 或者字典类型递归地转换为普通字典。
+    """
+    if isinstance(namespace, SimpleNamespace):
+        return {key: namespace_to_dict(value) for key, value in namespace.__dict__.items()}
+    elif isinstance(namespace, dict):
+        return {key: namespace_to_dict(value) for key, value in namespace.items()}
+    else:
+        return namespace
+    
+def load_yaml_train(yaml_file):
+    with open(yaml_file, 'r') as f:
+        params = yaml.load(f, Loader=yaml.SafeLoader)
+    params = dict_to_namespace(params)
+    return params
+
+def save_yaml(params, yaml_file_path):
+    params = namespace_to_dict(params)
+    with open(yaml_file_path, 'w') as yaml_file:
+        yaml.dump(params, yaml_file, sort_keys=False, default_flow_style=False)
+
+
+def select_path(Type = 'folder'):
+    root = tk.Tk()
+    root.withdraw()
+    
+    top = tk.Toplevel(root)
+    top.wm_attributes("-topmost", 1)
+    top.withdraw()
+    
+    if Type == 'file':
+        path = filedialog.askopenfilename(
+            title="Select file",
+            initialdir=os.getcwd(),
+            parent=top,
+            filetypes=[
+                ("All files", "*.*"),
+                ("Parameter files", "*.yaml")
+                # ("Text files", "*.txt"),
+                # ("Python files", "*.py"),
+                # ("Image files", "*.jpg *.png *.gif")
+            ]
+        )
+    elif Type == 'folder':
+        path = filedialog.askdirectory(
+            title = "Select folder path",
+            initialdir = os.getcwd(),#os.path.join(os.getcwd(), 'demo'),
+            parent = top
+        )        
+    
+    root.destroy()
+    return path 
+
+def show_confirming_string(Dict, ini = True):
+    show_str = '' 
+    for i, (key,value) in enumerate(Dict.items(), 1):
+        if not isinstance(value, dict):
+            show_str += f"{key} : {value}"
+            if i == len(Dict) and ini: 
+                continue
+            else:
+                show_str += '\n'
+        else:
+            show_str += f"--{key} :\n"
+            show_str += show_confirming_string(value, False)
+            
+    return show_str
+
+def Camera_GUI():
+
+    def on_camera_select(option):
+        if camera_vars[option].get() == 1:
+            for i in range(2):
+                if i != option:
+                    camera_vars[i].set(0)
+        else:
+            camera_vars[option].set(0)
+
+    def get_parameters():
+        option_camera = None
+        for i in range(2):
+            if camera_vars[i].get() == 1:
+                option_camera = i + 1
+                option_camera = 'sCMOS' if option_camera == 1 else 'EMCCD'
+                break
+        
+        value_dict = {'camera': option_camera}
+        for key, value in entry_dict.items():
+            value_dict[key] = float(value.get().strip()) if value.get().strip() else None
+            
+        return value_dict
+    
+    
+    def show_result_window(result):
+        result_window = tk.Toplevel(root)
+        result_window.title("Setting Confirming...")
+    
+        show_str = "Settings:\n" + show_confirming_string(parameters)
+        # show_str = "Settings:\n"
+        # for i, (key, value) in enumerate(parameters.items(), 1):
+        #     show_str += f"{key} : {value}"#f"自定义显示内容:\n{result}"
+        #     if i != len(parameters):
+        #         show_str += "\n"
+        result_label = tk.Label(result_window, text=show_str, justify=tk.LEFT, anchor=tk.W)
+        result_label.pack(padx=20, pady=20)
+    
+        close_button = tk.Button(result_window, text="Confirm", command=root.destroy)
+        close_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+        retry_button = tk.Button(result_window, text="Redo", command=result_window.destroy)
+        retry_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+    def submit():
+        global parameters
+        parameters = get_parameters()
+        show_result_window(parameters)
+
+    # Main Window
+    root = tk.Tk()
+    root.title("Camera Parameter Setting")
+    root.geometry("600x400")
+    
+    # Frame setting
+    main_frame = tk.Frame(root)
+    main_frame.pack(padx=20, pady=20)
+
+    # camera
+    camera_frame = tk.Frame(main_frame)
+    camera_frame.grid(row=0, column=0, columnspan=3, sticky=tk.W, pady=5)
+    
+    camera_label = tk.Label(camera_frame, text="camera :", anchor=tk.W, width=15)
+    camera_label.grid(row=0, column=0, padx=5, sticky=tk.W)
+    
+    camera_vars = [tk.IntVar(value=0) for _ in range(2)]
+    camera_vars[0].set(1)
+    camera_button1 = tk.Checkbutton(camera_frame, text="sCMOS", variable=camera_vars[0], command=lambda: on_camera_select(0))
+    camera_button1.grid(row=0, column=1, padx=5, sticky=tk.W)
+    
+    camera_button2 = tk.Checkbutton(camera_frame, text="EMCCD", variable=camera_vars[1], command=lambda: on_camera_select(1))
+    camera_button2.grid(row=0, column=2, padx=5, sticky=tk.W)
+    
+    # Input bar
+    item_dict = {
+        'em_gain': 1.0, 
+        'surp_p': 0.5, 
+        'qe': 0.95, 
+        'spurious_c': 0.002, 
+        'sig_read': 1.535,
+        'e_per_adu': 0.7471,
+        'baseline': 100.0
+        }
+    
+    frame_dict = {}
+    label_dict = {}
+    entry_dict = {}
+    
+    for idx, (key, value) in enumerate(item_dict.items(), 1):
+        frame_dict[key] = tk.Frame(main_frame)
+        frame_dict[key].grid(row = idx, column=0, columnspan=3, sticky=tk.W, pady=5)
+        
+        label_dict[key] = tk.Label(frame_dict[key], text="{} :".format(key), anchor=tk.W, width=15)
+        label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+        
+        entry_dict[key] = tk.Entry(frame_dict[key], width=30)
+        entry_dict[key].grid(row=0, column=1, padx=5)
+        entry_dict[key].insert(0, "{}".format(value))
+    
+    # Submit
+    submit_button = tk.Button(main_frame, text="Submit", command=submit)
+    submit_button.grid(row=8, column=0, columnspan=3, pady=20)
+    
+    # Run main loop
+    root.mainloop()
+
+    return parameters
+
+def Training_GUI():
+# def window_one():
+
+    def on_noise_select(option):
+        if noise_vars[option].get() == 1:
+            for i in range(2):
+                if i != option:
+                    noise_vars[i].set(0)
+        else:
+            noise_vars[option].set(0)
+            
+    class Select_Path():
+        def __init__(self, key):
+            self.key = key
+        def __call__(self):
+            path = filedialog.askopenfilename() if 'data' in self.key else filedialog.askdirectory()
+            if path:
+                entry_dict[key].delete(0, tk.END)
+                entry_dict[key].insert(0, path)
+            
+    # def Select_Path(key):
+    #     path = filedialog.askopenfilename() if 'data' in key else filedialog.askdirectory()
+    #     if path:
+    #         entry_dict[key].delete(0, tk.END)
+    #         entry_dict[key].insert(0, path)
+    
+    # def select_file():
+    #     file_path = filedialog.askopenfilename()
+    #     if file_path:
+    #         # file_entry.delete(0, tk.END)
+    #         # file_entry.insert(0, file_path)
+    #         entry_dict['infer_data'].delete(0, tk.END)
+    #         entry_dict['infer_data'].insert(0, file_path)
+    
+    # def select_folder():
+    #     folder_path = filedialog.askdirectory()
+    #     if folder_path:
+    #         entry_dict['result_path'].delete(0, tk.END)
+    #         entry_dict['result_path'].insert(0, folder_path)
+    
+    def get_parameters():
+        
+        value_dict = {}
+        
+        type_dict = {
+            'max_epoch': int,
+            'eval_iteration': int,
+            'batch_size': int,
+            'valid_frame_num': int,
+            'em_per_frame': int,
+            'train_size': int,
+            'photon_range': int,
+            'result_path': str,
+            'infer_data': str,
+            'bg': float,
+            'perline_noise': bool,
+            'pn_factor': float,
+            'pn_res': int,
+            'factor': float,
+            'offset': float,
+            'model_init': str,
+            'project_path': str,
+            'project_name': str
+            }
+               
+    
+        for key, value in entry_dict.items():
+            # print(key, 'here')
+            if key == 'perline_noise':
+                
+                value_dict[key] = None
+                for i in range(2):
+                    if noise_vars[i].get() == 1:
+                        value_dict[key] = (i + 1 == 1)
+                        break
+            elif not isinstance(value, dict):
+                value_dict[key] = type_dict[key](value.get().strip()) if value.get().strip() else None
+            else:
+                value_dict[key] = [type_dict[key](v.get().strip()) if v.get().strip() else None for k, v in value.items()]
+                
+ 
+        return value_dict
+    
+    def show_result_window(result):
+        result_window = tk.Toplevel(root)
+        result_window.title("Setting confriming...")
+    
+        show_str = "Settings:\n" + show_confirming_string(parameters)
+        # show_str = "Settings:\n"
+        # for i, (key, value) in enumerate(parameters.items(), 1):
+        #     show_str += f"{key} : {value}"#f"自定义显示内容:\n{result}"
+        #     if i != len(parameters):
+        #         show_str += "\n"
+        result_label = tk.Label(result_window, text=show_str, justify=tk.LEFT, anchor=tk.W)
+        result_label.pack(padx=20, pady=20)
+    
+        close_button = tk.Button(result_window, text="Confirm", command=root.destroy)
+        close_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+        retry_button = tk.Button(result_window, text="Redo", command=result_window.destroy)
+        retry_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+    def submit():
+        global parameters
+        parameters = get_parameters()
+        show_result_window(parameters)
+
+    # Main Window
+    root = tk.Tk()
+    root.title("Training Parameter Setting")
+    root.geometry("600x800")
+    
+    # Fram setting
+    main_frame = tk.Frame(root)
+    main_frame.pack(padx=20, pady=20)
+    
+    item_dict = {
+        'max_epoch': 50,
+        'eval_iteration': 500,
+        'batch_size': 16,
+        'valid_frame_num': 100,
+        'em_per_frame': 10,
+        'train_size': [64, 64],
+        'photon_range': [4000, 40000],
+        'result_path': None,
+        'infer_data': None,
+        'bg': None,
+        'perline_noise': True,
+        'pn_factor': 0.2,
+        'pn_res': 64,
+        'factor': None,
+        'offset': None,
+        'model_init': None,
+        'project_path': os.getcwd(),
+        'project_name': 'LiteLoc-main'
+        }
+    
+    list_value_dict = {
+        'train_size': ['Height', 'Width'],
+        'photon_range': ['min', 'max'],
+        }
+
+    frame_dict = {}
+    label_dict = {}
+    entry_dict = {}
+    
+    button_dict = {}
+    
+    row_number = -1
+    for key, value in item_dict.items():
+        # if isinstance(value, int) or isinstance(value, float) or (value is None) or (key == 'project_name'):
+            
+        row_number += 1
+        
+        if key == 'perline_noise':
+            
+            # perline noise selection
+            frame_dict[key] = tk.Frame(main_frame)
+            frame_dict[key].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+            
+            label_dict[key] = tk.Label(frame_dict[key], text="{}：".format(key), anchor=tk.W, width=15)
+            label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+            
+            noise_vars = [tk.IntVar(value=0) for _ in range(2)]
+            noise_vars[0].set(1)
+            noise_button1 = tk.Checkbutton(frame_dict[key], text="True", variable=noise_vars[0], command=lambda: on_noise_select(0))
+            noise_button1.grid(row=0, column=1, padx=5, sticky=tk.W)
+            
+            noise_button2 = tk.Checkbutton(frame_dict[key], text="False", variable=noise_vars[1], command=lambda: on_noise_select(1))
+            noise_button2.grid(row=0, column=2, padx=5, sticky=tk.W)
+            
+            entry_dict[key] = None
+                        
+            
+        elif not isinstance(value, list):
+            # row_number += 1
+            frame_dict[key] = tk.Frame(main_frame)
+            frame_dict[key].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+            
+            label_dict[key] = tk.Label(frame_dict[key], text="{} :".format(key))
+            label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+            
+            entry_dict[key] = tk.Entry(frame_dict[key], width = 30)
+            entry_dict[key].grid(row=0, column=1, padx=5)
+            if value is not None:
+                entry_dict[key].insert(0, value)
+                
+            # if key == 'infer_data':
+            #     file_button = tk.Button(frame_dict[key], text="Open", command=select_file)
+            #     file_button.grid(row=0, column=2, padx=5)
+                
+            # elif key =='result_path':
+            #     folder_button = tk.Button(frame_dict[key], text="Open", command=select_folder)
+            #     folder_button.grid(row=0, column=2, padx=5)
+            if ('data' in key) or ('path' in key):
+                button_dict[key] = tk.Button(frame_dict[key], text="Open", command=Select_Path(key))
+                button_dict[key].grid(row=0, column=2, padx=5)
+                
+        else:
+            # row_number += 1
+            frame_dict[key] = {}
+            frame_dict[key][0] = tk.Frame(main_frame)
+            frame_dict[key][0].grid(row=row_number, column=0, sticky=tk.W, pady=5)
+            
+            label_dict[key] = {}
+            label_dict[key][0] = tk.Label(frame_dict[key][0], text="{} ：".format(key), anchor=tk.W)
+            label_dict[key][0].grid(row=0, column=0, padx=5, sticky=tk.W)
+            
+            # print(key)
+            entry_dict[key] = {}
+            # print(key)
+            
+            row_number += 1
+            
+            for idx, list_value in enumerate(value, 1):
+                frame_dict[key][idx] = tk.Frame(main_frame)
+                frame_dict[key][idx].grid(row=row_number, column=idx - 1, sticky=tk.W, pady=5)
+                
+                label_dict[key][idx] = tk.Label(frame_dict[key][idx], text="{}：".format(list_value_dict[key][idx-1]), anchor=tk.W)
+                label_dict[key][idx].grid(row=0, column=0, padx=5, sticky=tk.W)
+                
+                entry_dict[key][idx] = tk.Entry(frame_dict[key][idx], width=10)
+                entry_dict[key][idx].grid(row=0, column=1, padx=5)
+                entry_dict[key][idx].insert(0, value[idx - 1])
+    
+    # submission
+    row_number += 1
+    submit_button = tk.Button(main_frame, text="Submit", command=submit)
+    submit_button.grid(row=row_number, column=0, columnspan=3, pady=20)
+    
+    # main loop
+    root.mainloop()
+
+    return parameters
+
+def PSF_GUI():
+    
+    def on_method_select(option):
+        if method_vars[option].get() == 1:
+            for i in range(2):
+                if i != option:
+                    method_vars[i].set(0)
+        else:
+            method_vars[option].set(0)
+            
+    def on_device_select(option):
+        if device_vars[option].get() == 1:
+            for i in range(2):
+                if i != option:
+                    device_vars[i].set(0)
+        else:
+            device_vars[option].set(0)
+    
+    # def select_file_cal():
+    #     file_path = filedialog.askopenfilename()
+    #     if file_path:
+    #         # file_entry.delete(0, tk.END)
+    #         # file_entry.insert(0, file_path)
+    #         entry_dict['spline_psf']['calibration_file'].delete(0, tk.END)
+    #         entry_dict['spline_psf']['calibration_file'].insert(0, file_path)
+            
+    # def select_file_zff():
+    #     file_path = filedialog.askopenfilename()
+    #     if file_path:
+    #         # file_entry.delete(0, tk.END)
+    #         # file_entry.insert(0, file_path)
+    #         entry_dict['vector_psf']['zernikefit_file'].delete(0, tk.END)
+    #         entry_dict['spline_psf']['zernikefit_file'].insert(0, file_path)
+            
+    # def select_file_zfm():
+    #     file_path = filedialog.askopenfilename()
+    #     if file_path:
+    #         # file_entry.delete(0, tk.END)
+    #         # file_entry.insert(0, file_path)
+    #         entry_dict['vector_psf']['calibration_map'].delete(0, tk.END)
+    #         entry_dict['vector_psf']['calibration_map'].insert(0, file_path)
+            
+    class Select_File():
+        def __init__(self, name1, name2):
+            self.name1 = name1
+            self.name2 = name2
+        def __call__(self):
+            file_path = filedialog.askopenfilename()
+            if file_path:
+                entry_dict[self.name1][self.name2].delete(0, tk.END)
+                entry_dict[self.name1][self.name2].insert(0, file_path)
+    
+    def get_parameters():
+        
+        value_dict = {}
+        
+        type_dict = {
+            'z_scale': float,
+            'simulate_method': str,
+            # 'spline_psf': {
+                'calibration_file': None,
+                'psf_extent': float,
+                'device_simulation': str,
+                # },
+            # 'vector_psf': {
+            # 'row1': {
+                'objstage0': float,
+                'zemit0': float,
+                    # },
+                'zernikefit_file': str,
+                # 'pixelSize': {           #[110, 110], # pixelX, pixelY
+                'pixelSizeX': int,
+                'pixelSizeY': int,
+                # },
+                # 'row4': {
+                'psfSizeX': int,
+                'NA': float,
+                'wavelength': float,
+                # },
+                # 'row5': {
+                'refmed': float,
+                'refcov': float,
+                'refimm': float,
+                    # },
+                'zernikefit_map': str,
+                # 'row7':{
+                'psfrescale': float,
+                'Npupil': int
+                    # }
+                
+                # }
+            }
+                     
+    
+        for key, value in entry_dict.items():
+            if key == 'psf_extent':
+                # print(value)
+                assert len(value) == 4
+                value_dict[key] = [
+                    [
+                        type_dict[key](value[j + i * 2 + 1].get().strip()) if value[j + i * 2 + 1].get().strip() else None for j in range(2)
+                        ] for i in range(2)
+                    ]
+                value_dict[key].append (None)
+            elif key in ['simulate_method', 'device_simulation']:
+            # # print(key, 'here')
+            # if key == 'simulate_method':
+                
+                value_dict[key] = None
+                for i in range(2):
+                    if method_vars[i].get() == 1:
+                        if key == 'simulate_method':
+                            value_dict[key] = 'spline' if (i + 1 == 1) else 'vector'
+                        else:
+                            value_dict[key] = 'cuda' if (i + 1 == 1) else 'cpu'
+                        break
+                    
+            else:
+                value_dict[key] = type_dict[key](value.get().strip()) if value.get().strip() else None
+                    
+            # elif not isinstance(value, dict):
+            #     value_dict[key] = type_dict[key](value.get().strip()) if value.get().strip() else None
+            # else:
+            #     value_dict[key] = [type_dict[key](v.get().strip()) if v.get().strip() else None for k, v in value.items()]
+            
+        result_dict = {}
+        for k in ['z_scale', 'simulate_method']:
+            result_dict[k] = value_dict[k]
+        result_dict['spline_psf'] = {}
+        for k in ['calibration_file', 'psf_extent', 'device_simulation']:
+            result_dict['spline_psf'][k] = value_dict[k]
+        result_dict['vector_psf'] = {}
+        for k in value_dict:
+            if k not in ['z_scale', 'simulate_method', 'calibration_file', 'psf_extent', 'device_simulation']:
+                result_dict['vector_psf'][k] = value_dict[k]
+ 
+        return result_dict
+    
+    def show_result_window(result):
+        result_window = tk.Toplevel(root)
+        result_window.title("Setting confriming...")
+    
+        show_str = "Settings:\n" + show_confirming_string(parameters)
+        # show_str = "Settings:\n"
+        # for i, (key, value) in enumerate(parameters.items(), 1):
+        #     show_str += f"{key} : {value}"#f"自定义显示内容:\n{result}"
+        #     if i != len(parameters):
+        #         show_str += "\n"
+        result_label = tk.Label(result_window, text=show_str, justify=tk.LEFT, anchor=tk.W)
+        result_label.pack(padx=20, pady=20)
+    
+        close_button = tk.Button(result_window, text="Confirm", command=root.destroy)
+        close_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+        retry_button = tk.Button(result_window, text="Redo", command=result_window.destroy)
+        retry_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+    
+    
+    def submit():
+        global parameters
+        parameters = get_parameters()
+        show_result_window(parameters)
+
+    # Main Window
+    root = tk.Tk()
+    root.title("PSF Parameter Setting")
+    root.geometry("800x800")
+    
+    # Fram setting
+    main_frame = tk.Frame(root)
+    main_frame.pack(padx=20, pady=20)
+    
+    item_dict = {
+        'z_scale': 700,
+        'simulate_method': 'vector',
+        'spline_psf': {
+            'calibration_file': None,
+            'psf_extent': [[-0.5, 63.5], [-0.5, 63.5], None],
+            'device_simulation': 'cuda',
+            },
+        'vector_psf': {
+            'row1': {
+                'objstage0': -500,
+                'zemit0': None,
+                },
+            'zernikefit_file': None,
+            'pixelSize': {           #[110, 110], # pixelX, pixelY
+                'pixelSizeX': 110,
+                'pixelSizeY': 110,
+            },
+            'row4': {
+                'psfSizeX': 51,
+                'NA': 1.5,
+                'wavelength': 680,
+            },
+            'row5': {
+                'refmed': 1.406,
+                'refcov': 1.524,
+                'refimm': 1.518,
+                },
+            'zernikefit_map': None,
+            'row7':{
+                'psfrescale': 0.5,
+                'Npupil': 64
+                }
+            
+        }
+        }
+    
+
+    frame_dict = {}
+    label_dict = {}
+    entry_dict = {}
+    
+    row_number = -1
+    for key, value in item_dict.items():
+        # if isinstance(value, int) or isinstance(value, float) or (value is None) or (key == 'project_name'):
+            
+        
+        
+        if key == 'simulate_method':
+            
+            row_number += 1
+            
+            # perline noise selection
+            frame_dict[key] = tk.Frame(main_frame)
+            frame_dict[key].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+            
+            label_dict[key] = tk.Label(frame_dict[key], text="{}：".format(key), anchor=tk.W, width=15)
+            label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+            
+            method_vars = [tk.IntVar(value=0) for _ in range(2)]
+            method_vars[0].set(1)
+            method_button1 = tk.Checkbutton(frame_dict[key], text="spline", variable=method_vars[0], command=lambda: on_method_select(0))
+            method_button1.grid(row=0, column=1, padx=5, sticky=tk.W)
+            
+            method_button2 = tk.Checkbutton(frame_dict[key], text="vector", variable=method_vars[1], command=lambda: on_method_select(1))
+            method_button2.grid(row=0, column=2, padx=5, sticky=tk.W)
+            
+            entry_dict[key] = None
+                          
+            
+        elif key == 'z_scale':
+            row_number += 1
+            frame_dict[key] = tk.Frame(main_frame)
+            frame_dict[key].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+            
+            label_dict[key] = tk.Label(frame_dict[key], text="{} :".format(key))
+            label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+            
+            entry_dict[key] = tk.Entry(frame_dict[key], width = 30)
+            entry_dict[key].grid(row=0, column=1, padx=5)
+            entry_dict[key].insert(0, value)
+
+                
+        else:
+            # row_number += 1
+            file_button = {}
+            for kk, vv in value.items():
+                if kk in ['calibration_file', 'zernikefit_file', 'zernikefit_map']:
+                    row_number += 1
+                    
+                    frame_dict[kk] = tk.Frame(main_frame)
+                    frame_dict[kk].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+                    
+                    label_dict[kk] = tk.Label(frame_dict[kk], text="{} :".format(kk))
+                    label_dict[kk].grid(row=0, column=0, padx=5, sticky=tk.W)
+                    
+                    entry_dict[kk] = tk.Entry(frame_dict[kk], width = 30)
+                    entry_dict[kk].grid(row=0, column=1, padx=5)
+                    if vv is not None:
+                        entry_dict[kk].insert(0, vv)
+                        
+                    file_button[kk] = tk.Button(frame_dict[kk], text="Open", command=Select_File(key, kk))
+                    file_button[kk].grid(row=0, column=2, padx=5)
+                    # elif key == 'spline_psf':
+                    #     file_button = tk.Button(frame_dict[key], text="Open", command=select_file)
+                    #     file_button.grid(row=0, column=2, padx=5)
+                    # elif key =='result_path':
+                    #     folder_button = tk.Button(frame_dict[key], text="Open", command=select_folder)
+                    #     folder_button.grid(row=0, column=2, padx=5)
+                    
+                elif kk == 'device_simulation':
+
+                    row_number += 1
+                    
+                    # perline noise selection
+                    frame_dict[kk] = tk.Frame(main_frame)
+                    frame_dict[kk].grid(row=row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+                    
+                    label_dict[kk] = tk.Label(frame_dict[kk], text="{}：".format(key), anchor=tk.W, width=15)
+                    label_dict[kk].grid(row=0, column=0, padx=5, sticky=tk.W)
+                    
+                    device_vars = [tk.IntVar(value=0) for _ in range(2)]
+                    device_vars[0].set(1)
+                    device_button1 = tk.Checkbutton(frame_dict[kk], text="cuda", variable=device_vars[0], command=lambda: on_device_select(0))
+                    device_button1.grid(row=0, column=1, padx=5, sticky=tk.W)
+                    
+                    device_button2 = tk.Checkbutton(frame_dict[kk], text="cpu", variable=device_vars[1], command=lambda: on_device_select(1))
+                    device_button2.grid(row=0, column=2, padx=5, sticky=tk.W)
+                    
+                    entry_dict[kk] = None
+                    
+                elif kk == 'psf_extent':
+                    
+                    row_number += 1
+                    
+                    frame_dict[kk] = {}
+                    frame_dict[kk][0] = tk.Frame(main_frame)
+                    frame_dict[kk][0].grid(row=row_number, column=0, sticky=tk.W, pady=5)
+                    
+                    label_dict[kk] = {}
+                    label_dict[kk][0] = tk.Label(frame_dict[kk][0], text="{} ：".format(kk), anchor=tk.W) 
+                    label_dict[kk][0].grid(row=0, column=0, padx=3, sticky=tk.W)
+                    
+                    entry_dict[kk] = {}
+                    
+                    row_number += 1
+                    
+                    list_values = ['h_min', 'h_max', 'w_min', 'w_max']
+                    for idx, list_value in enumerate(list_values, 1):
+                        frame_dict[kk][idx] = tk.Frame(main_frame)
+                        frame_dict[kk][idx].grid(row=row_number, column=idx - 1, sticky=tk.W, pady=5)
+                        
+                        label_dict[kk][idx] = tk.Label(frame_dict[kk][idx], text="{} ：".format(list_value), anchor=tk.W)
+                        label_dict[kk][idx].grid(row=0, column=0, padx=5, sticky=tk.W)
+                        
+                        entry_dict[kk][idx] = tk.Entry(frame_dict[kk][idx], width=6)
+                        entry_dict[kk][idx].grid(row=0, column=1, padx=0)
+                        entry_dict[kk][idx].insert(0, vv[(idx - 1) // 2][(idx - 1) % 2])
+                
+                else:
+                    # print(kk)
+                    assert isinstance(vv, dict)
+                    row_number += 1
+                    
+                    for idx, (kkk, vvv) in enumerate(vv.items()):
+                        
+                        
+                        
+                        frame_dict[kkk] = tk.Frame(main_frame)
+                        frame_dict[kkk].grid(row=row_number, column=idx, sticky=tk.W, pady=5)
+                        
+                        label_dict[kkk] = tk.Label(frame_dict[kkk], text="{} :".format(kkk))
+                        label_dict[kkk].grid(row=0, column=0, padx=5, sticky=tk.W)
+                        
+                        entry_dict[kkk] = tk.Entry(frame_dict[kkk], width = 15 if len(vv) <3 else 10)
+                        entry_dict[kkk].grid(row=0, column=1, padx=5)
+                        if vvv is not None:
+                            entry_dict[kkk].insert(0, vvv)
+                    
+    # submission
+    row_number += 1
+    submit_button = tk.Button(main_frame, text="Submit", command=submit)
+    submit_button.grid(row=row_number, column=0, columnspan=3, pady=20)
+    
+    # main loop
+    root.mainloop()
+    
+    return parameters
+
+def Infer_GUI():
+
+    def on_gpu_select(option):
+        if gpu_vars[option].get() == 1:
+            for i in range(2):
+                if i != option:
+                    gpu_vars[i].set(0)
+        else:
+            gpu_vars[option].set(0)
+             
+    class Select_File():
+        def __init__(self, name1):
+            self.name1 = name1
+        def __call__(self):
+            file_path = filedialog.askopenfilename()
+            if file_path:
+                entry_dict[self.name1].delete(0, tk.END)
+                entry_dict[self.name1].insert(0, file_path)
+
+    def get_parameters():
+        
+        value_dict = {}
+        
+        for key, value in entry_dict.items():
+            # print(key, 'here')
+            if key == 'multi_gpu':
+                value_dict[key] = None
+                for i in range(2):
+                    if gpu_vars[i].get() == 1:
+                        value_dict[key] = (i + 1 == 1)
+                        break
+            else:
+                value_dict[key] = (str(value.get().strip()) if 'path' in key else int(value.get().strip())) if value.get().strip() else None
+        
+        result_dict = {'Loc_Model':{}, 'Multi_Process':{}}
+        for key, value in value_dict.items():
+            result_dict['Loc_Model' if key == 'model_path' else 'Multi_Process'][key] = value
+            
+        return result_dict
+                
+    def show_result_window(result):
+        result_window = tk.Toplevel(root)
+        result_window.title("Setting Confirming...")
+    
+        show_str = "Settings:\n" + show_confirming_string(parameters)    
+        # show_str = "Settings:\n"
+        # for i, (key, value) in enumerate(parameters.items(), 1):
+        #     show_str += f"{key} : {value}"#f"自定义显示内容:\n{result}"
+        #     if i != len(parameters):
+        #         show_str += "\n"
+        result_label = tk.Label(result_window, text=show_str, justify=tk.LEFT, anchor=tk.W)
+        result_label.pack(padx=20, pady=20)
+    
+        close_button = tk.Button(result_window, text="Confirm", command=root.destroy)
+        close_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+        retry_button = tk.Button(result_window, text="Redo", command=result_window.destroy)
+        retry_button.pack(side=tk.RIGHT, padx=10, pady=10)
+    
+    def submit():
+        global parameters
+        parameters = get_parameters()
+        show_result_window(parameters)
+    
+    # Main Window
+    root = tk.Tk()
+    root.title("Inference Parameter Setting")
+    root.geometry("600x450")
+    
+    # Frame setting
+    main_frame = tk.Frame(root)
+    main_frame.pack(padx=20, pady=20)
+    
+    item_dict = {
+        'Loc_Model': {
+            'model_path': None         
+            },
+        'Multi_Process':{
+            'image_path': None, 
+            'save_path': None, 
+            'time_block_gb': 1, 
+            'batch_size': 30,
+            'over_cut': 8,
+            'multi_gpu': True,
+            'num_producers': 1
+            }
+        }
+    
+    frame_dict = {}
+    label_dict = {}
+    entry_dict = {}
+    
+    row_number = -1     
+    
+    for Key, Value in item_dict.items():
+        
+       row_number += 1
+       
+       frame_dict[Key] = tk.Frame(main_frame)
+       frame_dict[Key].grid(row = row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+       
+       label_dict[Key] = tk.Label(frame_dict[Key], text="{} :".format(Key), anchor=tk.W, width=15)
+       label_dict[Key].grid(row=0, column=0, padx=5, sticky=tk.W)
+       
+       for key, value in Value.items():
+           
+           row_number += 1
+            
+           frame_dict[key] = tk.Frame(main_frame)
+           frame_dict[key].grid(row = row_number, column=0, columnspan=3, sticky=tk.W, pady=5)
+           
+           label_dict[key] = tk.Label(frame_dict[key], text="{} :".format(key), anchor=tk.W, width=15)
+           label_dict[key].grid(row=0, column=0, padx=5, sticky=tk.W)
+           
+           if key =='multi_gpu':
+               gpu_vars = [tk.IntVar(value=0) for _ in range(2)]
+               gpu_vars[0].set(1)
+               gpu_button1 = tk.Checkbutton(frame_dict[key], text="True", variable=gpu_vars[0], command=lambda: on_gpu_select(0))
+               gpu_button1.grid(row=0, column=1, padx=5, sticky=tk.W)
+               
+               gpu_button2 = tk.Checkbutton(frame_dict[key], text="False", variable=gpu_vars[1], command=lambda: on_gpu_select(1))
+               gpu_button2.grid(row=0, column=2, padx=5, sticky=tk.W)
+               
+               entry_dict[key] = None
+           else:
+               entry_dict[key] = tk.Entry(frame_dict[key], width=30 if 'path' in key else 15)
+               entry_dict[key].grid(row=0, column=1, padx=5)
+               if value is not None:
+                        entry_dict[key].insert(0, "{}".format(value))
+                        
+               if 'path' in key:
+                   file_button = tk.Button(frame_dict[key], text="Open", command=Select_File(key))
+                   file_button.grid(row=0, column=2, padx=5)
+    
+    # Submit
+    submit_button = tk.Button(main_frame, text="Submit", command=submit)
+    submit_button.grid(row=row_number + 1, column=0, columnspan=3, pady=20)
+    
+    # Run main loop
+    root.mainloop()
+    
+    return parameters   
\ No newline at end of file