{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.12.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceType":"datasetVersion","sourceId":15301591,"datasetId":9787599,"databundleVersionId":16205535},{"sourceType":"datasetVersion","sourceId":15301111,"datasetId":9787312,"databundleVersionId":16204976}],"dockerImageVersionId":31329,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# ============================================================\n# CELL 1 — Full Setup: Packages + Models\n# ============================================================\n\n# Step 1: Install packages\n!pip install -q insightface==0.7.3 onnxruntime-gpu opencv-python-headless gfpgan tqdm huggingface_hub\n!apt-get install -y ffmpeg > /dev/null 2>&1\n\n# Step 2: Patch torchvision compatibility\nimport types, sys\nfrom torchvision.transforms import functional as TF\nmodule = types.ModuleType('torchvision.transforms.functional_tensor')\nmodule.rgb_to_grayscale = TF.rgb_to_grayscale\nsys.modules['torchvision.transforms.functional_tensor'] = module\n\n# Step 3: Download models\nimport os, numpy as np\nfrom huggingface_hub import hf_hub_download\n\nos.makedirs('/kaggle/working/models', exist_ok=True)\nos.makedirs('/kaggle/working/inputs', exist_ok=True)\nos.makedirs('/kaggle/working/outputs', exist_ok=True)\nos.makedirs('/kaggle/working/temp', exist_ok=True)\n\n# inswapper\nif not os.path.exists('/kaggle/working/models/inswapper_128.onnx'):\n print(\"Downloading inswapper_128.onnx...\")\n hf_hub_download(repo_id=\"ezioruan/inswapper_128.onnx\",\n filename=\"inswapper_128.onnx\",\n local_dir=\"/kaggle/working/models\")\n print(\"✅ inswapper ready!\")\nelse:\n print(\"✅ inswapper already exists\")\n\n# GFPGAN\nif not os.path.exists('/kaggle/working/models/GFPGANv1.4.pth'):\n print(\"Downloading GFPGANv1.4.pth...\")\n os.system(\"wget -q --show-progress -O /kaggle/working/models/GFPGANv1.4.pth https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/GFPGANv1.4.pth\")\n print(\"✅ GFPGAN ready!\")\nelse:\n print(\"✅ GFPGAN already exists\")\n\n# Step 4: Load models\nimport cv2, insightface\nfrom insightface.app import FaceAnalysis\nfrom gfpgan import GFPGANer\nimport onnxruntime as ort\n\nprint(f\"\\nGPU available: {'CUDAExecutionProvider' in ort.get_available_providers()}\")\n\nface_app = FaceAnalysis(name='buffalo_l',\n providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])\nface_app.prepare(ctx_id=0, det_size=(640, 640))\n\nswapper = insightface.model_zoo.get_model(\n '/kaggle/working/models/inswapper_128.onnx',\n providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])\n\nenhancer = GFPGANer(\n model_path='/kaggle/working/models/GFPGANv1.4.pth',\n upscale=1, arch='clean', channel_multiplier=2, bg_upsampler=None)\n\nprint(\"\\n🎉 All models loaded and ready!\")","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2026-03-21T12:01:58.665351Z","iopub.execute_input":"2026-03-21T12:01:58.666779Z","iopub.status.idle":"2026-03-21T12:02:11.687990Z","shell.execute_reply.started":"2026-03-21T12:01:58.666741Z","shell.execute_reply":"2026-03-21T12:02:11.686989Z"}},"outputs":[{"name":"stdout","text":"✅ inswapper already exists\n✅ GFPGAN already exists\n\nGPU available: True\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\nfind model: /root/.insightface/models/buffalo_l/1k3d68.onnx landmark_3d_68 ['None', 3, 192, 192] 0.0 1.0\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\nfind model: /root/.insightface/models/buffalo_l/2d106det.onnx landmark_2d_106 ['None', 3, 192, 192] 0.0 1.0\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\nfind model: /root/.insightface/models/buffalo_l/det_10g.onnx detection [1, 3, '?', '?'] 127.5 128.0\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\nfind model: /root/.insightface/models/buffalo_l/genderage.onnx genderage ['None', 3, 96, 96] 0.0 1.0\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\nfind model: /root/.insightface/models/buffalo_l/w600k_r50.onnx recognition ['None', 3, 112, 112] 127.5 127.5\nset det-size: (640, 640)\nApplied providers: ['CUDAExecutionProvider', 'CPUExecutionProvider'], with options: {'CPUExecutionProvider': {}, 'CUDAExecutionProvider': {'sdpa_kernel': '0', 'use_tf32': '1', 'fuse_conv_bias': '0', 'prefer_nhwc': '0', 'tunable_op_max_tuning_duration_ms': '0', 'enable_skip_layer_norm_strict_mode': '0', 'tunable_op_tuning_enable': '0', 'tunable_op_enable': '0', 'use_ep_level_unified_stream': '0', 'device_id': '0', 'has_user_compute_stream': '0', 'gpu_external_empty_cache': '0', 'cudnn_conv_algo_search': 'EXHAUSTIVE', 'cudnn_conv1d_pad_to_nc1d': '0', 'gpu_mem_limit': '18446744073709551615', 'gpu_external_alloc': '0', 'gpu_external_free': '0', 'arena_extend_strategy': 'kNextPowerOfTwo', 'do_copy_in_default_stream': '1', 'enable_cuda_graph': '0', 'user_compute_stream': '0', 'cudnn_conv_use_max_workspace': '1'}}\ninswapper-shape: [1, 3, 128, 128]\n","output_type":"stream"},{"name":"stderr","text":"/usr/local/lib/python3.12/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n warnings.warn(\n/usr/local/lib/python3.12/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n warnings.warn(msg)\n","output_type":"stream"},{"name":"stdout","text":"\n🎉 All models loaded and ready!\n","output_type":"stream"}],"execution_count":21},{"cell_type":"code","source":"# ============================================================\n# CELL 2 — Inputs: Source Face + YouTube URL (Kaggle)\n# ============================================================\nimport cv2, shutil, os, yt_dlp, numpy as np\nfrom IPython.display import Image, display\n\n!pip install -q yt-dlp\n\n# ---- UPDATE THESE ----\nSOURCE_FACE_PATH = \"/kaggle/input/datasets/aasthamalik1810/aastha-pic/portfolio_aastha_pic.jpeg\"\nVIDEO_URL = \"https://www.youtube.com/watch?v=HEqXeXI_KAE\"\nTRIM_SECONDS = 15\n# ----------------------\n\n# --- Source face with stronger embedding ---\nshutil.copy(SOURCE_FACE_PATH, '/kaggle/working/inputs/source_face.jpg')\n\nsource_img = cv2.imread('/kaggle/working/inputs/source_face.jpg')\nsource_faces = face_app.get(source_img)\n\n# If not detected, try resizing\nif len(source_faces) == 0:\n print(\"⚠️ Trying resized image...\")\n source_img_resized = cv2.resize(source_img, (640, 640))\n source_faces = face_app.get(source_img_resized)\n\nif len(source_faces) == 0:\n raise ValueError(\"❌ No face detected! Use a clear front-facing photo.\")\n\n# Pick largest face\nsource_face = sorted(source_faces,\n key=lambda f: (f.bbox[2]-f.bbox[0]) * (f.bbox[3]-f.bbox[1]),\n reverse=True)[0]\n\n# Normalize embedding for stronger identity signal\nsource_face.embedding = source_face.embedding / np.linalg.norm(source_face.embedding)\nprint(f\"✅ Source face detected!\")\nprint(f\" Embedding norm: {np.linalg.norm(source_face.embedding):.3f} (should be 1.0)\")\ndisplay(Image('/kaggle/working/inputs/source_face.jpg', width=200))\n\n# --- Force delete old cached video ---\nfor f in ['/kaggle/working/inputs/target_raw.mp4',\n '/kaggle/working/inputs/target_video.mp4',\n '/kaggle/working/inputs/target_trimmed.mp4']:\n if os.path.exists(f):\n os.remove(f)\n\n# --- Download in ANY format then convert to H264 ---\nprint(\"\\n🎬 Downloading video from YouTube...\")\nydl_opts = {\n 'outtmpl': '/kaggle/working/inputs/target_raw.mp4',\n 'format': 'best[height<=480]/best',\n 'http_headers': {\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',\n },\n}\nwith yt_dlp.YoutubeDL(ydl_opts) as ydl:\n ydl.download([VIDEO_URL])\nprint(\"✅ Downloaded!\")\n\n# Convert to H264\nprint(\"🔄 Converting to H264...\")\nos.system(\"ffmpeg -y -i /kaggle/working/inputs/target_raw.mp4 -vcodec libx264 -acodec aac -preset fast /kaggle/working/inputs/target_video.mp4 -loglevel error\")\n\n# Verify\ncap_check = cv2.VideoCapture('/kaggle/working/inputs/target_video.mp4')\nret, test_frame = cap_check.read()\ncap_check.release()\nif not ret:\n raise RuntimeError(\"❌ OpenCV can't read video even after H264 conversion!\")\nprint(\"✅ Codec OK!\")\n\n# Trim\nif TRIM_SECONDS:\n os.system(f\"ffmpeg -y -i /kaggle/working/inputs/target_video.mp4 -t {TRIM_SECONDS} -c:v libx264 -c:a aac /kaggle/working/inputs/target_trimmed.mp4 -loglevel error\")\n INPUT_VIDEO = '/kaggle/working/inputs/target_trimmed.mp4'\nelse:\n INPUT_VIDEO = '/kaggle/working/inputs/target_video.mp4'\n\ncap = cv2.VideoCapture(INPUT_VIDEO)\nfps = cap.get(cv2.CAP_PROP_FPS)\ntotal = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\nw = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\nh = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\ncap.release()\n\nprint(f\"✅ Video ready: {w}x{h} | {fps}fps | {total} frames | {total/fps:.1f}s\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-21T12:04:17.976386Z","iopub.execute_input":"2026-03-21T12:04:17.976797Z","iopub.status.idle":"2026-03-21T12:07:01.955379Z","shell.execute_reply.started":"2026-03-21T12:04:17.976761Z","shell.execute_reply":"2026-03-21T12:07:01.954329Z"}},"outputs":[{"name":"stdout","text":"✅ Source face detected!\n Embedding norm: 1.000 (should be 1.0)\n","output_type":"stream"},{"output_type":"display_data","data":{"image/jpeg":"/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAYGBgYHBgcICAcKCwoLCg8ODAwODxYQERAREBYiFRkVFRkVIh4kHhweJB42KiYmKjY+NDI0PkxERExfWl98fKcBBgYGBgcGBwgIBwoLCgsKDw4MDA4PFhAREBEQFiIVGRUVGRUiHiQeHB4kHjYqJiYqNj40MjQ+TERETF9aX3x8p//CABEIAl8CXwMBIgACEQEDEQH/xAAxAAACAwEBAAAAAAAAAAAAAAAAAQIDBAUGAQADAQEBAAAAAAAAAAAAAAAAAQIDBAX/2gAMAwEAAhADEAAAAuOM7uZbMmqHro38nOtvK7vNZjGbZobCJJCSkBFSQ02D6N1NXNrhzjyuDtY63OKEnEY4gSTmnBSTUYzQQJIEME9eO1V3iGvzenz9PT5noYgjTNgAJtqIwIkkCGAhjSGAmwWjr8Xq5TsLhb08zs0RPmobcu8QJA9aDv5ndRbNdnj9fl5Vrt5fXDiw249pTQ5AAAAEANEZqzMnybgiW5QkiZFAoyiNAwnqo3Z6Y69VDVcJqogpRYgAGgOj1/N9zi6J8L0XIHiEd3MwAAQMQIAAAAAYxDTEBPdz75j0VmLZjs0DfJ5fe4lY1AtK1Ad3OWV2J9rmdPm43l6HNs1nr8jsY8nzxx3hiAABCAaqcOXZpGVsUgc4SCRBoScRpphPdh1Z6X4elz0VAtM4KUWJNAAAdPmSi/T446uDo88tGf0eYAqWgAAAAEIAYhjEwABE4Nrp9fz3W51tAe1HD7fGeGRNa3pA7sC2vRL63M6fIyrO0to6G/idfK+ZT1uXcwTVyAAQlRnaE+TZOQBIYSakEI2xRUpxGhsHty6Ivbh1ZorNGxa5wjZAUIzixDQAAS73n9uN6uX3+LOlQHRgAMAQMQIAAAYNAMQDBCt3c7QZdq7lWc7s5+nHvnnQPo1F8e3GvoV9DNri7+cyIGienLJHd51uvGuHG+naEAyFNkOXYYsqZGQMSCbiwnFSTg5STjK26NM9tsZq5V6JeKnoRawrYUsEdtTWVaKqiokqlTgB6TBPTwdXALau7mATTQMABAAAAAADQDEwLK21quwyrHTlIKkBOvqlzJdOPRz4aGSrFogAEwCzr8W+X0eT28cPmqUdZqilx7MTlsSBzJAmSTUrtcaZL9087zPS5rIaweY0SSpdqCiGqAZYaawx07qLWGGijXGsaqb+757u8m2Pm9/j3VCmdPPAmgg5IESBQcgIkhkSQJDATGAAAmAgA1CO7IQAAIABgADQLZ0+Frzcuf3+ZL5SZhoCaHOMwkFipXT1Z6G1aIqJYkVKyKqDaBMAIyQJOIRhOMuqu+pmLLuzaxljbXpiu1xduenZw6zh34C05fS5WgqWgBiAZFiYkyREEwAbQDEA0IGgDUB25gAItc60kovMAYAIHEFsv5hm8wLn0GmiU4Wp2ao6s9TTXrmp2RkhpxCMZxTgpxGgECaBRkgjGUU4VXUoopvhZlzb82mWecJ6Z9bdwevw9VfH9DzaXOA7eUTQAAAAgAAAGAA0wAQAAAAahruzJRkq16MvSw7OPTux6YxAvBDQCaQJpOhSjy0NCJ6KNU3s0Q15au+M02xiIyQRUknGM0EFJAkxOKkggpxRCm+kKq7aKFmtrpY5wntgbsLm/Q10bfO6eFn7XI7sIJrbEAAAAAEAANMAAGgBAASjINSZ2wADt6HL059O3m9bBFYSUNuUBCAE0mSUxsjg4hKSe7H1I123qWWkmpA2m0DgIQk2kxxjKKE0wUSkLK6edU78eSypVexhinbnZVKMtIaALuvwtfPv2efslx6+ej0ed6PMAXmAgYgGgExMBoBoAAAJwmGkDtkABW1tX1JYujh0cinfi0zgmrxAEIBCqtpxZONub09XF0sd7JIlzhXhqd8OfVUdOvnxH05clJ9q3jdCa1xEhCgmsVuRkapK5duYFslgaenNJlYZBrgAMAA6PR891OPp18vr141582ZPQ5okioi2AhgkCBtAMBgAglCQahrtkAAACzpcrXl07OX1sc1zicNedDSla8vex0p4PsPP89862memXY6PO6OG8oyoHh2vRU1xhnlyy56anXfhmq6V+LbFWk7HOfPuwy8Ge2iyS126Zc7NpbVuHo5pqu6N03iUo7ZADQhA5QEdbb5/qcXVdy+3nh8NX0d/KAOQABNCGmA0ACAcoSDamu1IaEAAWVudes8uvHbl5+pzrmsCueXofO+h5OjZg6Eca8c+pi1z3dPl9TO5RmS45NPPHXk1dHXLkY9tTndY640W/D0ouyyuQni2ZpfIhordSsQ5UWhxp1WIy2WwT5td1HTztIqQAAACysl9jZ5/rcPScnv5A4xOHdygJoAEAA0AAAEoyDaB2pJgIAAEnf0+R0Mum7n9GqDkxup1xfb4d2R6CzNbx9GF6rKnmdLndFEmSl116YtZ5zgyOTRAeQ23TVGqTJUiQKq6pPnZd2JVdfl1JScmKMLYDop00Bz8nRxdGNYGuYAAAAgQXUifc0cPq8HTTyvQ8/RcxNdfKANAAAAAgG4zDaB2pJgIABNA9WSyN+tEpxuGDscylnGPDR6Hy3e5dbXbmz0w9Lk9JrTKFktjaVcbkOgsScJtsQwQ4Nkq5xl48HS5qpacdrW+dFonGUUQouzjz1aqrnnw059sEBaQCAEJiAenKTXfs5HV4Ornc/0PJ6M8iH08wAAmAhgKSYdGGmjr1gBWKAATQKcXN75592PRnli2hzq9uRZw05Fln6uXL6uW3IunlZ1rKb4pyTFIBkIzrGQjVLslRqag7IhKNiDNzujz4qumSp678OpTdFRCGa+4eaGxI4A6ejnaC5AAQwENhEkAt+EivQV5d/B08Sjs8jswg0bYtAAAA0w9Pz+ibdXHhrz65QTVYiYCTE7epyell041dkT3c66rPPOJzkep8rsT9HxrsU32tGDZnpdOqaJJQArKlUaFpCc7HU57JRBqFaDm3ZVSthIaIVM22c7oJR6vE7YZqduGHn5XouRefOejNvjIk6dZNAhAmIAAFLqcmzLXu4dFnHvwFqy9/KAVAIBtMOxv5VnT09PDffD49fTx6TnJwvBDSUt2DbHRZzunzpcIqOeUJKcTBTSVTAOz1fNejz2ulXKLlArQs0ZDe3Poc2EU06pRHlr1VlUVTzJyjCIA7wjtrJWPr8PvWtPO6WTMq522pPggdfMrqpKtLqZ1yzdjmmVIFc4AIEBq63A6XL0XcjvckMoLq5gACUWHSBdpZoxSnfrx5+vO6c3ViHJhvouc+7Pumnzehz0Z03GEJRlmmIFXFoD0Hn9U36YjLHZ1WRT510N4YJdBNZrJSp1R1IMy0RHkhsqTyZrYJucVK0ZTLU1+o8n7Cs549mPK8sq7Jvh07sPVgEhqU5XG/b5OzHO/Oh02c3LW6h4UEo1JbVcq7PP6HN4+jEmu7kAAGmHRQdyEAOdYr06edONuq+XbF7lkqVFE46ZZyUs4qklilFxIigBiEdzqeS9DntrBZ6U6IyC5xkSlJMjGcG6651pwptinmLop1VToahlss1z2+hjOFVh182LjKWdPm52dGAMbnvwdRdKIJ9aJg7bKtGeGPkemwvj49xVefX5cVFIDXJAANMOgB3yADQAACBpq5IFYNChfJ49GFWVY4xhOszQAgEBbWk/UaPLehy20uJFWTqmEwbUa7Yoor0RHSrq06qdFEvJk0R1WP0lusiUCiSnJJzZyehw9IjOFmuStq0zc9sx9hnrm9yUbG4wlYTDRSxbOdo2Th5mHoOPXLmAeKAAaYdFB3wJoYAADTbBaAA01pV2q2PP6HJrlXn5sq7ayIAxJSiEk0B3OJ1Z26zTxuVlUgulVMUkJEYOoc4RmnRl6tgc/o2OpUHSksM8aqyayBkxNdGBKNorbjVPTJTT6s865VtbWpCLoypKuU0VTjMV9dcFFPO72ZcnILK65hoF0QO/MTiNgANSKkmloDSDo59mXdCjViy6ObCyuPKlFhMFKIEZREThINdq3rth1fMdzKdUbFMKcIjsjbaGeehtVuaEgQnFQQZ3nmqKVYWcvoc24zAbc8tuTqztvosU7KvJLTqsrhMosjNtSjc089tQTjYDjPbfHO+duJw5HN9RzKrhGjO+TpJr0cCMoKpCYOQywBUgtVbnI5/Vry6YS+VTdTHkkoSUqMohEBpyheFfo/ObjaWbtcGd/Tasm3LJWOQ02CQk5cVFJxVaJZ4ZFc60yiebG508xR1yBzqTRmktuhPFYuuajJ6TmOrjatTSiZSb9MNKjnync7otU1Jt5klnr5+upLHyu5iEkHpeURlFUOMiptBQhDOlk349wlZn2Qzaskzz6L6c/JUkCcLKwiA0NILIgn2TleiOzoWwtxyY4gKISQdaTjXSndkpzl2QpzU9eTMtMWhVmABLTVJba6ia64gOy2y2nVZYnRIqbWinoLOt9GKwx1bcZomJ1NaKIyyR1562VFzRzxR9DxpJAycbRxUwcXOa0tvou5/c0bKbs+LJk6SH5mnRnjgYMUqraxVgNCaByjMZ6LzvqY16ElLNkJwRWKtDojiTnkrnVqrVjqMsLa9cUmiRMBABZdRctrehi3roxLVVWsrI2XqEW2Z2SrtFFrOtZzZZ8OjLuA4+y+D1p0YIOr7822YzZNOIrISPT8VADckyiRJXG+rfl2ZOlfRh3Tttc8/Ijv5p0YcnU5c8SthasI1W1CgmMQ0BZXalD2HkPXTpsnCedkJQRVm0ZZeTJoymhqLLivnb8DjPWGucQCWmgEwC6pla9GKc9Wm2M9exiHUh50Va4aFEZW2Cnq5MllspsodbKKrgdO2qcVbjpHAhJ65EHoeINTKGmrmIG+ly+lj3dbDddg4V7+ckczc66eZzehizypuz2nEQkia00ADA1Z7GR9H57rRt35wnmlXZWnXn00y8WLdgL0WVFRXzN2PWqo201jFpmYAAxjQ0MvouNt9lc79F7Mm5xmw9HLJbOnS6hvztZRtp1qVl6WRZYunlpevUppnOGF3zNKYdLiiyAel5jkpKmOJRXIDo19Llcvr9Dq+e9DGRCvJOVWXTk09DVytcEuUasufmTg0ZRjZWJtMbIAtHQw6Z6/UTrsjArshLqpvzy8WLoZFopKvYeW+GlU5baTmTTIQMTYxxTiBfRqN9c4XX6F+mqBnk00dAum2AKU9SWOPq8rco05rMc5Y9ytehCbnBUX1vSflev58nc0/R45OMlUk4ir6PN9BHRQtOvn7+D3fP9A038rdzxKEo10oQBi3ZY5MYKPNdd1YkACFMd2ijQur0ujHrzwcJxRVTfTFZsu3JF8+dppRm1X7TzcPQw0oNBzpphYgCMQG9lOo6bt+bVfVLCRL36q6DGuFQ+j0cOTRHHcqrq6J1MJhZXbKhq0XTz56reIllwX0Vj0RHdhKVchzpnSls9FzdOHddRphOvAvhWu3ZAWjENKtWVJWZtcJy5Uo6I8uunRnJiEwvlUp01URA73X8ZvI9LHmEvoVc6qX0MtHST50N3Pe76nN1VOHmbsdupNPmBgkIAsrtK1bKOu+qk6HOenN0Kb6FJWN1AilODCysQrZU7Fnvs5E45upnyQFjy6MavKrrFx2gu3JyrAc6OxFdnLrzZ9wZL62q5Pa5EaWSzXO5CGW5tOec04yDnX5nHlTrlAmV9N5rJStXRLTok8+HZ2sy508+eotpzpF+vmbU+nlupx7LM1+a9c1V+a4rRJ8kWBMRoC+jsvbR1edvNsueul6688yt4Jp2xQSmAEWklMGTCyTasJ5FGWuS581JSzUJXS9XzcxOuiHouTux9Ddz5wXarK5FzyX1owynTlF9me2lOsQoW1TSxR00T51ZZUZ26+fcdWq7DYadDdwJk+lvzasuaMLYopr0wRiy9PMq5rdL2uqou22qx7Mrxi5xWcIyi8QQK/dlsO2+/Da9rbsW2jRVC11XFVFyi2OBq2LLlPVEefTnvbjKFwWY+x57LlqAwolGUmyvq8Tv8qEFfve+ei3H2McZN7VNBRCdY4Z9MIjM5LOG4MUpQGrc1rMuarKlwOUWK9xmaRvhqOnu6c2nLnE1KUJxRTTfSqxZduZXmjfHo1ppnBw650EJA+d2VXl312VLrd9WtkdU4adFrKmVXqwddYI19fhdOOOF7Fjh53d5ddVEehje0cenHhzIRm5OMk/VcX0PKvzfP+j4Pre3Xby+nzctMMtMr668OnC9VAsWtTbbpjqhMY1dCFGSEMBjovgZ4nGJ5m2zJ6M14urTfXdr059HPxCamVCcEQpupTzZ9WedMqnPfTl1as2nPAaMgdhcddOo6Y0WxNdM42XtbfktanB2BGskOvpYqlHbjlnHJsqxTb34K6nrZjuqRDHOrJDFClKEkey5vRw35+DsW179OvHbmKjn0YtOqDda1u04elnyc6jp476ZQnU1VTepqpWVjVevMiFNuJcsU0cB3+BrenbLaL9To6cmvm4BNRCjKIV1XVS6M2rPN5ZJ6XHJ1sm75hqgnXKUzSrRTIdU6r3Oxu7TaTpQrZ1Uj6OTRaseXMuNqtLgZpz1k446oqeTCBBXHRRNRAQNER7SMatuPo8Ps8HTq0mfXW8I57nUqrM+ecoVpDuyab1arunHHVbQtZ3VW3s6beaZQqTnyhNKUwD0kuZ1a79GzPowxaajNRlEcK7K06c+miayVX0VpupS7OuqjRXKjNOZprlQonspvqrW43rcQuFRdOAr1TaolGysU6Y3Dunz+gsjmPLEklXLurvzp1jmVnWvMjuqweUaZS6uwnTAJdfl9tYc/l9vmQZVOhaXzyMmWnPqUZo2SLza66b0q5lla84AWIAAAE/XeP9GadSxPJtNQKLQRrnBOmm+mbzZ9Od25U6evsJdG05uDRqzzeVtyW3Vz01dtc6uVtKS1X85Eda3l9OeayvQ5xwZuhKt+Zs18dRnhFzSdtiJ49cVPNlC57wN1cz//xAAC/9oADAMBAAIAAwAAACG59c8tod87XZ/TdyjCxDLM92E+JO/LLW/fHx9LNFNs9ib6JperDo+R1w5MQoK/o0Eb+MJI00rT8kUHDJ28YrNicDwiuanJ0/BwLJh/1zgN4wrel/8A3+82unkDX/tuXFQDcBNP9DUASw1/tEB/8sMlzPY6A9toB57hkjZNVw9Kcd/h6u4QC33c95xymKssR+Z/HLrBOZJCFlVAfJQ7nDzBDgzsRkoHjATH/PT/AAPP/AFRkkWzfMvv4ujmpXoYAlZ33QIixj8RTVWbj/cwAi37azhnE5+ZPqkQJ+G0heyVfP8A/wCCqm6205SmC1TA/nSFATXiTZuSn/B6CVRhV8853rza+uzCIGtEq/5TonyMl/Y6p4VuK+cZ2aUBkMdZpQCKqCjbDUq9J9GfNnVlMBqcA754/BFL9E8sBFH8COnDDfsgnhyNPRpaB3qdflUA6OX7VJUkcwAVoi+KO3rWtcpscEdn+8Gi54F51MiMIN8oCr/IE99d8ovbvGg20NItu+txZixyGOj/AFH9vPAHvFzH8ccTGe+rlZBxWdAamA6r4fjGhBZbwOH6Ptzz6tWQUdORq/1YpvCn2RUpy+GqdeAzEw0bQFLsusFwh7WQlKp30WuUmVTR3757ucBkw+CNCvDw7azjOdZPqTAbDMLZnCTWCzy0ixfTuhDMxJgGebY5MvITYqLfbUlESSKt/WFUfAwAavgzymbgamQDKpRvFP8AkNVX1o4MElbDQBEkdCrS8UD8WB+j1Gndx/zT7XrOn330Dw972Y3UwU3ZQ+ZDvnXODeGIjYJyVHEs6Wn2l1X3t+mymQBlUX1yA2Ml7aIk13b9WYiZl7Pyby34vfx2PYeCUy23jwSREEJLoIi/PSMEOt1xu6dD5S5dQLarvwcaFHdo67Ljb13js/MXp2DUAOttPh5+J+Xy/arI9cFW7zDgnPtaokffIZzkbXyHqD7PcWyhVWob0Oov12DZe+m9pPAJP+EZYYT1ryqu2zlF50ieO9I2vdiT+Aopm7ju38de0ax5PRqmEj9PV4u5o0y04NtsoYiuL5aHdaWu8bJWdnUuzvMNcsaA8bUAcYI7o5Zq+dFOMWcs07tOfmJ2AZgQ8m2VQRNfCT/Zr5H/AC7bZlZnqHpLmeSKwu/ULPTZyef0fETii+lnwGqC7BcS2rTIDTeSjJtDHPqKlxOORnOpWgYGVzzEe/nplDoLpqyux3DQSVXQPsLDoFt54qds3vgYQwDu2o+xgrQdPADGOdCoSfa/LZgWyqlrGGP0da2vOCTwe2m7gfw3E6EAJcFhjIkqKnVYroFXpzp/tAwMVCC2e/XaqZ3sN0uveC6yE6ZGlB84SYGdiwulVte4mI+g2SPebsPwcPW5iP0pBu/9Kzp6XVAlvDE9viz8XAMB1RkKteE5VPERJ2lAWWzojV+Mfq/m0/8A/nKQzSYDfifL4fDKCXpiaXecNv/EAAL/2gAMAwEAAgADAAAAEKK9R/Yt+3vLh0TAbZ1XbE8h5EF2WfQCXA5RHdu81mxRa42gwOTYxArB+Cr5JhwzQlTes5EbUhCHTs/3EL3Rr7+P8ZXNKkAyrX/EpvPn4gHzGG+Y9T2P+jsmvFuOLvNKaIsRfMZ/RxLvc8KD8MZvnzY9gQlvkBNY2geC1dChfR6pgzhq/caxmcVNjaOsyJqHYDrpdHi/9bdbFhNoMxgpezm7PDQYCLn4UeegjKXfvLmxYsDg/Hrr1JXVCPyKMfwxcumOtTV4619UQb74MuYhIdyvTlOoP3YDXo2fWIM9v/fvwOlohsniPwJpAPjNkhgEPvMcidYHUvvqikdet+KFActWlAqZr3KtPa8GWB0Ar+h7S380FrLwkFbHbZj9YRidXhvvawA1ZykwELeYC13I/qv2mEhH6m7YAOk/7ianKsuDDczqLujJnT473VsSBVJtcADPFq7LbX5x18Pr+kyDUixjQKhd9Mdm9oDvUIqvqhKfns4+2mBiJ3xO3ighYATg8Y1T30fuPaoHvgVUqfer2L0+VwIyN6XDDD23aoqATMwe4xOkuhzWYRGTXu4uj7146/kSex2lbpS1VRTrJDDIsCHuAPhUzb1sd0VN++1P7z8tZK850ZST2BAMycabSdTDt3o3Bj9DzqSckKH8FwyWB16XUsbtyo/2Ax+5/wDBn2YkbKWKAVlaTyLGnHDRegWzdxPFUYOb7VcF+XfVe7+vux/jKKqKoClUoep3voU1qgmkpQtcaesihq+sv+ukg0IS7F+3znX7tv4nX0Y67IpmuUaGYbqtsCn/ALuyy/NC1Qs955B6JU5KtPLmOaj1677W2pKknJ/vjBe/UitMpowxVjxttWQ9MhPuoNv8Atj6c2NhzKFGfSpAWeE2pJF8DM8apT7uqrvAay+aSti8iVw6cOUhxms6bXU9Fnn+7rHLbuLX6Vsr/wA5udOPf8RtqGIGlnj9JijdeAWHbs/lvRWgqu+VFcdAob5+kibIS23QCUKxuFH94DQEmb0423/UmQBuOvkrMUWK8CiGZM4KrJxz/ZQwAsttej04RPIlJI7lgU8EjNhxAE+t1h3d54jexUtwXHSzB/KcjXyrxKQa8PxY+1mQM+ioJw96wGZ4Tnw3ATbkWChcCdVZKS2/q2HPLcRtBROUvhUU9VCyu1HAc+oCxSI5zAiNE8vdTR0zwvrAzQ+tX5P8UdQ5jbAamVTt19xwL9aSiIJs/A0ppaO94kx1P8RgsCINIcItiPc3/DwgqZL27iX9sivDkULrOAGaMuL1fs0byJ8tKFZvabz/ALoEImciiv00v550zQrQIGqSojZmFG5PfGuI5FKYn2wq/P6LHuTj1+iV4A0Mfkq/oaEerYEsFNSXq5xtUbs0GaCx5FxLN3qsXRQOLTQOzQYcrnYTWr3yWjr8ao16RbtDeY+tlNt/5Qg8q6bIKGtX/OCAcoL/xAAwEQACAgEDAwQBAwUAAgMAAAABAgARAwQSIRAxQQUgIlETMmFxFCNCUoEGMDNDkf/aAAgBAgEBPwD8WP8A0E1OFPxNSgcXMOJcmJxQsciaMqGKMBBix/6ifixf6Cfix/6Cfix/6Cfix/6CPix0fgJqlXG7cCO+43VDoehhaqFy/wB+g6Zl34nW6NGajNqcGqIOV6uu89K1I1GkQ3ZHBlyxBXWxAAfE2CKi/U9URsWTHmUmuzCBjwbmo/IpXKhNqbImIplxLkB4YXCB0zC0b+JojWRhNRjOLKHHYmYMgdFI9hmXKqIxM1Wc5chPtM1DkETBk3KIPZ6/owCXA783P/HNZtY4ieDL630EuBjNx+5qcQzabInmrE0zkpR7qaMYWCPBnpTnZlwk/pbiHpk/Sf4M0f8A85/iajEHxn78TSZSjlCYDY6twDPUNUXcopoSvaZqUsHmaVoD1ua3SLqcLIe/iDHl0Gu2sKo2Jp8oy4kcG7HuHUGprMZ0+q/J/hk7wGem86nOR2qEcnpmNIx+hNCLysfFSuJrMJRxkUfzNLnGRB9jg9fUNT+LEQDyYxsk+4mZzYqYeGMQmX7PWNEmfTM9fNBYM9B1W5DhY8jt0v2DpfTLhx6jCUYeI2i9QxNsSmU9mM0Gl/p8fyNseWMY8mDIlXuE1epBUohs+ZocW1CxHJ6ZVDqQRFLabNXi4jhlBHNwz1LJuzkeB7SYzgR9RXmHKWuFip7xNSR3M/qfoxNQCO8TID5gMdAyMp7EERfyaD1Eqe26xMTjJjVx5EHsv2I20wODGfjjp/RZx5ExaEg7nMAAFCE1LmqwDItjuO00mco343MZwFLfQmd9+Vm+zD1ZpkzhbmTOxsCMxJ7yz99Kln7gcjzMWY2OZiewOn/kOLaEygcgz0PWjJj/ABsf46UZUAgWbIEH3NizYIAJQlCpcvoTLlzVafd804PkQaojCyN3ogQ9+hjsAJky12jWxswrCsrqYYrEETT5KHeI1z1bS/n0xrmppc76TVAXVHiafOubErg9x1BgM3TdNxm4zdN0J6Gqh1CXVQMCAR1uarApVnHBqHuejGZspJoRjZ6GGV1MMAiGppsx4EoEUex4nrfp5xZd6ieheobT+JzwYDY6D2c+0GPe0/xMzMriabJY7y4WEuO3xIP1Mop2rplagZkbk9T0qEdCIVgQxUY9hMKsrC4o4mt0q6nCykc+Jnx5NHqTwQL5npOvXU4Qpb5D2XL9p66rFd//AKJpnptpikEAw9MgsEXMy7XIMM1LUsPPQLCsrrXTHgL1BgxIPkbgy4R2EVkyEVF7dPWPTRnxnIo5A5E0moyaPOASQAeJo9WmpxBlPPke8dD1ypuUzICjgiYMlgcwwxprdu4VGNAzO5J79MeO+Zsx1yYRi+4UxG/lGUA8GGXEHMUNXEOF2jacjxEGxxzFNgSoVsT1r0r/AO1BxPTtfl0mYAk/VTT6hM+MOp79xB7B0v26rH34mF6aojBljGeraxsGIbTTNwJptRkZyHYm+1xuxmX9RiizDkg3v2i6Vu5mXDtlEGVH4MxVwZjfEoskQ5kNcw5Ru78TLkTcKEw1sU/Y6uiupUiwZ6v6ScbHInbuJ6Z6lk0+Tax/YgzDmTMgdTd+25ftzraxwUaYMvAjmevWTiPgGIxUgxcwZRM/6zA1QckTAMajvzGyKO5Ey505EsGzN0yG4mTgQOp8zeo/yjZ1HmzPybiDNKxOFefHsyImRCrCwZ6t6U2Fy6du4M9J9TfC4Rzx2IiOrqGBsH/1MLFTUpVmY32kRWBWep6X+owED9Q5EKsgKsKIicKKmXkiGAxXI8x3Yyx1ftMZ7iMDcowgxDzNFnG0YyaPj25sS5EKsLBnqnpmTT5C6DjwZ6P6rtIx5DFIIBBsH/0mahbEC8kTG/iZW+BI+prcV2w/7FYjaCJlFgGEQCEGfIwLAJUeY/1R0sWsEKwLzMZshbojlSJpsxdQGPyHQ9DM+BMyFWFz1DQ5NJmLKOLno/qQyKMbnnsPZUqYcu6hfUzKtqY/xyiZFKncOxj5PgeY67lYTJjIaj/ybfhRjDmLAIdohMriVDjFQrTRRtu5UJgJ+pvZMit9GYxuVciRWur79a6avSpqMZU9/Ez4Mui1FjgAz0zXLqMQBPyHsMx5GxmjMOYN3MvoZqVowDev/Jm4YiGMisbI5EyobFCZFonoWhMHJi9qlCETaLsiN3mNLEyptqjFWlmQmzYmh1GUAoOa7CY3LCyCDFyA2DCR9+z1HQrqcRofIdpp8mXRamjYFzT5lzYlcHuOepmfT3/P3Az4jMWo7RXVvPTVDgzByJqB/cY+zUJtJMMJgFxRADCDNp8zaTBiHcmNkVeFjsWIFzb/AGxM00rlNQn1cFVCAemPJZIuHr61oAy/mQcz0HVEk4mPsKg95m09+I+J05WJnYHmLqAfM1GQMpmBaWZh8DxzZ9mdN6GMIfMBuoj13EBvtOfqXCRCZ3Mw4rPaagBVVZlHeVTCaVy2JSfqXxN0RGDmZdeuBgMiNX2BE1+kydsyxWVgCCCD5E1O38D7hxU9KB/rzt7X7mxK0yaXvxG07DsYMDEizEx7R2mdKV/HNwnk9ampw0bEI7wCugJE/KYckZz9wvcxrdTEBjFmZcm9iY8RN+RQB5iL+NQP2hYbYKPN0J+4MKK/cXNR6dp8q8oL+xNCn9NjONiSL4uZEXLjK3diuJo9Bj0zFvPvMZV+oFA8dNe/yof9h9jKGFEXNRg2EkdvYYTG7TkkTAAosmZc+7gDiM0YzQYNzbzHmVqAER0oKaMC154+oAACYATzPxgjkR9uM8ExMqsODB1qEdTKmZxjQkzO12fdnTdjIlV1JhlExcJubeI5l97mNTlcATDjGNAojkAWYF3kkkQYwP8AEfzBVCAX4lCEQ4we8OAC6NRCw7mwPMBsdT46GVKmrybmC/Uze7IaUTUY6O4RYRNhgxj6m2vHRmjSqXmaFaccdM5IBmKwRxYMXiDmDiCXZqUfEyZSCQViOUP7GJlBuopvo3QnplbZjZv2haySZmFqfcpAuxczYhRscGFQpIEAHS4TGboAfq4mlyZCOOJg04xc9zCY4VhFAHiAxR2gH3GNdpVfIQn48QgMBYmTAGquIiFHNiXt5qCNwpgPEPTWZtx2A8DvCyhtt8kTKaQ+/K/9oiMeZcuFoXMCkzHgLeJj0yLVygO3R+YBXEAiYuIq1CQosznk8T845BER0IhJ2nbA7kksaqKwYd483wkkUAZtYDtNh+5lpUY34gN2TM5b8oIEZ8hQ7gIPdnNLGEMLTdfaKgHJmIAvFquPY0PAuYVLcmBe0A/aO256Eqlj4zuNHiI+3uLhylq2ivuHEGAszNwoCxQ3k3xAijxKhMJmuyFcdRMoZSP3jZGOUALYHeFhfIjVZ9pmpHxHRo5qYDZhM04+cAoD2MLlGwDMSih0yNtWY1q2PcxmA7xsQPyLUImNALEpcYNwPYoQ4hVkwD43N0Y9fUnG4LfiONgPeYslubNQruFEd/McbDXtMzcqejRxwZpx8jKJNVMOLYLI5g6mCHuJi7R/5lPkajCFWoyMzftUyfFACbmNyTQEdGYc8Q/DyIMm7gmPksgCXCZcyOEQsfAmXK2XIWbt4mqB2AiYse8X9dxEHxoiZsKsnHeURwfYfMbkMI0aOe8xZacCaY4jlonmrn+R+vYYIe4icLHiArZM2juTDlG79hM4LUwmNXLihMrtZBEIBigKCf2mMWbl9AeZ6hmAxhL5My5KAEFZMYExJsbtD01CCr9hquTUBF9445MIjiAU4mJ2Nmv+zT5CVq7hq+PaLLCoo4ii2MpnyDg0IQCCKg07WeeJtpQIKEcr/lGyDsoEJYjtMYoQ5F+5+Sfk8zVscuY88CLsLbauKfx5SPBlihCYzUZlbekAhhhFk20xqAwj6a7IMOlyRtLlvtG0OSiTwImMY8ZUmaMFg1TzAer3UwgILYz8wo8TAeO0JN8dDx5nH3HsfpHJjYHPJNmLpz3aZDbd6Aj6vDj83Ny/cOVfFmZdTSsAK4mIk3wTZ7wJVtUzpxuH3MOW1onkQtH7QMdpHUgkGps8mIR5EXOm4i6qb1+xLWZyPxNX1P8ADvzU9NDbMh+zUo3z7FWyJmrgASjagDgjmKAoq4eh57zgTvAsyNtB5mry80DHNxdKg7m4mHGBYUTVIGysBwIibVqAXYmRBtqODjc1EyWBzGJ+4vc3D0Bq+IGHNiWhB4qP+tv5hZocjfcyZnruZiJdBNJtGKo3cy4IZ+SgZjydrqIxJJEC+T1LqDRM+I7meOJZAJMzZt1+KmVtzEwz0L1j+txfjyH+8nBmTMVQntDnUubPJl8jiA1GMzYw8KshgeBoRfWoiE9jMop2H7wwzJ2MxORxc0nyxd4YFPQmGY8ZY/QiIFFDrwPMzqCQQYWJUCYH+JBjOKYzUOKNQiMIxOg9TwZsZoOwDCa/OSiqp78zARvtjPyHxEBqyZ+Rbq+j4wbj4iDKIgP2YfqUYqbiOeINOF8zOKyuP3hhjeYDzPT3u1hWu8ELVF5ucFhUxiq46bgOD0yLuFQYjY4n4GDAiJiq7M1OQABRGQMP3jKVJEaeqBmODatkODBkyZQn3XaYcZ/JyIgG7tM7VLH8m5iZtnyEv94wBPJmwGZMe2uIo56KaMUhluaoVnyfzGhhEPDTSEnIoBqKGaw0NjvKJi8WDMfLiAzvCAe8so1HkRjxYMVtyiNk20O5jZ9vFTI26yfubgY6BhHQg1FyYnyBLBYC6mmx8kw/Fxx3M2kNu/aatmoc/wAiYDTgxsqrHynxNxI7zCo2iagg1B1xPwRNWf7z/wAwwiNGmnanU/RmIK6K1dxMyC+0Ajd5hWugYGEiqufyYCAaJFQFQY4ximmQr3BjAkExDx0emXtPQ8QXc+QjeeKPeIRRqUpIszP+XgID/wAjAEfPgyquq/aAixuEynkxD2m4qgq4TZ9nJ7AzVX+Q31aMP3mO7E0BJ04BBmZmLH4kCG64n+UxjtBVcwgXxCAZkVgfjc+V8gxWIXhTMruRytQ8DtC7c0IpAHaGqm8Ecgz/xAAwEQACAgIBAwQCAQMEAwEBAAABAgADBBEhBRIxEBNBUSAiYQYUMiNCcYEkMFIVcv/aAAgBAwEBPwDvf/6MpdtjZMZ2DDky0sRsEwvYCf2M73/+jO+z/wCjO9//AKMFj/8A0ZW7lhtjqV9zaAJiggfj2EjYE1/H4Y7hLlbW+RCla3JYFHa06jR7WQdD9W5HofxJm45OuDMSxkvKseDND6lydyHXkSuw+D5HpqVeY/iIdjUtTkzU1CIFlVZLKBKqwij8VlCgiX1gHgfjh2e/idp8pM6v38RXA/ZOD6H8D6ahEyB2srj4MpsFlasPr0tHtZH8H1r8x/8AGI2jLF2NiMuj6agXZmNSFUEj8RBMdpeCRCPP4YeUcezfweCJjWV2FkB2riZNRqudD8H8T+FiBgRMG8I5qPx49Oo2Kt9YibKialY5ln+InzK22NGWVztgExae59nwIJr8BADKU1HGxzHQbM0fww7ylq6PzOqU+4iXqP4b8T+GplKyOHTgiJ1itUPfwwnvPlZQfXA8RAQoE7TK6/kyw7mop0ZrvEddGATGUCsH8QsSrfxK8YH4gp1BXvyI2Oh3xP7ZY+Lo8CWUsvxCIp0wMxGW/HNTf7hxLqzVYyEeD/6XQONGX9PDNvUxcT2+dQTvH1DZNEwLCsQ6lig8iBeREGkA/BayTKsfxEqVYBP+pub5mp2y2oMPEvq7D49OnMeza+V5M6pQHVb1H8N+O5ubm/Q+gM7Z2zU1O2dkU64MVP3Ujxv8ErJIldOoBqK0DTfoIIIZk1dw8R07SZ0m5VtKN4caioNvQ42rDjcyqGouZD98ep9dTU1NTXpqBSSAByYnSL2r7tgH6llT1MVcaM1NQpK9hgDB6KCWEprCiAeqzfoPQehG5l0eWiMVYEHRHMotGVjq4P7p5mdQMnH71H7p5EI159D/AOkjUxQFvrJ8bELH9dHidVx+5Rao5HmdpgSdsC8jiD0oXbCKkIh9AfQH0E7tTvE9xfuXMr1to74gHJmFknHuU7/U8MJtUcWJyj+Z1TDCMLUH6N6kfnqEQTBu96gA+V8wqHRkMvqaqxlMHoBBBMVPmAQwsPuBoDNwGEzcsu7YbbX/AMRPauPkwrZWp34i+T6dNzF0ce08HwYVADU2jaH5mbiNjWkeVPg+h/I/hgXe1cNng8GNoEETqFIdRYo5Hn01BBEALCUqAo0PS19eIS/wNwC36gNo1xAfv11HKDkwZNY4EW6s+CI4D1mduifTZB2OCJhZQyahU5/cDgxkW5DRcNH4My8Z8ewow/4P4n88S33qF+xwYBsFT4MyKTVaR8fE1MHG92zkbA8zMpQJtV0RE4IlJ2ghnt7MKpWNtDloPAlNq2QoBCdSv9pZvxL67mfQB19xcaxeNGDGft8aMprsCaYx/wDNh/MPoljo4ZToiY2SmZWAeLVllS5SGq3hx4MvososKOPyHpqa9On29lvaTw0YaMy6RbXseRNaM6R/vGuSJagIIMfGKnxKBpIQdxRqZfvM/jiJQxPAJmNi2hg3gfUtBBAhTcqTUKAxk18QAfU7f4gXQmQO25/+ZuH0qtetwynREovXLqDA6sXyJfSuXUUYasHgy2pq3KMNEf8AqU9rKfoxHFlSt/Hpl0dj9w8GYWR7FwaApZYrDwZed2EfAlXgwwGMA0rRFhf6EP3NxD4ghHoPTMqPeWA/5/Gm+ymwOp0RK7lyUW1Dpx5Ey8Zcusuo1Yo5jKysQRojz6n016j06bbtShmvMtQOhUjmMhRyDMK0g6J3GUOxIlY0SPVdfMHbGhmjFnmE+gM+JkJ+paWpo7Hj8cbJfHsVlP8A1FdbVW+k8/7lnUMNbqzfUNEf5KIePQ+ubhEbsrGx8j8MOzsuEPBEImXUD+0RyjhhEtDKGB+ICe7cPqNzUJ0YW8wPzEMMI9BryZYoZCPsSwlGKMIR+OHltj2g+VPBEDLoW1naN5E6lhhCLU5RvQ+oJG1PImXgb3ZV8+RCCDojRggOiJU3fSjfxCRoTKbjXotjqCAdCY9oC/s8U7X0EUeI5CrC8L71F+IDqA7hOoG3LfAiHuWZdCMO4jn5jp2HzsRMex17kBb71Dj3gbNTgf8AH4dPzPab23/wbgwoujU/KP4My8dqLih8fH4VX15C8HTfUBZeCJkYdd42vDS3GtqJ7hx9+nT27sfX0Zkj/QJHBE7+8EmEeuK/cg55E1AIf1ljFpo/UVDxFQQVzX0J2E8mAftL2GwNylpkJ3VsP4hBJ0Zi2NXaNEjmV5PcoB5nU8VbK/fpXxw4A/DAyferNLn9hypnUa/cxw+v2Tg/glrowZToiY2eloC2cN9zsPlTsQ9rcOoMs6dS/KHUxsb2Kyu9kmZK6x23FGtxvXFt7LNfBgi+Y82IAsUp8ifqPEXZPAh4EMdhWpO4j+4S0p8iHzMqtFu4grBuUAymgkqA3k6mDg2pZdXZzWwnUui2UXMaxtSdiNj3L5Uwgg6PBmH3f3Ffb9zK0KMj8qM66nXOx9GU52Pbrf6kwKp/xYGCsAbZgBM3IVyEXwIlZdgoGzGQhyp8jzD8+nzMS8MO0n9hAYx2Nem9RWO9kQWfxBaYGJ+Yx1zMndgIBiKFUCUjeoWA2TxqWWe4xP8AMrJ94anTAXfvcgKIFsPKPsfEZQ66cAn5mZjVk6VNmZ+Db3lghEqd6LVcr4MzeonIQIqdo8n8NwH0Epe0EaYw22MOWJnO50jCcavccHxLwqZ1vd42Yx2x9VYoQR5ExsgWrzwfn0I9AYPRZkE60IF0PPMAi6VZm29lQHyZVMZe5yxHHxMCzFVVpftO+dyqlKWLBz2nwPiWOoUtvjUDDYJ8HxLaUu2Cu5m4eJWe2xPPzqZnTSm3pPcn4d0U+YGi8ytQFHpg4zZOSlYHG9mXVJVhhEGu0TMfuyHP8w/h0rGe5nIHgQ7B7T5HqBFE2B5M95RHt7oJWnzqOwUFidAS+022Enx8RASQBOnYiuNllAHwZVTj19vdSv8A/Qh7OwDjUCDt0B/1GAIGxrUL9vCjZlla2DTgHfxG6bWFYoe3fnczOjF+96CG0TsCPW9bFWXRHn0BiHzAZV/kIG0J3if05hhKjey7ZuAJfxRZsa1vQmTs3uT9n0Pr0K6mukL2/sx5MzFH9xZ/zubijfmEgfENkNkZ9mLEWeFEzhrGP3v0xcYdhYmYSOligjuUjkSvH0DpiUI8GICFC+dfMPcNaAlhcgEgSsggjcBVd6GzMvqd6l67KAAdiYuU2LbyT2tskGXVY3UlftXtceDL6HosZGE3KjswjzKV0AZvcw6Tfk1Vj5YbmMq01oqjQA1Mtv8AQdvIK+Zknd9h/kwQ+vSs7+2t0QCDwNzqdLqlV40d+dTezv0dozH0Vdyur7nb9CPdXX/m3/Uysw36UcKIqtvgTFawFf10PmYrUaUleQNQXq2gsVlAHMtftUfZ8QhhpmJlrFH9ys7Gv2BlmSq0BkI2RzGKXUVh1DkzM6Yly1lP1IPiYlNlGS7Oul1oanVsJMqn3K103pSf3HE+YniDZ8T+nekMlf8AdWLyR+sL0patDHTWKOyZTFMDIX5XccEsTvyT6EeqnREpyxZ08o+jocbizceAbMWsmV068yy6qoHbf9S/qFjcIO0Qksdk7gHImJQGdT8fMx0pRQG1z43CiqOBK+0L4inYJAgVdAsOfiZNmQpYr2ka8Gf/AK9a9yuhLDgzEyce1CoPaSN6Mc2ezuogkDjYleVld27XC68CU3V2Vg7Alml38j5nYIvap3sRXQk8wWjgATp1bZGXTUB5Ybi011UJWQAoUCdQttbqC9iHvRx2CX5Weca/+4C7YaVQJYhBYEaO+RD+C+RKbNUFYp4E3O3crqJ+JpUEvubsOpbs+Tz+GDZorszIfsrWwDZ2NTAN1y99g/4EdNINCVp4EsZe6XKhoO/J+Zk9Nt912DDt8kkzFykpJ2ney8DUOfbciCle3n9iY+BVeqM79xHyJ1BvZqVKyBzrcww7DbsSO0T3rG+YHb7lYYDepV9z+l6j/dPeU37SbEs6knUcHadyN3Dcsysg9QHsrvsGmJEx8mi0d1tbKR9idXpQZRZCCrHyJahUkGCGag8iVE8g+tY2wmgojv3Ey7/GMNkn1EqsNbAzCsGQVRpTWEUAQgcRiEQmbHLMZbkVKvIP8Ay/pSOnv33kDzoGYmNiCsFFB38mWJi4qWlvn4lWazKyVJoHxD03vVXtsO97iV9qjXjUWlRK0X6irAoE/pftOJkoX7TZwJ+2GbQtbFe3Y5mBlJZkMz2e2T4U+DKmem3d67qYa2BsCdXxKjSfbA1vakSwk+fI9DCOIo5j0f6SWKPA5gPiCIYOazNcy/FKrUh/yY7MuHYXGud+qifU6Q3/AJCyr/ETLdiQqtoiUPkWqqW64PmOlFei55PgGZFV12SdHVZXQmbY1OMiWuG51ozAzHa41oo7vKgGZeHZkp/q/wCmw58ztOMR2XqWH1BnFwisR3DW42ezZB8hFHEAlaACKREVrbkrXyTqf07itT3VkL2BB8fM/qbHFNlZQn9tzDwHyKwyjvAIDL8idOqAxfaZSQvA7pf02gUNXWNeTozqeI2Pc3GgTCIYf8RE8gTFr9zGddf7YeDr6MBieREP66lCIbv2OgIe57mZiCEGgZk8WsfveofRYZ0dd37+hFsCVrsx0Z7QQfmO4q0WPPxGUse+w71yI/U0N5IP6V+Z1im++tL0G0+hOn42R/cI6qR2ne51LNvdzXYjDXyIvb3+DMdRX32Nz+vEy2anGGztrDuVpsw8CBjOgULZl9zA6HjUs6kKL8de4dw0GAnV8T++xkZV2VO9zomMabN9pG000Y6M2GnX8So41jldsBxCPO4TCRoCVLtxMbLpoqPcfI1HYNYxHgk6giHxFbjzK13uO5qyNb0ja2J1alSqMg0NQ+gh2dTpFLJr7aMPCkzGo0xYneh4jJl5PUADWwrUw46mtlPyCJX/AE9ebX731X3bj1pXUtSjYA1EAU60dmX/ANsN++VGplZ+Nsrj0KB9kSivIv5cEV+SJ1K3vvKjwvAiKQPE7YVHjU6T07trr2xXa7JExzjJ1BaGr7gOXYxXQFe3/EjiAKBwNbjuACTPd3yDOpWNZj2oy6Gjoy8gEwRVJI4intA0vMvNhQntgvA8wZVf3EyE+5/eICNTEfvoD+Ny2h77FKjYHmZNbCgKx3oR016alCgmYRTGQPa2ifAMx+oV3WH9GA351MS5WHAJ38x2t90BU4PloB/MdSV0DBUi/GzMwOin2K92N8y/pGU+3d+5zzqY3SCGD3fB8TNsFdTFR4GgBF6fk3MTrQPOzB/xOzjzMPH968b3ocmdL9zhRW5BOg0swvaX+4ddN4P/ABMPvbHLfAP6yuzY58x3AB2YrEEiZDg49gPP6mXdv7bHOzBxMLFsv12rvXmJh0om3HMOTU1prZQE8ciZVAFjdnI3xDU2zwYFaID3czBAOKBqYNRAczqJARiYUaw8DgRl0xHp0rGN13cV/UTqyBjTUEJOxrUqoKe0ijQK8iU+xRWqBgJsa8wR2heNY8Ys2huOfILS39jqKI+Qd8Sy1u3W/M/pnpPf0+y1uHfhZ03E/taRWTsg7JlyK6FSNg+ZVUldXYo0B4lm622Izhh4hGtRuQQfBE6pjirIbQ0DyIBOlZ1da+2U8jyIuXjm07BMyq8C0lwT3a4AjjTEa8H5nasCD6ldS/KiYwCVn634mFagRgROrbsYKAQCeYtIRdamQB7rQDZAnSkSjGH2eTE7LD37BI8RLDYxKAbB1sxcdEYsf2JirwCT/wBQ8+DL+o4tN4qZv2M/uqONuAD8mWfsoK8y3/Tx2fXIXZlWY2TZvRXt8iE7ghoPd5mHinIyqq/thKM/p2ItWKLBsADQi26tVfsbncpIG+YdaliB41ZUnU8HmGdT6cMqva8MJfVZVYVdSCIjsrAhiIl7sRq0zp2If8yUMyRrIt/hoIInxKyfuVv2rwORMjISx1B1sHxMu+tF0DsxjsknyZgVF7lJXYBlyotQ0CCZiYlrjZLAShalTsA0Yo7ta8Ayy3ZAEBCDuZtTrtFFlwtpuUsfI3LMm2yhaQSWU+ROh5u8QraeVM/vEcP+ul15MQ1FrGrGtk7m4DLhobE6dRYKntXgkEAzozUplmy9t9g2B57jLOpXNtqtBmPAPws6TRb2nIvYl28bPgRsioOqFwGPgbnx5j2VsSNwqJr+PTLwcXIUm1RoDzMg1pe6pyoYgTpmLVk2KpP+7RlOEmIpCbMzBrJtGtfsYIIsrPiJpkIJ0T4marpYe4aMYknzuY+G9x/xIH3OnYS1kHUurDX1rE0qjjWpYikh1hurr0hOiedmfoo7t7mbjtmUMm9fWoOl2rcFfHbjydwdHyKsoMmuwzC6YajZ3PvuO5m3JWoTeieBqU0hawPk8wqV8wS0b0JhNY60UVeSDuYGI6ZnbZVogEgzBSh8plIHcoBmS7ABVOhM1+2v9e57e7gidPzb3xdZCdp+JsEkgxLNLryYnc3Jna3JI1Ov9Q9mr2Ub9m86h8zpt/sZSNv5mK/v0hx+251EEZtwPnuggimVGdpsQqOD8SisZD+zeuyBwTB0jFHhYMZEQBRrUqXsEVi+VseB8wuwTQGyYtTnyefqGhLEYOIl1mNcFsBes+CPiX2kY/fXrkcGLcbqEbeyDomZGatPagILk61G6mUtWvSknzLSj8kAncrZWHEZAwMIKHmYdBvsYAb0pM/pjFY22WOvAXSnX3MhTTmY44Pc+o+JZVni9B+vtkGZDXtWHdtbPKiYlbJbXYwHYTxMy/GrYFnAJ40Jfkdv+BOidncx27lGxrxqUBe0Gdbz6sXHY7/Y8KJfe99rO52TDAdEGdDzu6oIG0wG9TqL9+Zafnu59NxZX8SltFT9GUUUP22hB3EAEzITsckDib34mReEUgeZiVaTZ8nkynu8ajv2PyefqWX1uhVXAado12lwx+ZW/afba0do8DcHtV6UEkNyAJn4+JQ62vvu8gQUY6sLV5JG9GBHKs54+dShgwGmhdgxBBO/BnFi71zP6eXFRXbS7I1onnUxrKUXtoCldf7Z7FTPU11gDhtqCZ/U1+eioKdqnyVnTGY4ie+D/wAmKP8AR1x5/WOlAuVrSobUzm3tR440RMcke2O1jrXJmTfelRZEbQ+hOq5GXfb3Wo4UeN/hh+/s+0rk6+IzWMx7we7fPqsQniVE/U6af/H5B4md1HMOUypU3tg/Uqd/o6MKVhh3ESrt0NEai/wZYlLH9tblmLh2HWwD/BnUca+qw+wXYa5IMV8lbCTUxPggiUZxx6NCl+/6l2ZZllffq7AvjcQIFDaG/iWW26ZVQ8/OpiO6a/XgnmWaCH71sRL9AfoSZ//EADcQAAICAQIFAgUCBwABBAMAAAABAgMREiEEECAxQRNRIjAyYXFAQgUUIzNSgZFTNFBywSRDsf/aAAgBAQABPwLRH2Roj7I0R9jha6nqTgifD1aJfBE4aFMo4cI5RZw1Tg8QRoj/AImmPsaY+xpj7GmPsaY+xpj7GmPsaY+xpj7GmPsaY+xpj7FFdUq18CHTSv2RLlDW8JYHj2MGk0o0r2ML2Njb2NvYwjCMIwjBhdKwcPo17xW5XVS/2RLKKv8ABF9MYzexpRpRpRhexhexhGF7GEYRhGEYRhGlGlGlGlGlGlFUYZ3SKaqWv7cT+Xo/8cf+H8vR/wCOP/B8PR/44/8AC/ho+IjgaUYRhdHCvFnKE/Tt5cTXiWff5vBvaSONvSWlG7MGOe/SjTt8qEtyqeUpD3RxcMwz7dOfnxZw8+3RdHMS6GH10/3I8rv7kjhrNUcexbDXBoa+YrnXnA8yeXyz0voihRJL5XDWftK5ZRdHuvcnHTJr9GiiZXLMebOJh3H1Q+qP55cT/dZVPRNMTyjiq8S1e4/lN4O/TuYNzHRBkCxewx8sdVctMkUsmtji4b6v0kGcPPo4mJNdS7o8HFf3OXC2ZWknDXFolHDa+U3nqyZRnpiUtFqJfK4W3Kx5QnlF8Mxkv0iOHmReVzv+ktW/Uu6PBxf9zlCWmSZGWpJnFV/vX+x/Ik/k56UVdyazEkl8pNp5RwnEep8PksXk4iGmf5/SVSwUWc73sWj6YfUuXE/3RiOFsw9DGsrBZBwljrk8dGOWBI3N+W/QslX4PG5Zgx8qEnGSaZRb6sPucTXmP4/SRZVMhb7jtiWTyW9VCzZHlc82S5plVmuGTiK9cc+UPqk9+WOjImZ5PHPBgiR23Flrcm8bMz8vg54tJouhom/0aISIzNQ2WPpRwkO8iT0xbG+aKLdE/ty4ivS8rsPol8nJq6FE0MUWRFLY0IlWOODBgaMGOmuWmcWfUjiYZjn2/SJkZmslMk+bqsX7TRL2K+Gk/qEsLBxVm2kfQjhbcrQyUVJYZZBwk0+ifycG3LAkJMUDt4NyCZ4NA68npnpjrNA4DXTwN2VpfgsRbDRNr9Jk1Dl123xh+SUsvL6ovG6KrFOJfVrj9xrm+/TnnjlpFEjWyNIq0jQekekaMCgaUaTQYMDgOOCUR9HDyamfXE4mvMc+V+qXFWH83P2RK+yXkz8iqxwlkjJSWUcTTn4ojXJ9SXNIjAhSRr+xpNJgZgwYMc3EcTA0OBOPRB4Zwz/posRdXon+pyZM/JRRdoeH25cRRj4oku3UlywKJGLK6fcjBGDBjljkupjGiSJokujh5LTE7ovrzH7rqf8A7BRfp+GXY7nF04WqPSucY5FEriQiJc38xjJoaJLnw1mHpKmWLycRXpln3/8AZclPEOGz7HEtSok10oRFFdZGO5CBFdD+YxkhonEa5Iptykzui2vKaJRcXj9WomlDWPkZHJ6WuqJVHPKC3Ir575MkMwNFi50z0SK5EllHE1ZWV+mXRHuUwUpFlMdOyGvnwRV2IxIx/QPkxj5Ms7dHD2baWQeUWRL6tMvt+lXfoXcrlplyvhpl+SS+S+/REh3K4bCiJfomMeCUka0WduhPDyU2akmjui2vKaJwcZY/SR79KKJZjj2LYaoj+S+iJStyMdhfonNInfFE+J9h3SZqfLVmPTTZol9iuZJZRfVqX3Gsfo4d+lMrlpkuV8MSz7kl8hmOSI9zhofIfPPJ9DY5k7cIna2bsVLYuGHQOrBJY6uHtx8LIS8E45L6c7rv+jj1JlEsx/BZHVHA18h84rJXAqWOhzwPiIo/nIH85E/noC4yv3P5mD8itj7ifTNjZLc0i0oU8eD1onqJksFi66LtW3kjLJOHk4ij9y/RR6kVS0z5cRDD1Eut84dymOWRXOyelErRxnIdVnsehYeiz0j0mQjNFbfJ8myciUhyPvJnrL9sT+Yl7HrfYyvBGWR9WBZTyU26vyRlknAvpx8S/QrrRVLVAnHVHBJYyurhuG9Z/YlwNWh4JwcZNe3KBw/gXKT0rJqlZIhR79zQPCJ2RRK5HrRIyTFgSEYGiZOQ2Ri2/uSr03xVnY4icHN6VjD5KleksrwOOlkZcn1xk4vKKbdSyhPKLIF1Wnddv0C7PriUTxLHvy4iH7iXTCPp1RiRjsfxKvTdq9+UThuy53PbHuV14Rsid2+F3LJJLNksfYlxEf2xHbIWrGWiP2K5kBISJRLiXLh5xj3RxPp3pbPI+HnkjUk8yJ2t7JDiKCNJP6n8iE3F5RVbndCaZZX/AMLqtD+3z/HyEyEtUUxrJOOmWB84fXH8kl/UguXH0epWYwI4UXJrL5XWPsiVqr2j9RZXZjXMn6caq013XccnI4KGatyyiPg9JwkQjsIRIuRJbmCMjWeTER4O5GI1sXfX8mE3BlVuVlGzRZX/AMLa3B/O8fIicPL9vK+GqOfYfNd0OWHCZFqSJR2OLprjLI4L3OFFzkW5y2iiGLNUoljpvr05wW029sZIcPLyK3THTFGqT/cR7kfpFzsRYt+Siemekz0ZHoCqSGhl/wBXyq7HBldnnwbNFtWdmTg4PHzf2/JhLEkzvyuhpkS58NJW0JeVsUvBbLAoepZuXUR8IpWmQubgOCNKIwh7DhHccIksChKRVVjpkWrlASMGOTGhnEL5dVrg/sV2f8Gk0XVatiUXF4fzP2/JRRLMfxysjqiSXjnRdKqeUVzjNa4F+8clEVgtS0sj/dELngcRpjjI9FvuKmKFAx0MkWoZFkX0tDLO5ODi/l026Hv2K7CS1Ivp1fkaw/l/tXyUUSxP88s5OIr/AHD58Pb6Vi9vI1qr2K5Y2Js7WEewujHRgXVIsJdxMgxdDJEoa9hbr059/DJRcXh/Louxs+xXMlHJfTndd/l5+H5SZGWYpkpaLPsxlsNMhoQzgb9dK+2xpg2W5wyXdsqeYoXRgwY6cmebLEWdxpohMi+iRJlfc4qKTTJbr4v9Ma+XRd+1kJk4nEVY+JfK8DXyYnDv4cF8cw/BTPUsPuWQ1IkuUuxwN3pW4faR23RtJHERxI4aXwkRdODAzJq5rk0TLVueBbSIMT5MkPL7FS7pnEVaq2KbXfsNeV8yi3OzISyWQLq9L+3yX4JRcXhjXyF3KHiY1lMy4yNWuGxdX55PueTguL1rRJ78uKW6+5Q8SIC6mxslIixc0SJss7mowReCMjIxldXw5JxxuPdF8NFjE8Gfl5wU3Z/InqRbWicHF4+Q/BOCmicHF4Y4/Ii+zFui5YmyqzS/sTew1gZEg2pHBWu6rPlHEUSlDdb+GLKmVsXRkbGyUhfExQMNH9TJ8RqHImyyZFcpCswKzJkk/wD+kV8JZEgcVRrWfYdee3zYycXlFNudz6kX1ZXyGRkpLYnBSW5ODixx64lLzWjiV2fL1NsMk9hi7COH4t8PNvumWfxaMo+clnFQnpwjh55iIXPI2SZJ5KoYFyfJyRrRbPobGLKkiPYtZU8wRNHaZ3Rd/SsaxsTdc4+0uUHHs/8ARoZol7GmXt8iuzQyqZOOUcRXh562Qm4vKIWKaGk1uWUuPbsNdUThnsziF8BIfPwIlz4KzKELlkbJMnPwiECK6JMk2YPTJV45ZRKRGJGOZIeyLXucC3KlEi6PkRx8fhT6FNikamTgnHK+RRZh4ISyi6GRrDx1MTE8boruUtn35WUZ3iOOO449C7nDfUy76GS6PAhrkzhbNMyDz0SLJvOEQioogxGUakaxyP8AQ5P2JWSHIbGmQgYKl5LJbE2cB/6aAy0icTHNb6Fzp4dy4fUWww/kcPblEt0cRH4s9T5ZwZK72tmKSl2JQjLuToa7DQ48l3OH+pl30MkeRiP2kSZ5GJ43ODt11romR+uZpk0OF3hkXb+CMJeZGk0v3MS9zEhxkz0PdnoxXglFDI8lLCLJk5bnB/8Ap6/wMsI9yfYur0zfLAjcjFykkV1f0VBsuglKUSUHF9dMtM0Q+k4tdT6FIjJx7Mjen3ESrjIlw78DhJd0YKIaUcQ9kiQu/PwR7omPl4ODu9Oz7Mi8rnIxpt/JFGkcDTySTHFGOWSc0iyWWJcskpE5EPingoWmuK+xIsI/UxnF91yfYjy4dNy2Xgp4hQymTeZyf3Fjyh8NVPtsS4Kfhj4e1ftHGUe650x1TRHaJxUu3U+nOBSRGyUezI8QvImn2fLCJNJE5ankZ+8fcZ4/0IfQjguJ1LS+66LI5K+3RgwNsbHkeRoZgYyTLGfwzhNT9WXbxykWywiv3JsvlqnzRkojL09WrGRVx/yPRfh5Gmu4thZ9zc4uKdefbnTLTMdnwlktUs9T68moT9hWz9z1pkpN92N8pd0xR1MkeOT6YTcJZRw3EK2P36ELpYxvlgcRokSY2U0O6yMUVwjCCiuy5WMt3YlhF8tMWJ78n2Iijlkap6dkamu5qZ8U+7NOGQ7muqOz3P6Fixkt/h/mBZRZDvHll9b+VlmX0SWUVr4Y/ct+tkN8j7D6qrZVSyjh742xyuhdLGuWDA0MmTYstnAcN6UMv6nykyyQt3kZxlm+nnIS2KY75FdKPaQrK7dp/wDSaipPS9iPfljUtjGHgiskLJR/A9/wW8JGW8Cdcovddb+fRDMsmEnPHucR9RF7MfYfXVdKp5RRfG2KfQul82MmTZTwllz9kU8JVWtoi2GyciyWXgWxbNRTZKWqTfJEVmRgopsikX8M18UeShLGcHZkUpPubqWMnpi2zyrcZSxJnoRxsW8PlYLaHD8dT+cllmNKUUTSjNZ7NYLiI+3yeDilVHfubozyXS+bJMeqbxFFXBJbz3ZGC5NkpFthBDZxVuXpXPJCOEVp51aco/mp4xg/mbfc7kJYZOxvuY1HYzlZPubs0kbJw7M/mcrdDjGb8YOI4T90DHQ/nUR8ko7Za8k4qVTLPqfL9q6HyXKCbaSP7SjFftK5KUTTjsJ8k+hjkZb7IVUn3FREUEjHJslIsmd5cuJt0x6IRK652dhVzgep/lFMlVGSzD/nLDO4tjuYW/LZLlj7DS5enZGGotqhYvuTrlB7838hdKWWL4Yln9tDb0D7sZH6Rj6uDj8bl/ihs4S7fQIcTdCZk1Go0SYqYmlGOhsbJstZWSZxP1LnEppdjIQio4xsWa6332E67fsz4q5F0dM/s9zU2JGlmGbj7cuw2z07P8WV5rmm0bSiW1aWSrUu5dS4P7fKXTRHyJJbszmEsH7ZIfKHkYx9PASSt0v9ywcZw2hKcRzcZKS8HD3KcVywOAq5+4qkKKMdWRslMlMseWRiTOJfx80cLjTnyJtTX3JThL4Gdma2ZbFy9RmtkZLGGib227EU2emPSkU8Qmkn3PzE+F7LuWV6kOqLjgnX3RdS4b+Ol/I8kFpjEayRWMlixIs+pj7i5SJc0Y3E3GSfsRsXEQz7nFcO6zh7XXL7FM/UXLSJGOvI2TsJTHlkYDkkidijuTlqk30U3aGK6TwTsz45rnXFMjXH2LJKKKJJvfsSrcPoWw5SI1ylv4LavTa38FVlsY/YduWZTjsV6n3L9rZYHiSwyyGmXQ+a6aVl5PZCS+IeYMtxKJLux85EuhboZ/DuJ9G3Eu0jioa0TjpkcFV6dEc92JGOnJkyZJSJ2EpZ5akid6iT4pvsOTfP02aWvAsC28mWZEYMM0EI4RZZjsJStkQq0lec7EoSlKTx5K49l7l8PjxqOxLc1tLESu/CwzClu2ShHHcvr1LoYuumvTFLyZ+NkX8T+5b9MRsf/wB8/Ix9uhMfLg+IU4+nL/R/LqfER/PJdORsyZJTJ2DkaiVij3ZPiH4G2+/RgpZPEo5wYXNIQskdXsflErPCNDteERp0ySY4tbcpzbQu44pvIq5TP5d53J047D2yLsJEotdEhdVK+JMi/iI5149y+n0tI8ygT+lkiRE8kh9TK2cJL1YqXsIXJvobHIlaTuHIlNLuTvfgbb6vBHKNW2BQljOOXdirFBHuJsb2JfDH7lBGyZpyviPTrz2JVxbx2JVS9RImtJCck9mO1ae+5omi2ryjBHOWYz0Pp3FEivAnhlK3z7F2J0L38C4S3HsTqliWBjK/qH3/ANkt/kLufwxf05P79DMmRslYTuJWNncsbibv5EdzBBbjjKyv8DrnjsQibkcsl7HZC9yUtUj6UiufuyGMbPlPVnJZNzfYsFw8sLcko1tbnrwwTeXlFcMx+IdcVP8A0TaT25Z54FHoh3I9zGTh8ODXkutVShg/mXNEMaJN9sE9pSX3GV/WPu/yMfyP4escND79DGNk5lkxsjDPcjEuGsL5ETBHsVS+FIvmvpX+xLlDsL6xlkiC1Eslf0kJ6dxXXT7RIxeO5orjuShU/iwOeY6UOMv3ZN+UZPCz3Jd25D3NJj5FcdhbS3OGUXGfuQWLI/c4iiWz8H0yJ2uW2djiI75GQ7kl8TJdkPqR5OE/sVf/AB6GSJsskSZXHUxo2UC3dlj3+TGQskbmkRXNPuIk8I3kyEVEzk1YexUo17y+pnqVxWWyXEbfAam92z1U62mepgnOdi+kgvixIwvwiMoaWyyzLFDpXLB45VaY6F5OLohpUuxXsiiMXu/BbdvsW18PJdtz0t8ReS+qSi8rk1hol3Q/pH1s4J54er/49DJFhJD3eCuKSMblvY4jEcL5ansQ7i6bJZ2K4kYSkOMFtkhU32wWTlnHsVUytf2JwUVsM7kK13Y20tkNRj8Uu5ObZqfYjhN5Jt+Opc9tSKYL1E29hyU1JClHW8Q2RSnKL8E4xXZ5NLL01J4Y+InJYZasSM7HeI+4+rSsIwfwueaMf4vmxjJImj95AkZxqn/wlmUyaxLA/lVi5eSEF2ZfVKr8C+Jlagu7JXY2ijhq/Us+IwoWpfYt4dJ/WV+pCOIYZ8ePjhksa3Xn2N/KZXpa+Eku25OEZvZlylF4K4bOZTVlnF4jLC+Q3goWu6CJVzryVT0uH4K5xd0sew1Fonw9kPp3QrseSdcLd4/UW1OL7FnKL7E+rwZ2F4P4VLE7I++/NjGSLGZ+MiWS2RY/HsVrMyxbj+VWR5Vr4uXE3v09BVW0sjIUNLVJEZaHlE5Sk88ox/pp+RfEW/0LG9OzHxDkfFnY08Q0vI3JR3j/AMFBWSTZoliz2T2K4pQ/Jx9kVLb5DZwXDvGfLLNUZtZ8ldi+EjGGdWNySg/ySu0/UjitEpKUfInJPuXXK2CTW6LIE1gXYZ9uhcsmOxwT03Q++3QxkywlsyLFn1F9jia8Q1ryVI4nGyXy6+xEZTH4ck/pTJPVZv2O627EKVjMmN7CRatKSKo6poUTbJxaUqmQqfeSZB0rwepE7kEsJljbs0luiMN/BxU9U+hc2VQc7EkQk44y/BY/iyV+CONKL4PGqL3FxeYYl3JuDjzkiyvKF7c3yXRAqeJx/IubGTJIsjscND1HL7RPXUJPUjiLNVcYryxYRZl79S6a+xEhW5laxEtsxBorpzuyFe32RnlTTp3fchDXOTZd/TX+yjiIzjv3PURZf7FNurKZJoSNKMT27YEtVjkcbdnYk8tvrZwEcZmxwlG37M4mpY1RXYrZTZqpQ7NMvsT2nL89K2ZbH4m+a5LmiJHsVvMY/joZIki3sLX2Xk0lFMXcs+xcv6jguxKGwxdFfclzissguyI7vBBYRt5JPVN+xVDVhIvxGCihySI2fEvyd4mYVxLrFZPJGXZD2/cN5M74PVda+4uJuZXXxD7vBoz8Lkyx18OtvJxE9uts7shUqqoryRhK2xY7RLa/6ewvhmVW4WCck9ycszb6r+aH0JMjB+wng4WWqmD+wubGMtWxjTsYMyjvHuRpSh8SLc5ZLpiPnUsPIt2UQfcZfb+0jsUXUwj33L+I1y2M8o8TZGKRKyUnuxR9xyzhCwyfwfkhL6tstkOEsnu9iuiuvxytvhUi+92vJc8vrkzgoa719ifpb6t2aowjpgXW21rHuSb1EJGWPp3xku8ckh4Q+S3ZiK8CmeoiTyfw++HpKDe6E+bGMn3RNf1F+Bmc4Htg4vaX5JdHjoihYKq9mQzpRKSUGZ1TzzxtzyQWRseWRslFFdU7ZFdNdaNXhcruIjCLx3JSz+STxkfLJnm3y4CvRBN+RvLbOHgpPc4qOuWPYuhpZBmecUn3JRxypu0bHE1rRqXKuCl3LYqPOK54MMRVxFy/exXXf5Id9y8xHxl2cYR/OW+yFdbLyjhuJrnKNMq1n3OOrUL9v8SQlsidy0b9y+WuQ+T6olFeSPDySNMNMc7HF6VD4Xkqqaw5rBLGfh7CwmiyzX+OhTwZMiwR4hQjiKHdl7sjxOhkuIc/J3RY/iLfYVTYqY9MmcPD1LoR++5KNaj8K8coz0bkp5eTiYZrydmQlzyeBnkm/gkLuRtUc7Enq5JbkMYkaEaSmvX2J1P0tOxp3IbIhY1j8Er18OyHdF2N4FOO56ux/D5f/lV/k4ueriZ/gkj2JyGyXb5FFbnIgsFcsxROXqW4Go+rheC+1Tax46M8sjRgxyZgUIirRPEYdyXVkzy/hdP/AOx/6LpKNeC2dfgnZnZFXxLBdtDBYhPBnk0xP4SXJp6JCW/REhB9zyRjkprWnK7k4/6Z/KV2R3W5P+HTX0vI6OIj4ZL1FjKHnnwUlHiK8+5xeFxTx2cRngnuNE+SXJdHDV6YFejVuyUowiWWYbkir1E3n9xokelP25vBpZgyZNRrFqkacj22IRbXc4h+B9GGKBpGacySOFaiox9jiX8KQ+UZOLyiyessQxMTFYSmh9uSLI6ZsRuaSvCaNiDSl2HPYpuw1k9auXgq+lc9EfYdVf8Aih01f4Ilw9X+KNKre1cScpOxNnkbGTbJPcS5Poph8RKRCX3Ncp+exqxJCy9yE64rL3NdkvJoXkbXbBk1G5gwYMEVhDzGRXFM7HFJR879KR45M4avLc/YTwZbH0SJrkjbksct2iUJyWMGw5+w+UHI1PJqwa8E+IlLZHDf2YfjqZNFmx6iJSepSNawTeexjfm+it4JSyIjLBq1WbFepdiJ3ZOW5uaDBRU7JlvCLuj0kOmeMpcoy2ySep5KMa0mXadBN5k+myvRLlJ8q1prS5voYySMc1yQp4OKq04kns+iLeTL9jUbe5DT4OH/ALUPx0sZIsjk0Ikjts+WN+qEdzShmWbvG5XDBF43G8n7DGRQ2O3cbODsUZtPzy4iCW5UvgRxtSxqS5sfETcPif4H03V6k0TzFtcuHr12Iq4edhPhNKb1dhFnfofJoa553PPJI2ksFlbg+hSlygqzTHwcN/ah+OljJEyRtqH8UcPuhzMokxvogjdD7kYsr28GlaTGmRLySl4Qomw2KLfZH8vd/iQdirWTGqPxGqMdi5aqpfgjUaY1/kvXklWtOSXTbDycbV+9f75fwvhlo1NCil2OMntpX+yuPeXsRpnPc9KuuOXuWS1SyZ54MGB8kZM8v/kT4f8AxGtLEiESVFq8Hoz9iFb9jh/7celjJEiRIuXaaJb9SRBYJEVmQlyqlgm04Fj2ILybEpZNL9jhZQ04xuO1LwTvSISUlsXx7NG2jAmln3JPyTs1SRfLwPpZxMf6c0VQ12JEPgSjEXYlw79VuXYlHbTA3ilE4iz9q7DZu3glVOHdcmekOt4Y0YMdEuwpYyTeZMyV2uMkTxOqOf8ARsmQ2XYpeY9TGSJEiK1Q7l1Lh+OjAokVuftJPYq78ksmGiMmvAkte/YdbjvHdG7ZGPuSek1uMsohxq/eiXExe0RXaXsW3ylFI1vydpljlg9JbSLG2+u/95wPDZTm9iVTzBjbXgunlieC2we5KEVEemLU/sVS9SLcl2LKpr4tOx5PHK1eTBoZKOGaduWS2WFjo4O1W0aH3iaYxR8TOHzo6mMkSJFMdTkib7wkW8PpkememKOOSPBMo7mkjFsSMi2IXYexKlTxKHfyWT5QjqkkWw9OWCKWCSXsRixp+w4Pvgsm84FN4Y+pji5S7CqSUEcTY4uMUV3p9y6X9RkI6ngmsSeSPctbewlKyK+xVohHBderE4RPTQ1pSGPtgWx6nJ409uUnhZG89HCW+navZlq7M1nDPMepjJEhlMtNpxdWqCmu48ygsolHHPQYNWCTKlgW4moo1N9jMosyms8q5OGCyNVq9mWQcJNFMnp0nE1bKWfBBrQQhKYl6cOxFSkzi3JLOrZI3eWYHFaU0NdS7ko7HEWarhMvUsRkUz+JHFL+qxV479xx0ZZvowXfDhZK5fEOQpJppsUfLJS3HIiLknHLyWT1Pq4a31aI/YdeexwyxFr79TGMkSOzK7nFlk3N5JIaIrlIbIbsiLfBhryRXuOLwdipZ/0Si4veXflbU7ZZiYUUS+KKTPh7IhdjZIstT2PXhHY4u5yePBBPRg2wTW2w61pzkwtLZGKY+UpqIrczgTtSyS7kO5f/AGI/kTwyc9c8l83jJDLj8XkttlCWlEn6kNfldyKlLsj+XklmcjTBvGoWGmk+xKainGP/AHkuTLrMvC6/4bbpt0PsyT9ObXgpxpT9+pjGSJDIfQMfLGOU2NlccIRB9yUtyEsmceTRqTwRUoqWxCOfizyg3vgcZ+xLVqiTVUV9W5GWplVWlZa3L5byFBuSz2JTbzgg90hwaf2Y4+xF42Y2oyRKNc8YGiUm2b5J2ymYZjCLbNUIIS3KeDhpWrucbWkkkNv4V7F/xaZFcnhw9ymbg8Ftjk+5pcnscPtFokoKTJZ0diKFWl3OKnFbR+RCTjJNFLjZGMvdCgobLrZIkSGVvuuUKpWPCJ8M4/8A2Nal37EngwJCPHLSfTuj15i4l+5His91khZX+2J6dbEsdkTU9WYl09sOO5pz4PTnFpxRba6qsS3kxyw22a5TIRbyVRetE/peCUWlqHuxLUNNMUjGB7IS07sTWXIbzyrliWSq1NHESjknHcn2wL4ZbG7HJZ2K38RDaLFHZkk1GOTUi29pYJam/k/w2zNOPZkuy6mMZIkMj9R3OHjFQUsb4JYLoaJ58Mt7J8kLnljgzdCWpktpMon8QroCw9+TUJ6sEKlA2Lnrsk/YnJPCR2h+SNfw9yx6Ip/csliGSfxVP8cqVmxItq7MnSvB/8QAKhABAAICAgICAgIDAAMBAQAAAQARITEQQVFhIHEwgZGhQLHBUNHh8PH/2gAIAQEAAT8h4ZvTjKH9RtBNeIi+iISDesRK8J689eevPXnrz156s9WPiz1Z6MPHjwu61Alf4pdCR4RKeIek9XAR6SvAn0SvFLTRPQT1kfESvieiUeJR4lHiUQeEFYwi4H+KCpP44TGDknrnpJ6SetPWnrJ609ZPXPVPVPVPXPTPTPRPRPRDwEILUqz/AAckIokONAmsQjqeieqeqXzgfJHIkb91MGzExfUMv5vJP225abLLSEh41LhHz8Mp2SnipUfjQHxDC7hvmA7i5cuW8L+Ny5cv4kzze+GW7Jd+4/Ejr7+BX3zM9wXYdRCzx+S5PKRJW2YOBLhUUiIvK2S0uupriR+Y1Mdn6gDcB8AiIdPyuXL/AAXxccqalVzkT+NDnm+XTenAqa9D3ABO5hmoH4qFsVUwfAFMPMbca5y1UNhcyUPuGuCRUr43r3P75ZfslZPe/wDDJSkvr38LD7JU/L+4Q0hz+uMzcmoSvcRnZ+Fa3GcupuWTcKIRRllWMefKmaSyg3UReCVbmLFfnUphUe5/LpEp/wANTAEM3kRmR+P9yGn1P9MXMcmEJ3xgfgsai8XwcZ8cWjnuJ74JXzEgcQysgVjGPL8DSUkEWaHU0iX6ay/w7loYOPHOOfOyH2Q1Ha+ptFM4b1CZaY5f6iV8q0WdcEBDhpCQ8M8ldQYO8WpBKgke/DUqPyRAJDcddy78/wCIqlMrK0gS7jNeD8Dcp3Fz9x3wwibIRdu5hUBH4LLOQOCacjDAIkTge0HuPyR4afSNRlSOokSV8nAvqFY+YguuvlcuX+NcSVvn2x+AlIp6IaXRLlXvlRC8twRLmPsofg6OA4uHNw4EZUIjDwzx2CqwwtI5lLnjjbR1jnwvFUrn1Ayi08WTHt8r/Bf4CV8AJil7zvVBdOOjgQCGiGUuXcXwUyhk1Gep4AkrncmvgSwlsCAm0shbqLHalBpjQqFtQT9OVVFnZgjJOs04mnIpE5yNnT6g2+GN/Af4ZDkF+RiDcIyZY/FUJkht77hYtNRsjvl8Llwj4QIHCuF2iK6bj9wyWdS95gLjiiXbwISMaxKQ0l7MPcETkEnWZgfZZMGPwmZmZlMplMplSpUrmpUqVA7p4zxz6jC38K4GGhruAUwzSs9nA4izL4IsI0rEvhRqeqAEfWA8T6QYqFSb8KSsRIDPMR9pcVKt8LiPGfit/iZb6ZYeHUqVxUqJ/h2lpb8Kj9x/qCJjTLSWOzifgQO+DyiTCjXahDUJYYr8QHHhg8CcEwhxUQlfY8EVJcuXL/8AABn9cPiYHkhvo7PkIF8DPmUup5OOpUHqV8nh4fgm+ZIwmRaZbh4WM6+J/wDAEObf9YtllcPBubTLhwazBNI22Uw4eT82MeUcxRwkRnmw3BJGz3qMVs/yqg1mP4jCEcPXxIZagBHyZRCHLGJE+Dwk0myDleDSXzS+Hc6+njMFZN/42x8ahuopYklwn4WO34E1Q1HZKswgQ4bjK4SJyx4GJXKInA5zvm/sGuO7QmSNv8mdRXvXc3Miaip/A/GGSCwRD7yqUEPk8VH4VKjxpKxiC7lzVzbDfLkOoP7FCpCiYdRkuH/H3ZMs3F2dmobHEWX8mb8kFS2KgwQIfB+DH4rF4jcsDh1+1l9kbnn4/bNw8ZwwZWx01ESMf8cqZfuu5uYtqKH8BRj4cjYmQx7nUIQ+Cly+F8H4VUx8acxG4oqzDNTvMSD471jqXloYs3KqWG4/4W/yuJh+4v8At1Nw/gFk1xYqBiGIcmpu3MR7j54xR4Qms1F8uMuXMDM93GqU4g9kOZlhDfx1KgnCGM7l2E2D9nxplMplSvw7PydMrPDh4wrTB389HgYSKH+pVmHAvmJa5fEGvMd7z0x8RN9TPi4xKmYPG+f6JVKAwPUSag98Zbi/KqJtMhiVzTKZaVQckpD03CM3JMrT3K/wNX5uyVnk3AZRUkcPxVFaO2eaYj9qoRZJpwEFFojp79QwsR71KE7yeHBGa5hg4JnKZiTZxkKLcvnlVsyxqStJG3MS+SGwcY2TZ+Ny4NSCGzshy2oYjr8av8gVMzbXDr/uDv4EM/bVwAxqxVZmWsigcdNmM4zBCNjwn6GTcuv9kv5Klgsj3MMxZHfI0Q0M3Y7uN2i+ZgRHuG2gtLDogOCS3LGdQoQVyX8Q8CI32QGBnGUWw2/Ob/gTDwIQR0x0UFPP9fLIOpptmpmpww0zrwqUj4mpib2EbF3F5AOrhLNo0M4gBfUXCxc2sWFIzDZrHFcsGZ02uCdcFHJnkiJiNrEUOAKi/wAF9P3ABsdwYjREynpPT+bv+BdTf/DjCNwbOcU8M7uK/wBzBIDlKG2sPktNgnTjqKWbDzEG4GopYXXplTVNJGJqSqqAR2ZQ91hQTThlgymAgxTqe+eyX7Z0sEghw/Feeu4dAcuEQdHUcr8v/X4DfBAgE4zhpgp5tN2pepldmb0IJuGM4EqWTxpViD6S6ghIhqNaog1UgcBEguZ44Y8S2EkJBzNX4/7ghYby4EItvpiv8g/7cvydkxvfAWH9RRVvnoV2QUn2TBpMzCYp/smvA4YCdGN7ncTrIZ1CKIQluRvKpihK4TiMAge5U38a0QDGcMGFB8NREH8b+EdMw3XCn8pgp+4e+bwvgIcGbpLiLRHY4EqVGElMphAlSvhpDMeUMrl5cu1Sja8GP4yyTaRZX9zMLDc1+JwH4tTPqiUN/wD1lEpioddSibSkyPLmhaBCKCNe4Ic7kJXFlipUJZKcR5WQTkCXcRwxcRzWee/csRBQ/jrpfpl2GXlktU/fNSpXxdJXn8OkvXjMx2p42Q6e+p0O5WeCkfzSrQrW2S2qWUi4EIRIxhFUZbagLKm0rHAOIUxl1LzguKOXKFxChEodZJjMvCEltnjv8VSmYzZNSn7hUtYdzLhl+HWHASv4vLqKX3iVLyQsjYzanBX9x3KsDd5Q4zXuUEO0hqWKzgQhLi8xTM8rEKgSkpwOEDUO8vwElI741Gu5jHguOsOSKsTLmpXFfESE3CJ4Q4OETDGa/DVx3KAfhqGCofJPvcartCH9RoX9zswkjSMaYD0zQ+ll59zIOJgjhxceA0rlpnUDYZfcVBGyHAMIStcJrlC7cNB5BAqeo1JFioVMzCDCVTmH4wMAIP2RCN95NRKafn0l+ijCV51PF81ifWJmlc0y05szfN4eh6EEbeEStCSiY4pcWMLMctUSpyE1CR88d0yoS641HV6WBilPuA07OPqiEFYZMktmj+GCXED+9HrlvaJdvwNb13BQ8MyEwH9/PpLMTFN+JWhMxlAsRPjtMDLg+5gxal2P1xqTw7mmYiLEUuPJUXsiXmAEIxiVHMW1iPrPIlB3Gjcy0biu5W/HAsUe3rEFytD5jxLPBfhXqWkolAs/gz1x1MQwQnmMy6+XWUR1ZOgOB2wPiMqE8EcfC0PUMjgjuLU2P3EwhzxVmbSqz3KA8DFiqK7zLA5fMBjJR3GSfEt6iwcxCJftieGUZ2QJDLgyN8Fe046seJRfXwdMvslxF3vH1MsafndZlR5NwRq934JZAM7FPMKtXCcJn8yeUnhiMOEOb1yvadpvGK49s6TFvrglB5g5moZOTibXYY4UUk4W02bJfzGBzQeEg2yLvojqWlCkjbogo4CN0upBX0+Lwx5w3HqjmVFEFsAQo9sr6j1N9QfwQX2I7jAffy3+Hkj1yOrFiEm+Ife5uGHiRVUyynzJvNs7SJUevCUcep2lQLAwjBmQxoPWEOpSA9RZrjcQUpGoiARMHARjDKxhS8mesxFO3Ecrwq43nUXtlRnrULzEIaEh1uA6GdsjlIc/3KGFyPfy3+IoRxInWoPYPHoJaljqv1MllcDUlF7elTBj3GOiXibTM8Ls4dTCiw5qIZhARYlHDO4Q1CMIuNVmJMP7QAjxCWHflKCW3rh1HUJMh0KiRtXfiKFlClCmNUs1T7g9qivtyIbleTiK3ybfMZAMU2h49/CFnBqSkhpr3LSk8xckIE3EO5w2fDGLmo3FFxNxvKZVFKyXTyFZ+oatBUZhixQAJevUs+074BiUBKu/BNAZmWxqZVy13NWxxLPQrzHTH3UdE+pfafqL5uFirfnt+HMJe6WyuLiVN/8AlQVMUXgv8AOvAafZKlQi+DyEfHF4xm0zw0gVmJ/L6+L0qJYR+4bgWx9Soy1U1DKhUYWSiyNc9e59gRVyXMzQN+DNd0s7lnKhfM2/EHwZkhgh4IsfTNj1Kz8kOPxd8lX+yCX98XB+BiQRCJwMVE3yzp7YSP3dwU4aZhENI5HUZDvjEWJLoEwoU7JaHjshEVYXUpzEEGFsBY9MSl7zNTuaJhIIbB+5dIuXSZ+Tb8IfFACf2xFPskbr7mj9TMROe4x4Iy//ANZ5dQtBig8vBmOBkGbGfxwdQBQYgUcxtnY9yomfMG+DcbT7qJzAlOpG/wD1i2uJsnVWXRXUpUoHhGiK6J7MczygbO5jMKby+oocnw2/NnufU80RihusRKCaxLoZuTGHUHHhEgtWuCX2Tb7gp8kXCyDwDLixQiG0TZqgdlzWEJ1wVcFyMEtKcuott85LYpjg7mGBIaAEe402/wDnGNacQe0doBAAJWKn7MMuWVqKXuBepUZ14lgqvKVAc7flOQTDPVS6o6iXnVTNOKvhEY64JuX+0fzL18sIafZEJCZ5OQgl3RcN/ENlLgXXCuL+BFYzylJGv1cjJMwwH9zRaFg2XmCU/wDOAG4Vh4H7jj21XAeCUSqiwZ1LWCZbYplkHCbgbEn7bUxB/cwjg7+Dv5q48P6gNuYknhLy/DBSx1NBw68OuSdRpDxAepsUh0GDcyngaiXxht5gtEIqVGXFjwwO+LDkqIralxPBzsTMDFza6e46ij5lqUxfuOBcFQacTHU9HAL3Y3NGSxvcOJuL1RiXqTzLQWhKMXUwzCzJjCRXyR38NocnwCxPUIKtbOpYB3E/dB/LwYp7ndTY4dRhtqEjDtQ2M0qorSb1NqghSBUOARXNxZceHRLXjicSCUxEO+CGYzMSd5G5hNB4XqGuLiGoC7jXJUTnsly2PxELbDMNssABe7TAG4oVoSZJXiMHKBVpLnRGY/j4bw1CD4XL9aCVjxRL6MqezcFgcuZ/aizw7JtNCHHcZE7h22Kvp8xFVuu4qkX3A8RFcXFjwMMCSmKpcZAss1ON2t8ilk7CnqY+nKlg5dBBcE8S0n7MFZ77gXMfqOkWIJFUIZXylZFvXiYASvSmZQqepYrSlwlgMHDs+ca5uZWpZWzbC0MfAbvEqI8w7hDSb/GQiuOGDVzWUOxhd/UC4YHCy48gyBDl7uMCaIrH84pa+BFOfEZRpDwSpiMuYKlnVwYVGvAQKoldWeYo5r1FcKIY1BRqPa5de4tdYldNPM7kccTXLBv8FBw8FZMDLk+o7CeERIbsuWLif0JoTtMmOn3DTNPiMEQR7IVHTcYK+EuXF5EjuI6iM26IxjELX5UUjSyFsEt9BCBgIBRxaC31EImiUUM3xi7rMI7uBPBYB5p3uhrk2maUETTNRYJ3MR+48RsaphNkyy5fChBly2UpahCEHUe71LnW6XMWzhC8qEw9dDNOJunCwH1HXxNQmMP4jJA+U6uLsIKsExlxUtjuPyOkKG8ywRvWPHzCN0IhmD5QUniNo8p1RBk6izBDfuEkBUo8VEt11Al0qDXmZiKrcVi74YgH1qWmG4uKep6XCmL4WymDgVKIHBv6x5yyolwmEQhdmo1mCEL7Bg4BdDjBgh+JuBO5+9ng+bC6x6P8JsdRz91w/JZgrIQHmDRa8sZXGqiCe5cRKrBMTpbg/QgOn7nbY6PMaqn3MW2fMM1V+5n1yXVpjEF5PcT7SsHmUvZLk7JwrKODioGIGY6q2wsik/SYl2lu3HEWrOLgFPolQPe/gW2+L8esYNfV4I8lHJfTkoGvqP2o6A8wmp1w/IjYJ2xiX9RHLA4oIEHgeYqWw/mGAcQLZ/RGk8zuvmWjLhsATPdZn+14uZQEAz+zuFsa7iVX3C7+I4MOF0SzswuUzBMDuXHYsgoMgitUekFb6DXHVpnozNjyTKnji/EME3lq9OCPNbMaFipBGS0N6IKNybjvhh8CE1FwYr5WU1DEuUgBbEfBA7fpNDF+dy2fpO++TDxbHmdcYgqj1tromqhFdq6jOdeJYVdygFsYikfAOBmXUGZD7gByGdXP+RwPRiX3vGpsBZh7nXw7JhfLRjYj1MH6ir7cyd8Bkjgo2n2dOD4nxsDKLUWCokfYT91wzDg/AskeITYJfqx5izf0YIgZoBit7OMwJRDA/cVtMsvRj3XIL+glnBIw4pLzAUy7Zf64Gcd4xN9+2UxUB8DgxBuEJ7lYKrKvU9JgDBVFjoGZv6Xcd9PTC3B4eZk6Jludyr+jB3FsuPIQNvcvL/pPVg4HxCu+BSojbDoGhUsGMXe/mr4dOVghiX1LWCV3MsE0MOpiHMEN1L8sSpgy+EW9ZblpghlWj6mwA9wGZ4EjuFUsgvcN/Dk4OLqXxtoml9S61jKXKxFNYcu6ES+nqaldpahT2ESd8dTb/MVgw7h4OF4qaQ3epY4GoR5FM7hbIIRL0LmZsbfcA/iUupUeHkIRjDc/2TaOfuJSjCtWEWoGmIH+IIjRWjRLkAzPNe2Ba1CqFEVPJBqEcVCTIfcU0zujdTBNRoMWzLaiWn3fIQcMcFaBUitIiltY8qKyOEqK1k/mXJw9p+iWkGAkTGaly/CDiO4O48GXDc9nEst6LHYQ+Dpw5kMStI/uVBL1ZLVWQAq6qW7/AK47juG4w2TXDDcwh7i2I1bueYXUsWzJdQYLaKlCqC0bRE0m/wDmCdO8aFcSx8SWE/UR1Bep48fUrotPcK9wMSlvfPhLhxUcFB9EyDK4+pf0exMFSoPX/IdV2uvEIE8o6jxueBD9uHfGkcM052ixUzi5ekOHiODfHS9LZ+oGrTNzpwKidvhyyrPxBNo7huMF1m1RjEwSlSCoGpST2UQqGjiJAEU7iJf4gTF2RzTGC10Q+wPMai7njhNCNxQptdRyiv4mZpvUTmcSZFI7Zd/E4qJSAbYlXELIZ49kzyidzIPc3nETt4nsJlxiwlTQnbO+NbhqPHiTZtCNJlNs+hnJ5zxMmG8TBiA+h+4YMjlfbCLOoMw3w7jqKm47bl8UkBV88JgToTAQDebcHBwRs28C1upmzMnSKU0ai1Ft1BUbMtRXPFUxvSYP2fMVfqZ42+JdWuiYXxwchF4XT1nM1Fm/U6hO2ekUsF3csIsb4OuGXAWJqGfMvYdDcUuCg8y/owDwQ8kuTGZAJcfg0VStb7MVXD+RHv0wj1ydxjpLi8ZrhdFS9/UGFgqWJC37QhL5dSpYRbHdyrHcWxjoKmIa7YC8+ZvAct9dwwyU7UUvSK7fgXB5CAZz/U9gMavSYhDZSVtQhbiy6tTNzqLEDSx3FWcVcGPbRCjhjrfiKypaU5pqOkpphRVE/wDjpVZ4SCvcX6pj+2tI9Nay1EQgwmhItrqZnwdfB0RnabgyqlRVoQnLCwFAMF+X2lySwZawUNEWV5mPEWwY4Ui7rD9b3FuWGjd4lYQWmJnRNU7m6xO58BxweEH+CI8AUlRDn2RvdYDdhjcLCXFgByRLX1iPqGIX9EZtKUZRVbGE+hDo9YjDBmiMm5akWbv3GtO4FIanNS1G4msy5tZg63Muxt+KVAxMJ9Yxd/qZphDqbOK+AHwQyEsXiWd8QS1i8yhWBXNyjMeZSWwcIrWJYxUs1biYBOtEg4KzcCBxfIsDIZWoBI7LmEvFSuaIi7uOx7ZSy9C820TxoMnN1iMrXkiRUuLLQGUFnNu8Q4Wl3Ge8GTpgHipsmWEf3P8A1JL3Qgvpmc4hcVfDB5qDhdUlFV61KxmJXFEYonAKhBve48GIlu66moly8nMCOoPdaHFz0QSBO4gjNrl6MaiXULgiLAz5niOWp4fEN1FdysASxHbAx0qEWre+BCEGQ+pYQU8eQYDuVMRCp4iSx0yiddT2iLBLBmJiXpcRWH7l9MH1MlWEEU4SjV44SKbER/6p/wDERxLJsryQjq6/mLpDur6ggCozFJmVDxcqXFYoAS16RVTeP5OK6i1LTWrB/wC4lXAeiA7XBlDKkt1wtxxmUEKj3MxluJgauJG3aPJwVSjNo7BiEdm47jxIRgxw6jPMHwjUyZlZ4ILIncAbghRiXKwYk2YnbOIugFcvl8YR5eJozolG96hOxDYI1qfuHbGdx5jGG5cslqBl2fqoxXw1NsmIBhKjKlKW8QgQGjcBY44ry0EpGbTqKq7jejZSrNGIt6O/g9XXTFK4LuUf4t4IOLi8DZw2lssqCiLFUuYx7ioR8PTFl8AoTyIl/MycwwYR23pCPDwvwOEs1PXEWfqi3cMkSo9sW2XMTcli9e5cdwlQWyrqWLrhD0lI2WUq9pm4upZWCPlXSblATe4J9MCazphfCT7mwFQ9vn4i7vqWjsjGwLCKYKDuF9tTJgzrjJwudOBzCVwt4mGVauI3HXng4865Q5ai3MK+SPD8CGCBRenEN32ExU70wsahBLeGE7oxUOpiMWLsDEuB0wgI7lvigneZrbiIsTpGCacRXmtTS7RCdtVAgB3lgLITa0xcQE0BFn4E6sxHEEc5bgVCoZb7i06oGDpYUnY79y0eIxczHCMUzAjwqYAWWlOGKIguDduLQwGC0dypdXUCczg/ymH1fB+AMHBejiIy7jct5q5og0YMcBgh7mk6lgIL7wEYxLeILGuK79xbKgRRcv0K97UKWPUMRCQBurlJXRFfJCCxlnpT7zn19LY+pYEkLlZDLdS9uwmaYIM9Sk7oFTKWrcElnE8FS7uXUpH1EtkERbvTEGtUr0wqU3cFl5Spfgx5RDBMbTxG1qGVwJmGYEQ/TjG1CaUW1MS2J/xSHTVpk7RPKvENJtxgH7ZgkqO6poZc6YW4NMPhROw0RRfxHiv8GWLycQV1TAkpqwlVio+kS6GBWIKXcNXL6QrIpL9UUGhwxSszA1UE6nVMNcHnK3NKmA77+AnRV+oXLuLrwQAXDhjHiOBeHnCrI2F6jMS0YASsTeAMKCdZr9QRTeIae5sXqXfSBHPBEuqyOYqy/mhdy1vdStaibNogusE7eEG5L6lxaGCG/iRYjLyYNMBHE9wypvL+ISW6iA2GPSIVig4Iqrnuaoe2PfF8B1FHcEQ+E2xYCHCwEUuLHnKPAygAs3MTUy/vljH4I8aj3ib+kvEsLFlfsl6VAntGjCqXMSkNNwaDF9YRCzcfJpTcvkIuPPED1LBGBuZLjSiUtMTuor4XAuGpVlP3LlfYy1Rmw7+QzWS0eoiI4MEwEsP6l1nmU19yrWyFbcy8DwMW/usyjJ4/pqR86ejzM7ERYLgI6gE1qXNa5eDDctLsUwclmMx1Bwxj8nXQ+5ctlajNYvqWErgVOptxDK9QlXLVEuENTp7jBRcFtBqu1LwD4Qwy6xVFwqiZIwRpIKhIYHLENxCtyhH1ikis3Bqx3DQmjuWe8gzv1CPuClOCssLwrgIXqUV9xpvAmWKxih9ZpFM2bCompIT9RIwDLDAmYAmO9ldwKLXfDGE0lwmPwIOEfT9ywsHDGPIYYYZnbxjlZ5JcG2WQBWZnqEWl9oOLqHbGbFxaUYjksfXFGhyRjvBUtDuWl/VGYCdzmfqPfdi49wqNbfqO9HUdo4WV4yUZEX2S1XieAI4lSxSUoyy666jH6iDUTf3A8QREBLFAcpXhx/oYwGhBplQcCYNVB6VzG4Lf9Ro3s4YjiCW4fZl/BueG4zgds8AXiHLGPHwhxBxr9kbnrZDhM+ECwyjVdxTmDfAapBZSswzEq4UFg1BeEAUQmkdu5YuozwVMIToWBa2lzgrBq+DGFjjEyBgVdeZeKwMv5UJeW48kZVPAmdDCrW4cBtiOCv4EedSupA7fUdrbL7TXqDE3QrLAQtJ5g/fZa7tnSQmG6ikEul/AXKmJXA+TtBwMMVBm1ECVFRiQ4iVjyQD/AAIw5ghAg2OBeBikEsQdSo2XU8dlQHCqGfLM0bYoz4gXakBgqtxxvcWDompVXQmCdzNVjLg2JaF1uHn/xAApEAEAAgICAgICAgIDAQEAAAABABEhMRBBUWEgcYGRMKGx8cHR4UDw/9oACAEBAAE/EH/xp/poW/8AHGF+EssKLxRDEKvIckHVy0EiQcL4n+jn+rh/4c/1cf8AyZ/qZ/rZ/rZ/4WH/AIMrf+GJM/rhk4qUw6MC1rLeU4Ai0mu6y/RgGx+oH1mgl/q4F8/plriDUVP1A3MhCXQk+FENCetPWnrT1EI5MIECsncN/KjKt5powGBM9Plm/wBBH/yJ/quIZ3qz156c9OerPRnoT0p6U9KXYUGnsi9NM5M/16f6tFJX7pDnLNIacd+I+DPQnoS0uDK3o5AeQE/cQPQx9QwVhLJi2s/0zDPAZcsllyyWcThZqb1oCK/M66I2SvAHMGygojQwRoxOxDjuLLloXFAOiJiLioPgRLvKP6iv9Lge2WRADLn6i5aW4rQm+VCPxE5UqEEzemCJfNoSGLGMiGnkixFy3+awS5XveXj/APVFcYZ+0ZUpVPNx+CwZ1BplNGORQjtqw6CK6l3bAeYqSg4ioEYHCAEJvT2QxtAGGMY8ksSp9i4McGqZjKDYch8r86/EYPC+CjKNO5anZh4uAQe5UUN4gubS4bnq6HRCR5pgcdq+sQOzIlAfm9MozL5vi4sZeOIFTMEuAsHxmd7RKd0wYsxV5Y13MQoqOChhd4DVStJXtBB58QIwGqICMJK5TryFduhTBqZhRTGP2P8A43SR2D3CqXBly4wbK2DEc9x+AZjqJ/UJR7jLtqWXafpCm0x9wAUSolMK+LGCb0lo6iABMrMAmVLmoXRDOI26qXZQj5IL4lRKEbWf1iaCja+ZvRmxFRQn64SsY45GoOfQq/EFVYFTBeQgyCUjT/OfCupRYyIkNb1ySfuU1atmL8Ln9VP6qL+uUQueR/qJ2ILiYD1Hdxcv4LMZcEEwSyFoblCAdwEYhKRqHmienhonctcNs1lyl67mqqpQAyqzDFXM3EblfEzjQZRVlQSflQgXQ/8AgOTKJbagKLlBHXBHb3Nlm3wNkCV3LAeiF6IJS06mOmBlJ2iCMETF37EsR+HUCC/lmoyxKzDjvVE8NLCYitwIYyxR1L7cuFJimh5Qka0HE/GDwgZYFeIk3FH4DFmJYkecpA/8xGhvT+J/itExRcMMMnRjMF8RG/gj3Hl+BuKkNNvB/SYsoNZij0l3OlUo+GXg4rPZFr2fFUMsvBwJcwSKahKuAKRDTAeZ5BSWNEZXJKJlBxClVC1CnxHOhHEVpOHS5kuozqYUCO8LCRPhi3uteYihYEYITJv6PFy+L5CL+dy4spqKJCCoyIQZZeYsy4iOpT4lO4+4oOVhWJvyWLwoxEVvowEMiRds/wBMoz8BWArBl5j0JSC/iF3CkI3EVRGZSWIFILYTGNmDyYN1EKWbysw/5MRRh7lKrmidyjTcpRTFHTPRGWHkt7pYD5cU8jK8vP8AXFvC4r8My+Fy5bBly+TIlFZlLcF24J4f/cC4tX6cKP19sOEA1CfePUmLkZeVOgRn5IJlwOLWvZGVcMsjABUWioty4HviXanliIUpfGmRCmqlKCiYx9j3BSd6qHpbd+p5yWqJsFRTh/EZlDUcRUa3iUYjx4tym5SxBjBnV+M+4OSY2K8wtr1H+K+b4vgYo5BhuI9yx+FHiXRCbKYCWTEyxW/AaYtwWyGmg4PuK0Y7Xn1CIKDSRxxmME7jNmAJ0wy28I7G4WKGDjrZGwGheaATFMqRxTnyzEyY9UTRb8RVGvUKKqZZ4lZg1qIsJKIgNx5MEV9wAgmeYo8bAf8ABLwHYR++N/UXlmZbLZmVFQHwBErwcFCKlRgERw2qKxQUGpq8RcquYvKmUOK2bWuD5JYOCxIgbnSn7I6Mv4DLFXEIosIEsss9RVMLcNCdwgHTxUwiB1qEBUhHEFgMuMSsoqUmqE9UqRaTMGHzABLfZC6k8S2byZQsLgw8V96wn7gmrSDtS8KQAhmuKeJSUSkpCGAUfxnDy/CmC/C2vhXhgFrT9oHUITdFyXUrZjteCXArL1wZMFHRPIiqY9AZdEBsoCqAqU8DJ2lQLa8JwkSHMCBdwFS4zKxBjuJElp0IysOkjHNhhBE1xXLcENQ1LPisuXBgwZcuXFIsuV/J1MZCK4LAiIfYzDteLtjRO4NtQBwbyxHQBnxLwZIYlumVBbMYwIGJUjNTCvEbirieOGDbFl8x1CUw1NGG2RSEIFLNiZR8H3Ka2epeAPuYj+N0iy5cuWy5fJCHNy/g/wAa8BC9P3BwUCJA3NuMBAtuoLRdfuIlhQi1B+WZCZYACVMcjkikOZW/gsdcomVzAeIMywsI1rmkhoaTJCLawGFXpMwp8DKAPScXw/xHBwvw281BKBBDZizVRn5PjcXgh5NeYdx3wTWpakWkMbYWo1RmPAZTEWlGoa43LeGb8gxjfBQTFI0QbgbhMKtQUENkNR2L1CCImwEl95NRkxPCPL/EcXwvwy+ERPqdKRbEyhWe550IlPwYx40Yag9cE6ygXmWD+ZTaLcUe4SFMZZwzwCMJwUcmWEjLIKw4h3MHAYETSGuM8ef5IIDs3CLxHZGY8uPTHh/mZfOZjzXMf6d9GCARsSKodxMqGGd8U8P3zSpuqO+CWWRyDqj7YJL2Ib1mjMqIbgEuoN9RjBKjBxNTtiXERgSoS0FszvCbeMEGWZfT8Bv6VcUD0YvNEl0IMvcs3scPk5X8X53Fjzo+mPw+9mdP+qB7BgwbEQXARUtlx4YVIEtUEeBbEo1HEN2EN8+pkFIXAhKCLEYzHA4jKgYY0QRzMiwy1Icox21zqaim0QpWH1Cv6GYLZDXFxRW7KEAbCwxEfphUlb0CukaeQy/jfwPl/hY82yj8RbXJr6MEAnZiYIqWY6eHl4SIPEKrHFRiUCNn62fbAMZrFiUCE9RAOFjCVuZzLgMuVDL1QEsLcy5nf1j5H2us0wmQ2vQRRsqyG34XLR7SwyX6ZS7CP4GHmBFHmpcv4XB+GZmUwIM/r5F7yCbc1MOu8l7j1hIxEUjy8nC1NMq2UM2FVW0TGjKQrV8CYlfuC0Z4QvNWVRrUuIKzamB8GaUZ5UYcYaEPZHGH7I0ziF6ssGLZRV+qEw2QFYkabgOheH5AqEaRmIbX7hsWBBNP3wNUm+MynxDwclfzwOAlEomOX+j5V50y+rE3Koc+fTK2kfg8WGltwGUFeYiE1ZB8hYQMRbSsP+WIapc5Lhhk7WxqMUhc/YMF2QOtDDDb4R6lYJEwxklumYEEgolw1RKAbWOHbo7hKPFBPURiRDdSDJsQ/hsvSmU/AhViQRgGIakC1sMkKh2VkgsGTYOpQ+NkXjvgeHheFUU+VbLevXHbMY+4ZeRqBQeWUuI1vPhWLvVuHWiVAjmEM6GAuO1goJ2JfdQr9EYq7uOgQMJRk6IADQal4ss7EutJhixIaIMZ0TASIURUINRDzNlKPbA620HiK/jLqplTqqGgy7ZbZRPYbjW2LlDkhtBielmOVqPBWgSIBRkeTxkghYPZHRZufUtlstlvzIuLL4/vETHFfDC9MyZ0fnjUPqcYOVllA24gk1Wfd9wUrVQioCr1ZLfdx0vcZH3L0SsRQBKUEM8C04KZff8AtmYbaEdaLGeAEb4c2LQFnxUBc0xLMdx1FJcxoENIAj0pZgUNPqJ98FcyoajrBSiXUiL2Sn+HtPjiSzo/vlBFv4Mh9nnh5F52OyEMDsIlC0w+OX+C5fLr7SMT42kxvYjAHdmfuA3YUw1sdfUw3JEHv/LE+wf1DGkK/wAuW4aLVSluO27pggJ400iVtbYJ2uie1XkYSKQLvt2q6DBN2YEvl1lRg7GXXGUDcw2YBKHCqAgQUlABgqwhL1wStAmKFwhZwLj2EBLIt/I0+OnmWyFpMCyJLh0HZtv8x/m4Y8POdUzs+4ZgP/mJeeSI3mVG9+D+oOxR+hDa9kfnRhAhyggR9FMK2iaQRpikZlRhR4HqLlI5QJJBTCsdm3LIqUNz2xBrHLtjTdUNZU7WC7tCYiDL1FieyEtOo4hFJI9LgrvB8vCihFJilS+n+IEG+qPt0H2hgVWtoVOOn4n8HZ4JHljFQYhfSTSElkTcF/JkynHiKzDo+tMayyNR03Fc7gWyNoHUpNG4dfUEzhbzSTUpNTJCs/rlTBcJxRRmJm7AUHThGWBrjrIQSCOCAsCRIpB8QYVQssMVWH8eXqrSVgvCpMcnQkUFJ/FfGjg/A84DxEvuSuN83+UFfBiIoxbg7I8daQ/Kn3kaHsRSAxEM0/MaZdwin0QQNypfNqC3ltUK7WVm0XKgYBVclxiYiwlWCmRlUNEohwTmK7lLVGsxwDXT/GZZW59SsMtTPaOmaFW5CTpGqly+b4v4f3nl+Y1aehnudXqjFQeTWXtOCOuX/AY1wTZ9MZswjKwRvpZePU2IIQyEfxHwcXp4TwJdYFQi4guHBjshrU0kUJYs740Rj3L+SMj7jrgaR5UnzuLLlxnTbT4lhaCYYSpoYhmg0PMRSP8ADU1HuPD8r7iieymAV2GXfS/UJwCJmAYzbUZeoClx5dSpOBoZur4yFo/8Ehq9cDwIy6jHUIgGEipijViMLdMWpmMoMcBw8QJpjiiSoSoqboTphibMY06SLbYfaeGIxwvL8bjKCGR89MJiz2RUwOhwDLQfCuDgxbAY4Y8vDEqOxlrOXZ9Mx/sQrix77I3pQLUQE0DLEMPvCqgK9HpjRbAXGk0QipOy09lEpJwcBcEYx2W7JjfcEEojqlAIO5ZmrFENGCWgCSgNLghDrkYWupnqoXUrDlKqr2SsdOxUdeUrSLzfwzMy0AbIgoNzzAAXAzFAsFCPuhiXLg8PNzR9T/3AS9YYiR+JlAymupEibCX8bUtZUoX6ZcN4ScSMZ0bl6YBYYl4R1fGAm1Wr6eBQhFwEIDDJ9SsYgzOrKzmE5woOGMYsYukKpcpSOWIt9scRYAhLpMrTcZyzlCHUcyiYuyEFCQs0IyqnimX4VmEAfBgkDiZmrceYF/slzzV6gMacPr+DT6RiVDTE30nzGMmvk8IU5Ef1DD0DPVsiI09LFLzDSu0v6I4PmMD3RR9iJLQ5p5iPe8Zh1FNlNJ+5YIKEcKgQgBBhhWUHMZTqKJUqEKqtiGCT7JljPcyNgFNDbtcwEYZJhizWiDSYk/7hqUEYASpmhJseoZghOVr8xVQpi76mTnuXLly+XSyMe+XqiSgV50VMCcPwJ/jhlvs8Rv8AUfEVGvR6Z2QiYT5Asma7sSuvsSIuoJQum/xGta1bWZP4gbfMoP1ANhTasncIzGRUp/YG4VnKQJhhOGNTMjxMiNCO1Mw0cA8NxDGIZSF1Vh6jVMKMNSIqcCUinUbM0H9REtLDRiqdViAYeZW82SyBsdQJV1PtG8MGWLIaktz+r+AuFvgTKt6pdDYXMN0P9o/Em/0gD7R0kCNDvD4iR9u/xT1rHKSPwxRHfbGegJsTDR9xOZkT+5WG+2Yo9NSz8sBbAwlppsgC2WCY4Y8AG57JsApW7O2ACI64VhFRHxTF7JuXwqusc1MvLgnbhAYA4xkynEzUJY+wYYY3WBctNSgTP9bLYkFKe5V3suIIAS55IaqAyR+Dy45yA7glZ8H+5vMVcPwefoR0DqBliQ4X2dMQREEZgBA+rp5nbAVTzoirzpt+447MEZidk8DUEXw1eiVJMJEsVwYDpkuHDZqUlYeyyQvblUQuCNkOog+4hxDBxgotVjekgTmqjK3leyrzFhqiFdjMAlhmViAh0lhpraytMAlHQXkmL+0SlIRKZWQDSV5gmXn3IdJiOWSa5eRIGxi3Xrg3TxZCMFBj8dz6jFCZ0aZQq9fYhEolIN99yz+q7lmKmIZgWyWQfwCanuQmgQb9bDr4ySi/EIh7t/qAe8CD7kaKxtOxBad4MEiOA1EvC98H7SgDtzNHUdMoT9lkKcEAYwmGCkCMNMBjs23glukvcYxFOIiQ4PUBngllzKIxTQLTxFZ9XDc8kYwZKQzCEWxhqdNDvbIh3IYXFohwGMBFOmMfj4AVMwywBvDj8dH0RajLRsYGDaCWEJB7+pexsgLXfkmRE+IvQPxHult9SmN0+CALtXM4xv8ApiF7x/iXvtlzyEp6CX48LMDHiUZLUzUxwGxLmnIVzedFHE9E2wlKpg1UwWHuO7slZKMXLtXiLgqLujKcu4KJVFNpbFzB1swiIdSEDDZaL8DLiUIbzBzCSGbm10ZfUbfoTvJBSUMhGkd7EllyYy1Mdy31Lgn2cgDog71hA92j8f8AAR3Hh47CuGLWieGVoj8kEAIg7BlTj9UVGAJpeP0IrEwQ9lQ1XuD9kbwBU/KZj0TJ9rmZFAsyYOGfi3shBqIYMIMjZFb90QLCUVEzoJdWTEVPAltHu5sbFqM7YqTbMqQORiyfHzAoASpRgHMVGNpayvjjGBlmPCDQLDf227ISm9+JENPcg0xm0NjMIul1LHiaUIVd7GV3zCM74cVQiXAekHc62dRPlr8aje5tsSlVPpg9Z/ZFDQ91G7Zml1EJ68Yhgzll7fUGA2rFojJHcdTtMGIbSRgAAEmkiVAHDBOOCRjNM9M9EQEIFH2i0a74FQyyjqoGWwvxBgwASoMAUcz2zxEh2+sIiq7TFoQm28aj21MiheRyidhxGqhHiWHE2tZairhC1mrmKyU2mJUuRwQ0IFZUN+7FEwQ81iAktxjxw/HfGJK+FcCNLCdywhTbBMcSgBmsStUa2+RhbhXcRPTw6L5jzw6hgPuG+PuOHTMl6vYPAEw4BuHBwwWRvEUxfxACFUzMdKa3iBFjQFwdNx8h4g1CBhF5hvRg1xF1sGYxPE6BD8hJYliFeJ43GhhGBhiFCcLMIPYMigjBeyIUFPEJUNBFwVMOT9R0TXNAU9RTEVWiJmFO+H47474fjUqVZlRCDUQw2iwPAr/2y6fagfoiCbMlUdznphgRI4jWyn0JMRLoe5vvg8UJUGIMCWoMKdcIJDF3DTHcuFSvtlqFRCIQcxLnLBEmAwFjXWpYXZMseJl0VrQRqFyJALDfvIEYCYrMeYC3FObIjTeBZ27LKwxqB+XuGswhq2XCKHGnoY1qr0WAFEN9xTbI38DZN8dxj88OE4P61alm5c7Fmnh2TEbYKPq6hMs/V0S6vNSswyk1wZAxmQkPZQql5Cy07dHiUTXxDGEgJSL5RFQVzCSW/UWK/wBRBYQGAh1Mphg5i4kRe6CfMtLyZ+XhYRAEAF2hGwc1AYgB3uKuVEzSKq2tsLAwsfzMdU6aheLWkrrGxnTTFZ3uVr0jTMQTW8OpXK3sSsNWtzAOI7hsIPhjwTfL4fiEMHwuDnHowAkUrqFegsvfULENFXkhWeoUj1UNJBSxUx3RjEvGJYwYHtg8yW35WWB6kgxax4gRXLPg+q7im5gUe5SNDwTOWveY2Vn0TOSjhUI1OZpXgiLPEpnRCMibXgg0n9qZQgHbfGIyexRT+5Zjkf5kBUSLURuKQyj2EoHfdRmOGLQTAxv210IGEIatAqgBuOqtb4i9FrS5g2ZpGf1np4NzZw8aYci2BwbHgLtpAGgVR5lkQYM6Xqx9JPvi3MS4QHtgyM0e5gzPiqSOGCUXul94S0qqNzNGD8MFMpUw+SFlCBKhuKbjgt9CbICMFj7gIACAOoTQRoTbBlwvCE58mA8vt8+QEY9UUlOxGoIFUYgK4eDKvUM01UJsxT2GzwkwXrPpjUhAT0TKAMXeerguwSXFYxcMxcFsvndMolXgiKrL6If9QiyaukTQxayJo9bIe3xGou2XlO5u+CqDkx4FNMyK2xFMCjFxsBLVBJGWqJZO2ZQrgFjBU4kGxEphuW1HtGYuFEAyYp7ZNlUgiVcdLRTKwfTMosn7lSAECGcYpUeCMAHMuIsFvEUpocpR1uEB0nBdw1HdANJLKKdHgJdzdG2ZX7AWHg6RESQ1bohwlypmwBruW4pKxVdsYs0GUsFd7IANg5+pkm7/AKhd8S3TGaP+mZ414RM+LcuI4MJu4gUKVQaC2ww5fDCFYQgLDUeGyMXyyhhm0x7fGoJjQqBn6yYlHtNgEWFqGrRgXggoIP8AaZQBUWh06jq0Bx6gypDzCRMsBcDcrOSILZWYNAhOWCECAlRajxXjADmAXMS6LuomXY1rczfuibMlGKmYjJAQ2pSS19Rb2xlTN0kGWNIIJdEbam1V7lhuo/UWIbqgj+w8mr22bVLgDLZKQdAdJcLwZB4LGBykEqkNhTAsodiV1oaWCEqcxA5bpiQMLlH50cHFxitl/wBpiQ+xcobWKO+pikpKSt6SXUfKBd8y6SuorSKxBLTi6DKY76iCIqoMu66oEq9RmxiXLzj3A/W+q+XATURKOJ4Bk7iEEuLswBANxUmepdFJ5YqWuAtgsb9RwoB3uj7B9ktRUYeBLgpwBIGpSSMftkLXqDQQDJNXhpektlQNXAnILX6gq1jnBK0Kx6XAOeh3ELKg1FoouGDyQhcZAuu4IlS1Huc6g93I8nJFjmuKRmhAVcEpJf4YRm0oIBKLmLRTDKS78xmfAxlvlMNQbiAHpIS8ViEe+GAm3BQykeaJ36h1Yf8ATlDRWjBMMwRxOn4IRULzCNwS5zHZYo1HiEMo0eUTsV8y+O5ZVRLIiqcsF++ACSoSP4ShFgFaHphdQtqiHUY8JRney7Qd69QjbBwMsx2iBABmu2MNURxHS/dYEGFqyA+z0gZGGg9kTZ6qJcsAq7Ykl4jF46RwmssilkyhAqBrgVTJlf8ABe4jvaQoF9+ypf2CjBPJP8kNJP8AGRa3hIxmYksBITFEsgUKhHaxwRiEUDgYePRcINyxhxFM4sAsZaBTzL4l+JuIuOZaioyjZH9RyUFtxLMqJfRBBKqJAtgBQoisVcQHqVxj2Gbgl62FtwhgtZld4wAF2jcFJY9MIBPLdSusb83B7YP4jtgHRAGW2JV2GfMmHwomIplHHbLxi3idPBrFoSN5xrgcIqXkI+4SZVKBctlAZl3OxljBoOU8EKmzqptPx5hp+o+5I3EIkTBxuJpUbEbvBhKhVHio3GsEzcIuZRdMQbwhwufMohl3GaL/AAB6trogEfiiD7slB6KkSOGBmGFszF9pnwpQgzKiAEpTMXQdgjPHeIdUK2qdiB1HEBPMsmWtrTrxMyD94NZNmo5yMtJRGXRLZ27DphiHvpu7mGr6U1EJYpKR0xBxEkZGi7qYVwGUT6h3qATO+FyyRSNswW30+SJrVgdQqDySn5QvTC6IVfUFMsoSv1OVe8lEeOox1GYJr84rUyF/LAKIcROWkcygcx26YwVmUdJZC4MLxHbo05Yg25B/crlUYwmpC+ydMd2WCDo7iq8GUSqiFQIMurFjEoosTnTj6iB2lsaATMa3WAIgKTN+TL42Aacq+oNIV2jxad/9JZqu7CjTD8Rzo4Vj6JecWivCDNyXAShlh1EfoZA8yi+FcShth4YFKOF4lpTCMNItcfREoEZ05dvErRTExDrig7g4keDFzgujhnR7CAJUaGMHW0Zc6CTa4IRlcbJOiOnBKaIvU14OiPDFDmK2XN8W13WxfqBBl7XmAY6ixxqVX9QZtCVjhIGYJRZ04jplRuD42lCowtatyqmNBdT2tMTMRE+CUtgYlrMXgEIULwwWdwLVmN8MGppPSl2DgysarHuFUimiARw6BL4l6nfolNizttBPiUF2xvY2pZHwj8OybYTaAwBfLKkzPqLhgigXRN2aX+GUHLuJS+nNx0ytfZgTKNLKHSlAx0vTAUPaMdvbaGW8ys6fXAjuefqBeItnohS3uEe9H6iamvFcOpLypB47YQbFy4FxbZ2o+47dFb9y7CVNviEEMrI8dUqmECE0ggw74mDucwkSB/cH4D0Q5k9jaz2GhV0JY4tKYSBAc8xZjWEs2MBdw4aKywtlh7ICKnARQ1IT/vFzh08IW+tUHiNKEECqq7YpLzw7OpYI6YPeoJB2SFoDNom35wMy4D+BnHmKTQ83jEqdg3G1XuGajSC4oI7ZQOPEojSyklqsZYJt3Dp6FQ7PEdcO0q2VfaQ17e4dfuyZ25hrqa8ollwyFJ+pRCWbZD7YxHVLyu2XIuTllp4TFXAx8A8QI5IKBxBV4AkRYIuj0fMYDfR7I1huUtKRBS9u5mmBhGtH6EHVLFHcdqDOWkh371TggxjbQ2waBbLs6jqaVWuSMtXe3pI91NPcO0n2Q6NU+7MOLVWVRAHJKhAZ4IALI5CKgKZYwna2zCobhYciyKzcDzkRprcdvXy9ErNkNMlOK89YeNhhEqBx2JpEULzcnKHUA+6Z4VmVmXkwv/xULcC/AhUXAEsQmpyawgMqQ0t5JcxNj6PS4mgFR9kS7wQK3kMSt8dHIZmJKqM7m80wRQNxvXbgxhGgoD4mFSu2JXSMwUgMmJ2kp5IoqJW7GVjUWJ2XAyrwFy2DiuxFkKJVJHaq+kLczmsYIILgUZduU+o+s4KNyClrdQMzaXyVYExjuNVxlEA+qrUWrljLdRaoUy34IYJRSncqQrFB/wAwksdhm4ATBX2IWERlEjV5QrQNSz9dR2J5BBc0lMYDbOJuC4quVrGFJiPWDAucWUdiafD0DG1EEQYbjPUIZx+pBBjKFhW1FhgKlZgzLjLKgUmLFHYgyfAmr6IBRA0ZgDSJSeEldUXqgUMF7ut0NJFVka9logEZqxIWByylKK8SoaoXcNE7q7uHPEqi0+RMFoZZXMmIHIlP2xQUEV5gA3QzMQcKi+MUyEUJvMMvyK3De0ALqiO6qFYoBrp+meVJvZFzjeOpAtu3jqOZqn0MxO5lWIRiHYoLbagXPDMSwUpNpozD9QUeEdIZBCKwvPzCV5mkYIIG0uvEpSD+WExhLTW/wEpPEfcqUBtD1lMPAS8VAsQRtgqp+AY4MZtNUrZWJlUuzCtD3AeCzZ4inZUp7jnaIQ8AXfmWBLoWVoIW9D9QUrFyAYW0e6m3FRQiV6jWWMYq0LHCemNMX6JRID8S8V28wWJMLrghPK6q7qHuaLwjKeYPAhMdRSXLGY4Dkg8WYXmLMnSrIkN8kq4H/OMmrdrcayij6gpRSwi6RDNEvTBFAU4JsWbJkypmHExhubvREgT3Ik1jDA0xm5hcQB9LLsLlnYlbYVJuM/7EqOdIZ/iXhuRQs0zOMJOBnoKMoYJgxZgAFrqV80qn1DrMyYZopQsHfiICtQ/PuVu3VviaXnfuoE9jqBe4B/UMqOp+5SxAPyxSADRwC1rVMStorQSxRLhJsxaPAFBLK8ARf1VmBKKYawRjSIBd5qJkW2osIEIngXBgF1QAPLKydoeWNFh37xG8gmO4l/pErnS1kIoBS4JBhEiEnhwIj2mAdqw3S9ZgQ5KuOpVHDGxsbVKPACKwBMxblpHviMcCzHWHbUzALIPtmh4bIiwXRP4RhC3kQErZJK1MYdwVOqJUYS+E94CuIlMWZLlkM5NRdhoqlgTbyMZb0bzABgMezCBlK6JdbGDDLgUMtyHxHsqGMNHSGZz+iXqrFHMOahpF0k8hQruEUA9ssJrUJaF0NxPjGJbxjgOWKhVvUBauVrtxw1rpf2Qr5RvsVgENFtsYvassqU3AVv6hpuIh3fHCoADWq4qr7ha06j34PuWkSMUAS/2hBfiGOolR9KD0RROZu6Y4Th0xwZifMXO4hsv4JZPFy4ogt0P6ZiRiq/DKlYFkuqysjHFJqMECjGlWw6IsGV2Bs/BBUM3bgQ/ERE2Iz2tIKjAJ0tJq2UIsuIYiwC5omeWyovUSy/UMfIq0yStNQ5ZhIptRsRzV3NGfJS6klFRgrVOVlwXtHaOVX4AxIrDBi2ysJk+hCCHIzKh0JjQNRiwoi2oyQFAqAjKH6julLaJiYiS+wygdusT2bh0VGVhiQMc+CUqg3cKhlV+0SOxOhGocVz9xYUzV01lsLESu6VhwQMLfmbJR6lIK4YpGChoG7Zd84zWojKhCJ6nU2GFJN0i0xW5eYNPlII2pcPr8eeoHFK0uY6dCRKT4UyhFsh0YdHgU8xhp1GNklXMY6gJDaVW4wxnciA/JbYugg+9pmDLWzIRMIaljVVzGCsCWqQPZ5uFGSAyWV+iavzMQH4i00C6XFqVTML9M+wGBuiJRqBWw8Sjoo29JkwiSGDIWl2RpIzraXLIOWY3DSvcxj5qKeC4aYgGR7lhKZIq6MXY8I6UoWIyrXcQQSGTyRY5hWJgGACKqPNMM3ywRlzcGfOnGMhov9m412aXmJh+4RGUI/og1HCyO53xQBkLh1gUlUr9TIgr+gmTS/FdTF5CsOLk1tR6seOERN8IRhXblxExYXM7SmMciwRgS9YazFlVzcQugyxIBMRMYUGGXsDmqXAl5wI5MCcEAwhbfbDTaVAzNA/Ue8jhCA3C4B+9k8gJhIzXS1S+7mBtuYxkFdpGhL4kUG+vMMWy4qUo9kvPuKym5LPP0ywtAPI+SJf5lRN8IagimsO7QWTfoyxXdepi5MkFUqENguiW7FBu/VRqW6CAaVKqz22bRiqkoQ0yhzqVqmowmGVqDKR2Ywh9XbBqQrh5gWGx1LDgMXsIrCSHYIv1HG5R0zTTcRIUm2tBMQTUrsS4HMQcAA7loNp0w2luAPEwYMX5ZZE+pk3KgEIJtDrwia2wKgiR8kfuUHDQIxypcXccGKpIpyqy+4N/cRCV4WCeJFqMeO65mZM9S1hpbVdPiV5hZUtSReAsomXfnNMKUDLhlgb1CFcOyDuGGFzY8NsveukDENIxl/ZAG1/COH/Cjyv1wLJq7zQYewDQRdY6JWiiafeI1FOngzIplNuRdTCIdSjWDJHAQ7IglcjLMJ/SYtBywytqvKGoXvNx8+IO+eNUzGpk9x2KdsawR0QCi4XCQCAQeXMA4uVWn6GIRtMxx9cpDQsELXBws4zdjuLTOEfbL715RNWX3KRNxWRUQlPmY7qZUfuLhQxNzRKXDkQ7i1rzVErXsIJch9IytE9sWUQXTTMbS2nDMYrilksSVHiDqSlKSg9i/4KQ2wlMwlNiNOJfKYFDzLiPkeom1F9yq9WVK815YBI8CbpIljaBDTwgk+0gcsyzp3NqyCiPqi5eUqVbJU9xbhheHEKiisNRaBCm8oI1DcLxcrGQZJ6UiWjspMUlI5GAALsTcdDkUu43RqJ20IhUIQl2tuFrBFItUEdM/2F5sWJDd8EjJZTIyhxAQLllO6igu2AXKXiNTW1E7eyQVSzDcFZIYLQjTSCbU7H+WF5Lia8aQvXBlCmyJoi69rhGNBfuRLqoDMtb1/mBZ6iDh3BgqE36JenKhBLcyhWhiWsowJmoEgVF2QNTR39kB9LRzDEZe4FICWBRwuBDFSTadwBQJZ8kKEfpsj7T3tZ/MNYDhj0gKACs86BjzGFeTFptqWS4QZhZF28MqTSIxqqwCum2OxGUqI0UOkFB5YYWVVNOoiZE9RZdYTEJtgnEBzjg216iFF+5QpuAeTFisjUG5bY4JIFMomY9ylQhcxrfPRK+x9QABqsOFcFGtwYiB1Ox6jBe5fmFsXgbKjl4LUwxq7SHi/wARzRAmzCrMPo5+oAtRJcmWqY6gQPPcQ0mn5GOfrjLBpoRZENrcMJKosHcUJ7dRmqwCg8BcrEPYyn4AKLg6wSBq4UO0M0u4vULXBBCjw6IqEJNyh69EZHjgYPDED9xaDWIeCcjoAmeS7KIpox9wyNRWLOuVphShbQeJSMWrUyaJRm8QVnxHOJSN1EsiFUOnEWpZTlPmJoUoY9rslLHAGLCe20uFedwe5Qg0aSqQiR4bMEBmbcQabmDqEUWTZ6Jc3RbjthqKOW3nJHsVLO0lQxnUoB0MIATHEA7YEAOSoHyUqjzHA6lgXJPDCpQUo5VDgCPD1LF7ucS2n2eIkig2fuBgUGNvqD8NqPRAist2+5dukSOBVB+NxcCOmyCz0v6jdem5V4CHLoI0E5dpY+dy33+xY29QFyjBjmQRsMpoQpqbDLlzJRGq71NQAuoLuDGsKJcCAGCDB4GJtO4hVxUvbiaZYy7AXfiZAXugQF2Le4CwEXiYcrKVDXDw7y2YfESnUE3uBBJ0NodkHqV2QtRipqZVkS0orxVFJBLClU1AYoZWbLxAl+mvEbUq8/SL0XetkzSpdMALLdn0xajlpTCCVWKnqi0janTaQ1GdkCIJZTwQxq0lXMythGXQgC/fT3FZWwuJrgeJ1Kjxg75gSXbmFtuDMYCqGSL2qiCy7yyjZLCF6KwE2SHtBmjAVcFYcp6GAlMCR09mJXcMhCaQQH0kToLFaoWwUqUMpLDrFMKkY7GYeVZpRfMgEw7gmPhgCxbfkNKYW5hcRb1A2wrmjAbCWgXeWda+npI2biAVKyEawKLPx3c6pcoGyOdpF8fZi8MBawRAGT1L4u249MK0DwdMz327YBGmAeo9a3DZHhrgYytVEfIyhjSSzKjUy/YC2diFFgdIG5V3EsqVEKxoo5GKCJhaJKIMxRwYJQavL8QDifMNHGD7EQFbVfcHaoAuuyiCTVGdbsPcTwsXGcLCNHaHC2Folp6I74UozDAHuVqb+ZmxHeY9dbccHgQxEdbVg5ZmwTULUk1FvUFfYQ+J3ga1Bd4myHLHSNVVLY9CeIDaWLNQ02SMI4CFi+B4ljY9rDajdxqmj1K7DHCUJpErEO2o79wqGbXH5iAWIZheUtoI7dujGCHMV3F1uSbWEZsEqy3mW3ZrJEjJcvU7KsrCislo7RoGjuMYUGclhxcqEyGU95AgXFKStMokzAz8TEKwpTKMLuRDIIClNJcVSrHtYzJFdw9YJCoZVAXL8QdAek7S19rddRl/iGswRqEHUB0y59xSLHAfEkBsbi5FHHt1EKjKRcrS0F8cLneiHcEXsDLM3gXuFaFXTUCDpTUNaVCzmKCJWQRUqb1EG2HctYmMi2KS4Sncapiym56BCBw+QNksDfeZaIJK8lTpj3Fd6AhHYPeYYzaZXa1XWiCSACvLHY059oz44X1AupvP6llgMpS1oYwUT7xXi3RiObGZIoS+p0EpOwTZasUkqSqZYIiodjce+zCKtwDUoG+ks1CAzR3B7DyRcaPE/G5gSkzmqJTQUB6XcPLZuM/iA3aMqDEbURdWa9EFg3wkrgrGx1LFScrwRYHFmvr5DpDLoITbwVZu5FbxLC/UFiy2ArFylXC1MdNQSMs0qoMyJgqYKV4jCyUz3mGwSvCMG62bEJ0+ZiokmjTtUVIAEYEIhHX4h1sNW6g4LsAmR8OPLBAAGToR5FSNhh1F11AngSgeI/b5st2/oGU4UxAqG2gRgOaJUTbiO06tLlEVu+pulvfoqBi6wJ5uhtu4wOuc0Oq1Ykq0Rgf3BeSs+4K0opSbEIP4hyArWffcqWVqjUQasGDVWpbyy4bv4hw9YR8pDFn0RU02HiLa8DUuPKHUMMNulSC5sz9HkvwfYJTSJaNkm7KblmQQy96bNy/tkhIqKR3UUIJDKow4lqCVR7MwxR2wT67I24gybgfCpqMmXmVGrFDIU+2osk278TCX67hQ++7cMxBKXcYREbjU9UCVGtRIq4OP+COEgcqdBAap5YU0heMEZw7Kiop3onvMwIQ6Y6AXStxBqiqJinqIty9zyAMEho69TMC+GmMh3TFMy9kd6luALzLvcCjuPA8lfcyJEq2CtgO/McSBaNqkHLsB6WPyKwT2wDoVOkDgiA7X52QrJEQ3/UwkHxpc2msVWwWMoJmZ4QupSAdXMNbHzUwlVEjruBHUXW+3k5wMQSqn3GgSgqmwIppsuoXQEFQrdR0WBm46sUsi0kaC1gom9Iagal7Fg6woXqOwB30eCPLsWGAe18E2uAT2lJ8gTyStLpCCG1c7moRG5aa1B7EoXBZ//9k=\n","text/plain":""},"metadata":{"image/jpeg":{"width":200}}},{"name":"stdout","text":"\n🎬 Downloading video from YouTube...\n[youtube] Extracting URL: https://www.youtube.com/watch?v=HEqXeXI_KAE\n[youtube] HEqXeXI_KAE: Downloading webpage\n","output_type":"stream"},{"name":"stderr","text":"WARNING: [youtube] No supported JavaScript runtime could be found. Only deno is enabled by default; to use another runtime add --js-runtimes RUNTIME[:PATH] to your command/config. YouTube extraction without a JS runtime has been deprecated, and some formats may be missing. See https://github.com/yt-dlp/yt-dlp/wiki/EJS for details on installing one\n","output_type":"stream"},{"name":"stdout","text":"[youtube] HEqXeXI_KAE: Downloading android vr player API JSON\n[info] HEqXeXI_KAE: Downloading 1 format(s): 18\n[download] Destination: /kaggle/working/inputs/target_raw.mp4\n[download] 100% of 63.19MiB in 00:00:01 at 42.47MiB/s \n✅ Downloaded!\n🔄 Converting to H264...\n✅ Codec OK!\n✅ Video ready: 640x360 | 30.0fps | 450 frames | 15.0s\n","output_type":"stream"}],"execution_count":22},{"cell_type":"code","source":"# ============================================================\n# CELL 3 — Clean Simple Pipeline (Best Quality)\n# ============================================================\nfrom tqdm import tqdm\nfrom IPython.display import HTML, display\nfrom base64 import b64encode\nimport os, cv2, numpy as np, shutil\n\nENABLE_ENHANCEMENT = True\nTEMP_VIDEO = '/kaggle/working/outputs/temp_no_audio.mp4'\nOUTPUT_VIDEO = '/kaggle/working/outputs/face_swapped_output.mp4'\n\ncap = cv2.VideoCapture(INPUT_VIDEO)\nout = cv2.VideoWriter(TEMP_VIDEO, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))\n\nprint(\"🚀 Starting pipeline...\\n\")\nfor _ in tqdm(range(total), desc=\"Processing frames\"):\n ret, frame = cap.read()\n if not ret:\n break\n\n faces = face_app.get(frame)\n result = frame.copy()\n\n if len(faces) == 0:\n out.write(result)\n continue\n\n # Step 1: Face swap only\n for face in faces:\n result = swapper.get(result, face, source_face, paste_back=True)\n\n # Step 2: GFPGAN on full frame — no masking, no blending\n if ENABLE_ENHANCEMENT:\n try:\n _, _, result = enhancer.enhance(\n result,\n has_aligned=False,\n only_center_face=False,\n paste_back=True)\n except:\n pass\n\n out.write(result)\n\ncap.release()\nout.release()\nprint(\"✅ Frames done!\")\n\n# Merge audio\nos.system(f\"ffmpeg -y -i {TEMP_VIDEO} -i {INPUT_VIDEO} -map 0:v:0 -map 1:a:0 -c:v copy -c:a aac -shortest {OUTPUT_VIDEO} -loglevel error\")\n\nif not os.path.exists(OUTPUT_VIDEO):\n shutil.copy(TEMP_VIDEO, OUTPUT_VIDEO)\n\nsize = os.path.getsize(OUTPUT_VIDEO) / (1024*1024)\nprint(f\"✅ Output saved: {OUTPUT_VIDEO} ({size:.1f} MB)\")\nprint(\"📥 Go to Output tab → download face_swapped_output.mp4\")\n\n# Inline preview\nmp4 = open(OUTPUT_VIDEO, 'rb').read()\ndata_url = 'data:video/mp4;base64,' + b64encode(mp4).decode()\ndisplay(HTML(f''))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-21T12:17:01.045099Z","iopub.execute_input":"2026-03-21T12:17:01.046014Z","iopub.status.idle":"2026-03-21T12:17:39.354061Z","shell.execute_reply.started":"2026-03-21T12:17:01.045975Z","shell.execute_reply":"2026-03-21T12:17:39.352236Z"}},"outputs":[{"name":"stdout","text":"🚀 Starting pipeline...\n\n","output_type":"stream"},{"name":"stderr","text":"Processing frames: 100%|██████████| 450/450 [00:37<00:00, 11.90it/s]\n","output_type":"stream"},{"name":"stdout","text":"✅ Frames done!\n✅ Output saved: /kaggle/working/outputs/face_swapped_output.mp4 (3.1 MB)\n📥 Go to Output tab → download face_swapped_output.mp4\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"","text/html":""},"metadata":{}}],"execution_count":24},{"cell_type":"code","source":"# ============================================================\n# CELL 4 — Gradio UI (Kaggle Inline)\n# ============================================================\n!pip install -q gradio\n\nimport gradio as gr\nimport cv2, os, shutil, numpy as np, yt_dlp\nfrom IPython.display import display\n\nos.makedirs('/kaggle/working/temp', exist_ok=True)\nos.makedirs('/kaggle/working/outputs', exist_ok=True)\n\ndef download_youtube(url, out_path):\n if os.path.exists(out_path):\n os.remove(out_path)\n raw_path = out_path.replace('.mp4', '_raw.mp4')\n ydl_opts = {\n 'outtmpl': raw_path,\n 'format': 'best[height<=480]/best',\n 'http_headers': {\n 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',\n },\n }\n with yt_dlp.YoutubeDL(ydl_opts) as ydl:\n ydl.download([url])\n os.system(f\"ffmpeg -y -i {raw_path} -vcodec libx264 -acodec aac -preset fast {out_path} -loglevel error\")\n if os.path.exists(raw_path):\n os.remove(raw_path)\n\n\ndef process(face_image, video_file, youtube_url, trim_seconds, progress=gr.Progress(track_tqdm=True)):\n\n # ── Validate ──\n if face_image is None:\n return None, \"❌ Please upload a face image!\"\n if video_file is None and (not youtube_url or youtube_url.strip() == \"\"):\n return None, \"❌ Please upload a video or paste a YouTube URL!\"\n\n try:\n progress(0.0, desc=\"🔍 Detecting source face...\")\n\n # ── Source face ──\n source_img = cv2.imread(face_image)\n source_faces = face_app.get(source_img)\n\n if len(source_faces) == 0:\n source_img_resized = cv2.resize(source_img, (640, 640))\n source_faces = face_app.get(source_img_resized)\n\n if len(source_faces) == 0:\n return None, \"❌ No face detected! Use a clear front-facing photo.\"\n\n source_face = sorted(source_faces,\n key=lambda f: (f.bbox[2]-f.bbox[0]) * (f.bbox[3]-f.bbox[1]),\n reverse=True)[0]\n source_face.embedding = source_face.embedding / np.linalg.norm(source_face.embedding)\n\n # ── Get video ──\n progress(0.05, desc=\"🎬 Preparing video...\")\n raw_video = '/kaggle/working/temp/input_video.mp4'\n\n if youtube_url and youtube_url.strip() != \"\":\n progress(0.05, desc=\"📥 Downloading YouTube video...\")\n download_youtube(youtube_url.strip(), raw_video)\n else:\n shutil.copy(video_file, raw_video)\n converted = '/kaggle/working/temp/input_h264.mp4'\n os.system(f\"ffmpeg -y -i {raw_video} -vcodec libx264 -acodec aac -preset fast {converted} -loglevel error\")\n shutil.move(converted, raw_video)\n\n # Verify codec\n cap_check = cv2.VideoCapture(raw_video)\n ret, _ = cap_check.read()\n cap_check.release()\n if not ret:\n return None, \"❌ Could not read video! Try a different URL or file.\"\n\n # ── Trim ──\n if trim_seconds and int(trim_seconds) > 0:\n trimmed = '/kaggle/working/temp/input_trimmed.mp4'\n os.system(f\"ffmpeg -y -i {raw_video} -t {int(trim_seconds)} -c:v libx264 -c:a aac {trimmed} -loglevel error\")\n input_video = trimmed\n else:\n input_video = raw_video\n\n # ── Video info ──\n cap = cv2.VideoCapture(input_video)\n fps = cap.get(cv2.CAP_PROP_FPS)\n total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))\n w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n\n # ── Pipeline ──\n temp_video = '/kaggle/working/temp/temp_no_audio.mp4'\n output_video = '/kaggle/working/outputs/face_swapped_output.mp4'\n\n out = cv2.VideoWriter(temp_video, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))\n\n for i in range(total):\n ret, frame = cap.read()\n if not ret:\n break\n\n progress(0.15 + 0.75 * (i / total),\n desc=f\"⚡ Processing frame {i+1}/{total}\")\n\n faces = face_app.get(frame)\n result = frame.copy()\n\n if len(faces) == 0:\n out.write(result)\n continue\n\n # Swap\n for face in faces:\n result = swapper.get(result, face, source_face, paste_back=True)\n\n # GFPGAN full frame\n try:\n _, _, result = enhancer.enhance(\n result,\n has_aligned=False,\n only_center_face=False,\n paste_back=True)\n except:\n pass\n\n out.write(result)\n\n cap.release()\n out.release()\n\n # ── Merge audio ──\n progress(0.92, desc=\"🔊 Merging audio...\")\n os.system(f\"ffmpeg -y -i {temp_video} -i {input_video} \"\n f\"-map 0:v:0 -map 1:a:0 -c:v copy -c:a aac \"\n f\"-shortest {output_video} -loglevel error\")\n\n if not os.path.exists(output_video):\n shutil.copy(temp_video, output_video)\n\n progress(1.0, desc=\"✅ Done!\")\n size = os.path.getsize(output_video) / (1024*1024)\n return output_video, f\"✅ Done! Output size: {size:.1f} MB | {total} frames processed\"\n\n except Exception as e:\n return None, f\"❌ Error: {str(e)}\"\n\n\n# ── UI ─────────────────────────────────────────────────────\nwith gr.Blocks(title=\"🎭 Face Fusion\", theme=gr.themes.Soft()) as demo:\n\n gr.Markdown(\"\"\"\n # 🎭 Face Fusion\n ### Swap any face into a video using AI\n **Stack:** InsightFace · inswapper_128 · GFPGAN · OpenCV · ffmpeg\n \"\"\")\n\n with gr.Row():\n with gr.Column(scale=1):\n gr.Markdown(\"### 📥 Inputs\")\n face_input = gr.Image(\n label=\"📸 Source Face Image\",\n type=\"filepath\",\n height=200)\n youtube_input = gr.Textbox(\n label=\"🔗 YouTube URL\",\n placeholder=\"https://www.youtube.com/watch?v=...\")\n gr.Markdown(\"**or**\")\n video_input = gr.Video(\n label=\"📁 Upload Video File\")\n trim_input = gr.Slider(\n label=\"✂️ Trim to first N seconds (0 = full video)\",\n minimum=0, maximum=120, step=5, value=15)\n run_btn = gr.Button(\n \"🚀 Run Face Swap\",\n variant=\"primary\",\n size=\"lg\")\n\n with gr.Column(scale=1):\n gr.Markdown(\"### 📤 Output\")\n status_out = gr.Textbox(\n label=\"Status\",\n interactive=False,\n lines=2)\n video_out = gr.Video(\n label=\"🎬 Output Video\",\n height=400)\n\n gr.Markdown(\"\"\"\n ---\n **Tips for best results:**\n - Use a clear, front-facing photo with no obstructions\n - Plain background works best\n - Good lighting on your face\n - Keep video under 30 seconds for faster processing\n \"\"\")\n\n run_btn.click(\n fn=process,\n inputs=[face_input, video_input, youtube_input, trim_input],\n outputs=[video_out, status_out])\n\ndemo.launch(share=True, debug=False, quiet=True)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-21T12:42:58.530665Z","iopub.execute_input":"2026-03-21T12:42:58.531018Z","iopub.status.idle":"2026-03-21T12:43:04.139190Z","shell.execute_reply.started":"2026-03-21T12:42:58.530987Z","shell.execute_reply":"2026-03-21T12:43:04.138473Z"}},"outputs":[{"name":"stderr","text":"/tmp/ipykernel_55/588209873.py:151: DeprecationWarning: The 'theme' parameter in the Blocks constructor will be removed in Gradio 6.0. You will need to pass 'theme' to Blocks.launch() instead.\n with gr.Blocks(title=\"🎭 Face Fusion\", theme=gr.themes.Soft()) as demo:\n","output_type":"stream"},{"name":"stdout","text":"* Running on public URL: https://c3e56ce0f2349c8bb3.gradio.live\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"","text/html":"
"},"metadata":{}},{"execution_count":25,"output_type":"execute_result","data":{"text/plain":""},"metadata":{}},{"name":"stderr","text":"ERROR: Exception in ASGI application\nTraceback (most recent call last):\n File \"/usr/local/lib/python3.12/dist-packages/uvicorn/protocols/http/httptools_impl.py\", line 416, in run_asgi\n result = await app( # type: ignore[func-returns-value]\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/uvicorn/middleware/proxy_headers.py\", line 60, in __call__\n return await self.app(scope, receive, send)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/applications.py\", line 1160, in __call__\n await super().__call__(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/applications.py\", line 107, in __call__\n await self.middleware_stack(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py\", line 186, in __call__\n raise exc\n File \"/usr/local/lib/python3.12/dist-packages/starlette/middleware/errors.py\", line 164, in __call__\n await self.app(scope, receive, _send)\n File \"/usr/local/lib/python3.12/dist-packages/gradio/brotli_middleware.py\", line 74, in __call__\n return await self.app(scope, receive, send)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py\", line 882, in __call__\n await self.app(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/middleware/exceptions.py\", line 63, in __call__\n await wrap_app_handling_exceptions(self.app, conn)(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py\", line 53, in wrapped_app\n raise exc\n File \"/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py\", line 42, in wrapped_app\n await app(scope, receive, sender)\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/middleware/asyncexitstack.py\", line 18, in __call__\n await self.app(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/routing.py\", line 716, in __call__\n await self.middleware_stack(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/routing.py\", line 736, in app\n await route.handle(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/routing.py\", line 290, in handle\n await self.app(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/routing.py\", line 119, in app\n await wrap_app_handling_exceptions(app, request)(scope, receive, send)\n File \"/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py\", line 53, in wrapped_app\n raise exc\n File \"/usr/local/lib/python3.12/dist-packages/starlette/_exception_handler.py\", line 42, in wrapped_app\n await app(scope, receive, sender)\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/routing.py\", line 105, in app\n response = await f(request)\n ^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/routing.py\", line 431, in app\n raw_response = await run_endpoint_function(\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/fastapi/routing.py\", line 313, in run_endpoint_function\n return await dependant.call(**values)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/gradio/routes.py\", line 1671, in get_upload_progress\n await asyncio.wait_for(\n File \"/usr/lib/python3.12/asyncio/tasks.py\", line 520, in wait_for\n return await fut\n ^^^^^^^^^\n File \"/usr/local/lib/python3.12/dist-packages/gradio/route_utils.py\", line 528, in is_tracked\n return await self._signals[upload_id].wait()\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/asyncio/locks.py\", line 209, in wait\n fut = self._get_loop().create_future()\n ^^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/asyncio/mixins.py\", line 20, in _get_loop\n raise RuntimeError(f'{self!r} is bound to a different event loop')\nRuntimeError: is bound to a different event loop\n","output_type":"stream"},{"name":"stdout","text":"[youtube] Extracting URL: https://www.youtube.com/watch?v=HEqXeXI_KAE&t=60s\n[youtube] HEqXeXI_KAE: Downloading webpage\n","output_type":"stream"},{"name":"stderr","text":"WARNING: [youtube] No supported JavaScript runtime could be found. Only deno is enabled by default; to use another runtime add --js-runtimes RUNTIME[:PATH] to your command/config. YouTube extraction without a JS runtime has been deprecated, and some formats may be missing. See https://github.com/yt-dlp/yt-dlp/wiki/EJS for details on installing one\n","output_type":"stream"},{"name":"stdout","text":"[youtube] HEqXeXI_KAE: Downloading android vr player API JSON\n[info] HEqXeXI_KAE: Downloading 1 format(s): 18\n[download] Destination: /kaggle/working/temp/input_video_raw.mp4\n[download] 100% of 63.19MiB in 00:00:01 at 46.73MiB/s \n","output_type":"stream"},{"name":"stderr","text":"/usr/local/lib/python3.12/dist-packages/gradio/components/video.py:398: UserWarning: Video does not have browser-compatible container or codec. Converting to mp4.\n warnings.warn(\n","output_type":"stream"}],"execution_count":25},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}