diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 00000000..0349cb5d --- /dev/null +++ b/.dockerignore @@ -0,0 +1,47 @@ +# Git +.git +.gitignore + +.cursor + +# Python cache +__pycache__ +*.pyc +*.pyo +*.pyd +.Python +*.so +*.egg +*.egg-info +dist +build +.ipynb_checkpoints + +# Virtual environments +venv +env +ENV + +# Jupyter +.ipynb_checkpoints +*.ipynb_checkpoints + +# Test outputs +*.avi +*.mp4 +*.png +*.tif +*.npz +encoded* +decoded* + +# BUT allow requirements.txt +!requirements.txt + +# IDE +.vscode +.idea + +# OS +.DS_Store +Thumbs.db diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..4b8b04c5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.ipynb_checkpoints +__pycache__ +_tmp/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..bfe925bb --- /dev/null +++ b/Dockerfile @@ -0,0 +1,30 @@ +FROM ubuntu:22.04 + +RUN apt-get update && apt-get install -y --no-install-recommends \ + python3 \ + python3-pip \ + git \ + ffmpeg \ + wget \ + && rm -rf /var/lib/apt/lists/* + +# Install venv dependencies, create venv, and upgrade pip in venv +RUN python3 -m pip install --no-cache-dir --upgrade pip \ + && python3 -m pip install --no-cache-dir virtualenv + +RUN python3 -m virtualenv /root/envs/VCF + +COPY requirements.txt . + +RUN /root/envs/VCF/bin/pip install --no-cache-dir --upgrade pip \ + && /root/envs/VCF/bin/pip install --no-cache-dir jupyterlab \ + && /root/envs/VCF/bin/pip install -r requirements.txt \ + && /root/envs/VCF/bin/pip install --no-cache-dir ipykernel \ + && /root/envs/VCF/bin/python -m ipykernel install --user --name vcf --display-name "Python (VCF)" + + +COPY . . + +EXPOSE 8888 80 + +CMD ["/root/envs/VCF/bin/python", "-m", "jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--allow-root"] diff --git a/notebooks/2D-DCT.ipynb b/notebooks/2D-DCT.ipynb index e395473f..b4ed57d4 100644 --- a/notebooks/2D-DCT.ipynb +++ b/notebooks/2D-DCT.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6a0c815c-386d-4bad-b37d-bb6c58f88fdd", "metadata": {}, "outputs": [], @@ -319,9 +319,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python (myenv)", "language": "python", - "name": "python3" + "name": "myenv" }, "language_info": { "codemirror_mode": { @@ -333,7 +333,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.10.11" } }, "nbformat": 4, diff --git a/notebooks/2D-DWT.ipynb b/notebooks/2D-DWT.ipynb index ff21ba59..60b20f0b 100644 --- a/notebooks/2D-DWT.ipynb +++ b/notebooks/2D-DWT.ipynb @@ -213,7 +213,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/notebooks/III.ipynb b/notebooks/III.ipynb index 53d104f6..2ed1a674 100644 --- a/notebooks/III.ipynb +++ b/notebooks/III.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "id": "1e42347e-49b9-4b47-9637-51da1c5fca58", "metadata": {}, "outputs": [], @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "id": "ff5131a5-c8cb-44d0-affd-f917d48026ac", "metadata": {}, "outputs": [ @@ -46,18 +46,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1;34musage: \u001b[0m\u001b[1;35mIII.py\u001b[0m [\u001b[32m-h\u001b[0m] [\u001b[32m-g\u001b[0m] \u001b[32m{encode,decode} ...\u001b[0m\n", + "usage: III.py [-h] [-g] {encode,decode} ...\n", "\n", - "III coding: runs a 2D image codec for each image of a sequence.\n", + "III... coding: runs a 2D image codec to a sequence of images.\n", "\n", - "\u001b[1;34mpositional arguments:\u001b[0m\n", - " \u001b[1;32m{encode,decode}\u001b[0m You must specify one of the following subcomands:\n", - " \u001b[1;32mencode\u001b[0m Compress data\n", - " \u001b[1;32mdecode\u001b[0m Uncompress data\n", + "positional arguments:\n", + " {encode,decode} You must specify one of the following subcomands:\n", + " encode Compress data\n", + " decode Uncompress data\n", "\n", - "\u001b[1;34moptions:\u001b[0m\n", - " \u001b[1;32m-h\u001b[0m, \u001b[1;36m--help\u001b[0m show this help message and exit\n", - " \u001b[1;32m-g\u001b[0m, \u001b[1;36m--debug\u001b[0m Output debug information (default: False)\n" + "options:\n", + " -h, --help show this help message and exit\n", + " -g, --debug Output debug information (default: False)\n" ] } ], @@ -75,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "id": "cba7aef5-b4fa-41e0-99de-0ddc97d14565", "metadata": {}, "outputs": [ @@ -83,14 +83,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "\u001b[1;34musage: \u001b[0m\u001b[1;35mIII.py encode\u001b[0m [\u001b[32m-h\u001b[0m] [\u001b[32m-T \u001b[33mTRANSFORM\u001b[0m] [\u001b[32m-N \u001b[33mNUMBER_OF_FRAMES\u001b[0m]\n", + "usage: III.py encode [-h] [-T TRANSFORM] [-N NUMBER_OF_FRAMES]\n", "\n", - "\u001b[1;34moptions:\u001b[0m\n", - " \u001b[1;32m-h\u001b[0m, \u001b[1;36m--help\u001b[0m show this help message and exit\n", - " \u001b[1;32m-T\u001b[0m, \u001b[1;36m--transform\u001b[0m \u001b[1;33mTRANSFORM\u001b[0m\n", + "options:\n", + " -h, --help show this help message and exit\n", + " -T TRANSFORM, --transform TRANSFORM\n", " 2D-transform, default: 2D-DCT\n", - " \u001b[1;32m-N\u001b[0m, \u001b[1;36m--number_of_frames\u001b[0m \u001b[1;33mNUMBER_OF_FRAMES\u001b[0m\n", - " Number of frames to encode (default: 20)\n" + " -N NUMBER_OF_FRAMES, --number_of_frames NUMBER_OF_FRAMES\n", + " Number of frames to encode (default: 3)\n" ] } ], @@ -259,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "id": "178ae86f-cc39-4855-97d5-a86197cb6115", "metadata": {}, "outputs": [ @@ -274,7 +274,7 @@ "" ] }, - "execution_count": 5, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -285,112 +285,25 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "id": "898ac549-e43d-4876-8362-e85e7a6b4506", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "rm: cannot remove '/tmp/systemd-private-41cc37d8e87e4e16b5dd2b0bb9e3ede8-bluetooth.service-8YZtn3': Is a directory\n", - "rm: cannot remove '/tmp/systemd-private-41cc37d8e87e4e16b5dd2b0bb9e3ede8-dbus-broker.service-j2XVYy': Is a directory\n", - "rm: cannot remove '/tmp/systemd-private-41cc37d8e87e4e16b5dd2b0bb9e3ede8-polkit.service-tj633t': Is a directory\n", - "rm: cannot remove '/tmp/systemd-private-41cc37d8e87e4e16b5dd2b0bb9e3ede8-systemd-logind.service-16sGGB': Is a directory\n", - "rm: cannot remove '/tmp/systemd-private-41cc37d8e87e4e16b5dd2b0bb9e3ede8-upower.service-OT8QPv': Is a directory\n", - "rm: cannot remove '/tmp/timeshift-autosnap.gmsdDbbk': Operation not permitted\n", - "(INFO) main: Namespace(debug=False, subparser_name='encode', transform='2D-DCT', number_of_frames=20, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, Lambda=None, disable_subbands=False, quantizer='deadzone', QSS=32, entropy_image_codec='TIFF', original='http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4', encoded='/tmp/encoded', func=)\n", + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='encode', input='http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4', output='./encoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, Lambda=None, disable_subbands=False, quantizer='deadzone', QSS=32, entropy_image_codec='TIFF', encoded='/tmp/encoded', func=)\n", "(INFO) III: Using 2D-DCT codec\n", "(INFO) III: Encoding http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4\n", - "(INFO) III: Extracted frame /tmp/original_0000.png (352, 288) RGB in=103164 out=216228\n", - "(INFO) entropy_image_coding: Written 31458 bytes in /tmp/encoded_0000.tif\n", - "(INFO) III: img_counter = 1 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0001.png (352, 288) RGB in=72754 out=216501\n", - "(INFO) entropy_image_coding: Written 31629 bytes in /tmp/encoded_0001.tif\n", - "(INFO) III: img_counter = 2 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0002.png (352, 288) RGB in=70089 out=224667\n", - "(INFO) entropy_image_coding: Written 34839 bytes in /tmp/encoded_0002.tif\n", - "(INFO) III: img_counter = 3 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0003.png (352, 288) RGB in=69750 out=229009\n", - "(INFO) entropy_image_coding: Written 35323 bytes in /tmp/encoded_0003.tif\n", - "(INFO) III: img_counter = 4 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0004.png (352, 288) RGB in=69622 out=230186\n", - "(INFO) entropy_image_coding: Written 34734 bytes in /tmp/encoded_0004.tif\n", - "(INFO) III: img_counter = 5 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0005.png (352, 288) RGB in=69342 out=233398\n", - "(INFO) entropy_image_coding: Written 35186 bytes in /tmp/encoded_0005.tif\n", - "(INFO) III: img_counter = 6 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0006.png (352, 288) RGB in=69894 out=233931\n", - "(INFO) entropy_image_coding: Written 35034 bytes in /tmp/encoded_0006.tif\n", - "(INFO) III: img_counter = 7 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0007.png (352, 288) RGB in=69593 out=235513\n", - "(INFO) entropy_image_coding: Written 35233 bytes in /tmp/encoded_0007.tif\n", - "(INFO) III: img_counter = 8 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0008.png (352, 288) RGB in=70531 out=236525\n", - "(INFO) entropy_image_coding: Written 35235 bytes in /tmp/encoded_0008.tif\n", - "(INFO) III: img_counter = 9 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0009.png (352, 288) RGB in=69862 out=237319\n", - "(INFO) entropy_image_coding: Written 35044 bytes in /tmp/encoded_0009.tif\n", - "(INFO) III: img_counter = 10 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0010.png (352, 288) RGB in=70005 out=237613\n", - "(INFO) entropy_image_coding: Written 35200 bytes in /tmp/encoded_0010.tif\n", - "(INFO) III: img_counter = 11 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0011.png (352, 288) RGB in=70287 out=238804\n", - "(INFO) entropy_image_coding: Written 35316 bytes in /tmp/encoded_0011.tif\n", - "(INFO) III: img_counter = 12 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0012.png (352, 288) RGB in=69943 out=239596\n", - "(INFO) entropy_image_coding: Written 35525 bytes in /tmp/encoded_0012.tif\n", - "(INFO) III: img_counter = 13 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0013.png (352, 288) RGB in=70869 out=239715\n", - "(INFO) entropy_image_coding: Written 34961 bytes in /tmp/encoded_0013.tif\n", - "(INFO) III: img_counter = 14 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0014.png (352, 288) RGB in=70306 out=240257\n", - "(INFO) entropy_image_coding: Written 35023 bytes in /tmp/encoded_0014.tif\n", - "(INFO) III: img_counter = 15 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0015.png (352, 288) RGB in=70605 out=240057\n", - "(INFO) entropy_image_coding: Written 35146 bytes in /tmp/encoded_0015.tif\n", - "(INFO) III: img_counter = 16 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0016.png (352, 288) RGB in=70423 out=240724\n", - "(INFO) entropy_image_coding: Written 35529 bytes in /tmp/encoded_0016.tif\n", - "(INFO) III: img_counter = 17 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0017.png (352, 288) RGB in=70532 out=241399\n", - "(INFO) entropy_image_coding: Written 35456 bytes in /tmp/encoded_0017.tif\n", - "(INFO) III: img_counter = 18 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0018.png (352, 288) RGB in=70967 out=240239\n", - "(INFO) entropy_image_coding: Written 35257 bytes in /tmp/encoded_0018.tif\n", - "(INFO) III: img_counter = 19 / 20\n", - "(INFO) III: Extracted frame /tmp/original_0019.png (352, 288) RGB in=70410 out=240756\n", - "(INFO) entropy_image_coding: Written 35316 bytes in /tmp/encoded_0019.tif\n", - "(INFO) III: img_counter = 20 / 20\n", - "(INFO) entropy_image_coding: Input bytes = 4692437\n", - "(INFO) entropy_image_coding: Output bytes = 696444\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "1\n", - "Uf\n" + "(INFO) III: Extracted frame ./encoded_original_0000.png (352, 288) RGB in=103164 out=216228\n", + "(INFO) entropy_image_coding: Written 31458 bytes in ./encoded_0000.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0001.png (352, 288) RGB in=72754 out=216501\n", + "(INFO) entropy_image_coding: Written 31629 bytes in ./encoded_0001.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0002.png (352, 288) RGB in=70089 out=216543\n", + "(INFO) entropy_image_coding: Written 31600 bytes in ./encoded_0002.tif\n", + "(INFO) entropy_video_coding: Output bit-rate = 2.490714436026936 bits/pixel\n" ] } ], @@ -403,85 +316,37 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "id": "c5a6723e-a344-473c-b36b-da1b7da466a0", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "(INFO) main: Namespace(debug=False, subparser_name='decode', transform='2D-DCT', number_of_frames=20, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, disable_subbands=False, quantizer='deadzone', QSS=32, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", - "(INFO) III: Using 2D-DCT codec\n", - "(INFO) III: Decoding frame /tmp/encoded_0000 into /tmp/decoded_0000.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0001 into /tmp/decoded_0001.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0002 into /tmp/decoded_0002.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0003 into /tmp/decoded_0003.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0004 into /tmp/decoded_0004.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0005 into /tmp/decoded_0005.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0006 into /tmp/decoded_0006.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0007 into /tmp/decoded_0007.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0008 into /tmp/decoded_0008.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0009 into /tmp/decoded_0009.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0010 into /tmp/decoded_0010.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0011 into /tmp/decoded_0011.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0012 into /tmp/decoded_0012.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0013 into /tmp/decoded_0013.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0014 into /tmp/decoded_0014.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0015 into /tmp/decoded_0015.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0016 into /tmp/decoded_0016.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0017 into /tmp/decoded_0017.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0018 into /tmp/decoded_0018.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) III: Decoding frame /tmp/encoded_0019 into /tmp/decoded_0019.png\n", - "(INFO) no_filter: no filter\n", - "(INFO) entropy_image_coding: Input bytes = 696444\n", - "(INFO) entropy_image_coding: Output bytes = 3677798\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='decode', input='./encoded', output='./decoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, disable_subbands=False, quantizer='deadzone', QSS=32, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", + "(INFO) III: Using 2D-DCT codec\n", + "(INFO) III: Decoding frame ./encoded_0000 into ./decoded_0000.png\n", "36 44\n", + "(INFO) III: Decoding frame ./encoded_0001 into ./decoded_0001.png\n", "36 44\n", + "(INFO) III: Decoding frame ./encoded_0002 into ./decoded_0002.png\n", "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n", - "36 44\n" + "(INFO) entropy_video_coding: original_file = http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4\n", + "(INFO) entropy_video_coding: N_frames = 3\n", + "(INFO) entropy_video_coding: video height = 288 pixels\n", + "(INFO) entropy_video_coding: video width = 352 pixels\n", + "(INFO) entropy_video_coding: BPP = 2.490714436026936\n", + "(INFO) entropy_video_coding: Number of encoded frames = 3\n", + "(INFO) entropy_video_coding: Video height (rows) = 288\n", + "(INFO) entropy_video_coding: Video width (columns) = 352\n", + "(INFO) entropy_video_coding: Mean RMSE = 14.420463220839627\n", + "(INFO) entropy_video_coding: J = R + D = 16.911177656866563\n", + "(INFO) entropy_video_coding: Output: ./decoded\n", + "(INFO) entropy_video_coding: Re-encoding frame 0 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 1 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 2 into /tmp/decoded.mp4\n" ] } ], @@ -492,36 +357,7 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "04c26b9e-898e-4b0e-8672-697c7b0d9e27", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ffplay version n8.0.1 Copyright (c) 2003-2025 the FFmpeg developers\n", - " built with gcc 15.2.1 (GCC) 20260209\n", - " configuration: --prefix=/usr --disable-debug --disable-static --disable-stripping --enable-amf --enable-avisynth --enable-cuda-llvm --enable-lto --enable-fontconfig --enable-frei0r --enable-gmp --enable-gnutls --enable-gpl --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libdav1d --enable-libdrm --enable-libdvdnav --enable-libdvdread --enable-libfreetype --enable-libfribidi --enable-libglslang --enable-libgsm --enable-libharfbuzz --enable-libiec61883 --enable-libjack --enable-libjxl --enable-libmodplug --enable-libmp3lame --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libplacebo --enable-libpulse --enable-librav1e --enable-librsvg --enable-librubberband --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libsvtav1 --enable-libtheora --enable-libv4l2 --enable-libvidstab --enable-libvmaf --enable-libvorbis --enable-libvpl --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxcb --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-nvdec --enable-nvenc --enable-opencl --enable-opengl --enable-shared --enable-vapoursynth --enable-version3 --enable-vulkan\n", - " libavutil 60. 8.100 / 60. 8.100\n", - " libavcodec 62. 11.100 / 62. 11.100\n", - " libavformat 62. 3.100 / 62. 3.100\n", - " libavdevice 62. 1.100 / 62. 1.100\n", - " libavfilter 11. 4.100 / 11. 4.100\n", - " libswscale 9. 1.100 / 9. 1.100\n", - " libswresample 6. 1.100 / 6. 1.100\n", - "Input #0, image2, from '/tmp/original_%04d.png':B sq= 0B \n", - " Duration: 00:00:00.80, start: 0.000000, bitrate: N/A\n", - " Stream #0:0: Video: png, rgb24(pc, gbr/unknown/unknown), 352x288, 25 fps, 25 tbr, 25 tbn\n", - " 0.04 M-V: 0.010 fd= 0 aq= 0KB vq= 235KB sq= 0B \n" - ] - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 16, + "execution_count": 22, "id": "fe49bbc8-6d7b-40f6-8210-6d8ea39b2651", "metadata": {}, "outputs": [ @@ -529,20 +365,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "ffplay version n8.0.1 Copyright (c) 2003-2025 the FFmpeg developers\n", - " built with gcc 15.2.1 (GCC) 20260209\n", - " configuration: --prefix=/usr --disable-debug --disable-static --disable-stripping --enable-amf --enable-avisynth --enable-cuda-llvm --enable-lto --enable-fontconfig --enable-frei0r --enable-gmp --enable-gnutls --enable-gpl --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libdav1d --enable-libdrm --enable-libdvdnav --enable-libdvdread --enable-libfreetype --enable-libfribidi --enable-libglslang --enable-libgsm --enable-libharfbuzz --enable-libiec61883 --enable-libjack --enable-libjxl --enable-libmodplug --enable-libmp3lame --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libplacebo --enable-libpulse --enable-librav1e --enable-librsvg --enable-librubberband --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libsvtav1 --enable-libtheora --enable-libv4l2 --enable-libvidstab --enable-libvmaf --enable-libvorbis --enable-libvpl --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxcb --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-nvdec --enable-nvenc --enable-opencl --enable-opengl --enable-shared --enable-vapoursynth --enable-version3 --enable-vulkan\n", - " libavutil 60. 8.100 / 60. 8.100\n", - " libavcodec 62. 11.100 / 62. 11.100\n", - " libavformat 62. 3.100 / 62. 3.100\n", - " libavdevice 62. 1.100 / 62. 1.100\n", - " libavfilter 11. 4.100 / 11. 4.100\n", - " libswscale 9. 1.100 / 9. 1.100\n", - " libswresample 6. 1.100 / 6. 1.100\n", - "Input #0, image2, from '/tmp/decoded_%04d.png':KB sq= 0B \n", - " Duration: 00:00:00.80, start: 0.000000, bitrate: N/A\n", - " Stream #0:0: Video: png, rgb24(pc, gbr/unknown/unknown), 352x288, 25 fps, 25 tbr, 25 tbn\n", - " 0.06 M-V: 0.009 fd= 0 aq= 0KB vq= 0KB sq= 0B \n" + "/bin/bash: line 1: mplayer: command not found\n" ] } ], @@ -1440,52 +1263,247 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "c2ca722d-82fb-4288-8eff-e9e332ac58c5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2026-01-17 20:45:22-- http://www.hpca.ual.es/~vruiz/videos/coastguard_352x288x30x420x300.avi\n", + "Resolving www.hpca.ual.es (www.hpca.ual.es)... 150.214.150.42\n", + "Connecting to www.hpca.ual.es (www.hpca.ual.es)|150.214.150.42|:80... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 18798302 (18M) [video/x-msvideo]\n", + "Saving to: ‘coastguard_352x288x30x420x300.avi’\n", + "\n", + "coastguard_352x288x 100%[===================>] 17.93M 1.53MB/s in 12s \n", + "\n", + "2026-01-17 20:45:34 (1.48 MB/s) - ‘coastguard_352x288x30x420x300.avi’ saved [18798302/18798302]\n", + "\n" + ] + } + ], "source": [ "!wget http://www.hpca.ual.es/~vruiz/videos/coastguard_352x288x30x420x300.avi -O /tmp/original.avi" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "b0cdebea-5ae2-40fc-9ef1-49b6d5c410fb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: mplayer: command not found\n" + ] + } + ], "source": [ "!ffplay -i /tmp/original.avi" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "1294e83b-61cf-4102-b42e-4414d2b33322", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='encode', input='coastguard_352x288x30x420x300.avi', output='./encoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, Lambda=None, disable_subbands=False, quantizer='deadzone', QSS=32, entropy_image_codec='TIFF', encoded='/tmp/encoded', func=)\n", + "(INFO) III: Using 2D-DCT codec\n", + "(INFO) III: Encoding coastguard_352x288x30x420x300.avi\n", + "(INFO) III: Extracted frame ./encoded_original_0000.png (352, 288) RGB in=77644 out=176121\n", + "(INFO) entropy_image_coding: Written 10762 bytes in ./encoded_0000.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0001.png (352, 288) RGB in=64282 out=176149\n", + "(INFO) entropy_image_coding: Written 10777 bytes in ./encoded_0001.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0002.png (352, 288) RGB in=63848 out=175820\n", + "(INFO) entropy_image_coding: Written 10823 bytes in ./encoded_0002.tif\n", + "(INFO) entropy_video_coding: Output bit-rate = 0.8512731481481481 bits/pixel\n" + ] + } + ], "source": [ "!python ../src/III.py encode -o /tmp/original.avi" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "66fdc894-015f-4652-8cee-814b8e1867d0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='decode', input='./encoded', output='./decoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, disable_subbands=False, quantizer='deadzone', QSS=32, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", + "(INFO) III: Using 2D-DCT codec\n", + "(INFO) III: Decoding frame ./encoded_0000 into ./decoded_0000.png\n", + "36 44\n", + "(INFO) III: Decoding frame ./encoded_0001 into ./decoded_0001.png\n", + "36 44\n", + "(INFO) III: Decoding frame ./encoded_0002 into ./decoded_0002.png\n", + "36 44\n", + "(INFO) entropy_video_coding: original_file = coastguard_352x288x30x420x300.avi\n", + "(INFO) entropy_video_coding: N_frames = 3\n", + "(INFO) entropy_video_coding: video height = 288 pixels\n", + "(INFO) entropy_video_coding: video width = 352 pixels\n", + "(INFO) entropy_video_coding: BPP = 0.8512731481481481\n", + "(INFO) entropy_video_coding: Number of encoded frames = 3\n", + "(INFO) entropy_video_coding: Video height (rows) = 288\n", + "(INFO) entropy_video_coding: Video width (columns) = 352\n", + "(INFO) entropy_video_coding: Mean RMSE = 9.99587068598698\n", + "(INFO) entropy_video_coding: J = R + D = 10.847143834135128\n", + "(INFO) entropy_video_coding: Output: ./decoded\n", + "(INFO) entropy_video_coding: Re-encoding frame 0 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 1 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 2 into /tmp/decoded.mp4\n" + ] + } + ], "source": [ "!python ../src/III.py decode" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "357fe763-ac02-41e5-bcd8-e02e36edf461", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: mplayer: command not found\n" + ] + } + ], "source": [ - "!ffplay -i /tmp/decoded_%04d.png -loop 0" + "!mplayer /tmp/decoded.mp4 -loop 0 -quiet" + ] + }, + { + "cell_type": "markdown", + "id": "c3dfd866-57ce-41ce-bd90-8f96dbd82eda", + "metadata": {}, + "source": [ + "### Default encoding and decoding (lena)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "29fbe5e2-254c-4b19-bf0e-d424a0c41ad7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rm: cannot remove '/tmp/*.png': No such file or directory\n", + "rm: cannot remove '/tmp/*.TIFF': No such file or directory\n" + ] + } + ], + "source": [ + "!rm /tmp/*.png /tmp/*.TIFF" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e9407913-d1fc-4fd2-bf5e-ae2a150198c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='encode', input='http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4', output='./encoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, Lambda=None, disable_subbands=False, quantizer='deadzone', QSS=32, entropy_image_codec='TIFF', encoded='/tmp/encoded', func=)\n", + "(INFO) III: Using 2D-DCT codec\n", + "(INFO) III: Encoding http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4\n", + "(INFO) III: Extracted frame ./encoded_original_0000.png (352, 288) RGB in=103164 out=216228\n", + "(INFO) entropy_image_coding: Written 31458 bytes in ./encoded_0000.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0001.png (352, 288) RGB in=72754 out=216501\n", + "(INFO) entropy_image_coding: Written 31629 bytes in ./encoded_0001.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0002.png (352, 288) RGB in=70089 out=216543\n", + "(INFO) entropy_image_coding: Written 31600 bytes in ./encoded_0002.tif\n", + "(INFO) entropy_video_coding: Output bit-rate = 2.490714436026936 bits/pixel\n" + ] + } + ], + "source": [ + "!python ../src/III.py encode" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "46ba71f2-c27f-4e81-9478-b98e166d960c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='decode', input='./encoded', output='./decoded', transform='2D-DCT', number_of_frames=3, block_size_DCT=8, color_transform='YCoCg', perceptual_quantization=False, disable_subbands=False, quantizer='deadzone', QSS=32, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", + "(INFO) III: Using 2D-DCT codec\n", + "(INFO) III: Decoding frame ./encoded_0000 into ./decoded_0000.png\n", + "36 44\n", + "(INFO) III: Decoding frame ./encoded_0001 into ./decoded_0001.png\n", + "36 44\n", + "(INFO) III: Decoding frame ./encoded_0002 into ./decoded_0002.png\n", + "36 44\n", + "(INFO) entropy_video_coding: original_file = http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4\n", + "(INFO) entropy_video_coding: N_frames = 3\n", + "(INFO) entropy_video_coding: video height = 288 pixels\n", + "(INFO) entropy_video_coding: video width = 352 pixels\n", + "(INFO) entropy_video_coding: BPP = 2.490714436026936\n", + "(INFO) entropy_video_coding: Number of encoded frames = 3\n", + "(INFO) entropy_video_coding: Video height (rows) = 288\n", + "(INFO) entropy_video_coding: Video width (columns) = 352\n", + "(INFO) entropy_video_coding: Mean RMSE = 14.420463220839627\n", + "(INFO) entropy_video_coding: J = R + D = 16.911177656866563\n", + "(INFO) entropy_video_coding: Output: ./decoded\n", + "(INFO) entropy_video_coding: Re-encoding frame 0 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 1 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 2 into /tmp/decoded.mp4\n" + ] + } + ], + "source": [ + "!python ../src/III.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "8a130edc-012d-4d6d-96d0-aee2b67e9945", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: mplayer: command not found\n" + ] + } + ], + "source": [ + "!mplayer /tmp/decoded.mp4 -loop 0 -quiet" ] }, { @@ -1498,30 +1516,120 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "a42485ad-beff-4ae7-bbe2-2f70fd4fa758", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='encode', input='mobile_352x288x30x420x300.mp4', output='./encoded', transform='2D-DWT', number_of_frames=3, levels=5, wavelet='db5', color_transform='YCoCg', quantizer='deadzone', QSS=32, entropy_image_codec='TIFF', encoded='/tmp/encoded', func=)\n", + "(INFO) 2D-DWT: levels = 5\n", + "(INFO) 2D-DWT: wavelet=db5 (Wavelet db5\n", + " Family name: Daubechies\n", + " Short name: db\n", + " Filters length: 10\n", + " Orthogonal: True\n", + " Biorthogonal: True\n", + " Symmetry: asymmetric\n", + " DWT: True\n", + " CWT: False)\n", + "(INFO) III: Using 2D-DWT codec\n", + "(INFO) III: Encoding mobile_352x288x30x420x300.mp4\n", + "Traceback (most recent call last):\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../src/III.py\", line 164, in \n", + " main.main(parser.parser, logging, CoDec)\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/main.py\", line 34, in main\n", + " args.func(codec)\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/parser.py\", line 14, in encode\n", + " return codec.encode()\n", + " ^^^^^^^^^^^^^^\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../src/III.py\", line 88, in encode\n", + " container = av.open(fn)\n", + " ^^^^^^^^^^^\n", + " File \"av/container/core.pyx\", line 482, in av.container.core.open\n", + " File \"av/container/core.pyx\", line 298, in av.container.core.Container.__cinit__\n", + " File \"av/container/core.pyx\", line 318, in av.container.core.Container.err_check\n", + " File \"av/error.pyx\", line 424, in av.error.err_check\n", + "av.error.FileNotFoundError: [Errno 2] No such file or directory: 'mobile_352x288x30x420x300.mp4'\n" + ] + } + ], "source": [ "!python ../src/III.py encode -T 2D-DWT -o /tmp/original.avi" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "645fa615-40ab-4d31-804c-2c23b4124f1b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='decode', input='./encoded', output='./decoded', transform='2D-DWT', number_of_frames=3, levels=5, wavelet='db5', color_transform='YCoCg', quantizer='deadzone', QSS=32, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", + "(INFO) 2D-DWT: levels = 5\n", + "(INFO) 2D-DWT: wavelet=db5 (Wavelet db5\n", + " Family name: Daubechies\n", + " Short name: db\n", + " Filters length: 10\n", + " Orthogonal: True\n", + " Biorthogonal: True\n", + " Symmetry: asymmetric\n", + " DWT: True\n", + " CWT: False)\n", + "(INFO) III: Using 2D-DWT codec\n", + "(INFO) III: Decoding frame ./encoded_0000 into ./decoded_0000.png\n", + "Traceback (most recent call last):\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../src/III.py\", line 164, in \n", + " main.main(parser.parser, logging, CoDec)\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/main.py\", line 34, in main\n", + " args.func(codec)\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/parser.py\", line 17, in decode\n", + " return codec.decode()\n", + " ^^^^^^^^^^^^^^\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../src/III.py\", line 157, in decode\n", + " self.transform_codec.decode()\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/2D-DWT.py\", line 109, in decode\n", + " return self.decode_fn(\n", + " ^^^^^^^^^^^^^^^\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/2D-DWT.py\", line 83, in decode_fn\n", + " decom_k = self.read_decom_fn(in_fn)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/2D-DWT.py\", line 208, in read_decom_fn\n", + " LL = self.decode_read_fn(fn_subband)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/src/entropy_image_coding.py\", line 102, in decode_read_fn\n", + " input_size = os.path.getsize(fn + self.file_extension)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"\", line 62, in getsize\n", + "FileNotFoundError: [Errno 2] No such file or directory: './encoded_0000_LL_5.tif'\n" + ] + } + ], "source": [ "!python ../src/III.py decode -T 2D-DWT" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "0ab73231-b966-45e2-819b-177ba4c6d834", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: mplayer: command not found\n" + ] + } + ], "source": [ "!ffplay -i /tmp/decoded_%04d.png -loop 0" ] @@ -1683,39 +1791,174 @@ "id": "1df7510a-19d4-4039-ad87-cb50b537b545", "metadata": {}, "source": [ - "### Using VQ\n", - "Working on it ..." + "### Using VQ" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, + "id": "a1954497-cd45-41bc-a5ab-8584500690a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rm: cannot remove '/tmp/*.png': No such file or directory\n", + "rm: cannot remove '/tmp/*.TIFF': No such file or directory\n", + "rm: cannot remove '/tmp/*.npz': No such file or directory\n" + ] + } + ], + "source": [ + "!rm /tmp/*.png /tmp/*.TIFF /tmp/*.npz" + ] + }, + { + "cell_type": "code", + "execution_count": 36, "id": "bf74617c-3aba-4bdd-9071-09e3cd8d6e1c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "main Namespace(debug=False, subparser_name='encode', input='coastguard_352x288x30x420x300.avi', output='./encoded', transform='VQ', number_of_frames=8, block_size_VQ=8, N_clusters=256, entropy_image_codec='TIFF', encoded='/tmp/encoded', func=)\n", + "(INFO) III: Using VQ codec\n", + "(INFO) III: Encoding coastguard_352x288x30x420x300.avi\n", + "(INFO) III: Extracted frame ./encoded_original_0000.png (352, 288) RGB in=77644 out=176121\n", + "(INFO) entropy_image_coding: Written 1831 bytes in ./encoded_0000.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0001.png (352, 288) RGB in=64282 out=176149\n", + "(INFO) entropy_image_coding: Written 1821 bytes in ./encoded_0001.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0002.png (352, 288) RGB in=63848 out=175820\n", + "(INFO) entropy_image_coding: Written 1810 bytes in ./encoded_0002.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0003.png (352, 288) RGB in=63360 out=175043\n", + "(INFO) entropy_image_coding: Written 1798 bytes in ./encoded_0003.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0004.png (352, 288) RGB in=65709 out=175574\n", + "(INFO) entropy_image_coding: Written 1808 bytes in ./encoded_0004.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0005.png (352, 288) RGB in=63297 out=175807\n", + "(INFO) entropy_image_coding: Written 1826 bytes in ./encoded_0005.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0006.png (352, 288) RGB in=64756 out=176099\n", + "(INFO) entropy_image_coding: Written 1814 bytes in ./encoded_0006.tif\n", + "(INFO) III: Extracted frame ./encoded_original_0007.png (352, 288) RGB in=64490 out=175913\n", + "(INFO) entropy_image_coding: Written 1815 bytes in ./encoded_0007.tif\n", + "(INFO) entropy_video_coding: Output bit-rate = 0.14325875946969696 bits/pixel\n" + ] + } + ], "source": [ "!python ../src/III.py encode -N 8 -a VQ -o /tmp/original.avi" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "f32e287a-5739-4796-a5bd-7e75af885d79", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Denoising filter = no_filter\n", + "main Namespace(debug=False, subparser_name='decode', input='./encoded', output='./decoded', transform='VQ', number_of_frames=8, block_size_VQ=8, N_clusters=256, filter='no_filter', entropy_image_codec='TIFF', encoded='/tmp/encoded', decoded='/tmp/decoded.png', func=)\n", + "(INFO) III: Using VQ codec\n", + "(INFO) III: Decoding frame ./encoded_0000 into ./decoded_0000.png\n", + "(INFO) III: Decoding frame ./encoded_0001 into ./decoded_0001.png\n", + "(INFO) III: Decoding frame ./encoded_0002 into ./decoded_0002.png\n", + "(INFO) III: Decoding frame ./encoded_0003 into ./decoded_0003.png\n", + "(INFO) III: Decoding frame ./encoded_0004 into ./decoded_0004.png\n", + "(INFO) III: Decoding frame ./encoded_0005 into ./decoded_0005.png\n", + "(INFO) III: Decoding frame ./encoded_0006 into ./decoded_0006.png\n", + "(INFO) III: Decoding frame ./encoded_0007 into ./decoded_0007.png\n", + "(INFO) entropy_video_coding: original_file = coastguard_352x288x30x420x300.avi\n", + "(INFO) entropy_video_coding: N_frames = 8\n", + "(INFO) entropy_video_coding: video height = 288 pixels\n", + "(INFO) entropy_video_coding: video width = 352 pixels\n", + "(INFO) entropy_video_coding: BPP = 0.14325875946969696\n", + "(INFO) entropy_video_coding: Number of encoded frames = 8\n", + "(INFO) entropy_video_coding: Video height (rows) = 288\n", + "(INFO) entropy_video_coding: Video width (columns) = 352\n", + "(INFO) entropy_video_coding: Mean RMSE = 11.378701425947101\n", + "(INFO) entropy_video_coding: J = R + D = 11.521960185416798\n", + "(INFO) entropy_video_coding: Output: ./decoded\n", + "(INFO) entropy_video_coding: Re-encoding frame 0 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 1 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 2 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 3 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 4 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 5 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 6 into /tmp/decoded.mp4\n", + "(INFO) entropy_video_coding: Re-encoding frame 7 into /tmp/decoded.mp4\n" + ] + } + ], "source": [ "!python ../src/III.py decode -N 8 -a VQ " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "4c723ebb-4b74-4792-be4b-b583cd509aee", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/bin/bash: line 1: mplayer: command not found\n" + ] + } + ], "source": [ "!ffplay -i /tmp/decoded_%04d.png -loop 0" ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "aa596420-0b7f-41e0-a00e-eaecab8a35c7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../III.py': [Errno 2] No such file or directory\n" + ] + } + ], + "source": [ + "!python ../III.py encode -T deadzone" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "619dc7fc-9c44-4bcd-b260-b4633a8ba2f9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: can't open file '/mnt/c/Users/zerbo/Desktop/ual/multimedia/1/repo/VCF/notebooks/../III.py': [Errno 2] No such file or directory\n" + ] + } + ], + "source": [ + "!python ../III.py decode -N 1 -T deadzone" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ab0b210-9abb-4d81-832f-64d573b69ddd", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1734,7 +1977,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.3" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/notebooks/LloydMax.ipynb b/notebooks/LloydMax.ipynb index f71b50b7..39732ec8 100644 --- a/notebooks/LloydMax.ipynb +++ b/notebooks/LloydMax.ipynb @@ -353,7 +353,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.3" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/notebooks/MCTF.ipynb b/notebooks/MCTF.ipynb new file mode 100644 index 00000000..182e6c6a --- /dev/null +++ b/notebooks/MCTF.ipynb @@ -0,0 +1,2176 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Video MCTF coding" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overwriting ../src/MCTF.py\n" + ] + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the current cell or a previous cell. \n", + "\u001b[1;31mPlease review the code in the cell(s) to identify a possible cause of the failure. \n", + "\u001b[1;31mClick here for more info. \n", + "\u001b[1;31mView Jupyter log for further details." + ] + } + ], + "source": [ + "%%writefile ../src/MCTF.py\n", + "'''MCTF: Motion-Compensated Temporal Filtering with Hierarchical B-frames.\n", + "\n", + "Implementation features:\n", + "- Bidirectional prediction for B-frames\n", + "- Hierarchical B-frame structure\n", + "- Integration with VCF spatial transforms (2D-DCT, 2D-DWT, etc.)\n", + "- Reuses VCF quantizers, color transforms, and entropy codecs\n", + "authors: Youssef Zerbouh, Hamza El Qadiri\n", + "'''\n", + "\n", + "import sys\n", + "import io\n", + "import os\n", + "import tempfile\n", + "import logging\n", + "import importlib\n", + "import math\n", + "from typing import List, Tuple, Dict, Optional\n", + "from dataclasses import dataclass\n", + "from enum import Enum\n", + "\n", + "import numpy as np\n", + "import cv2\n", + "import av\n", + "from PIL import Image\n", + "from concurrent.futures import ThreadPoolExecutor\n", + "import multiprocessing as mp\n", + "\n", + "# VCF Framework\n", + "with open(os.path.join(tempfile.gettempdir(), \"description.txt\"), 'w') as f:\n", + " f.write(__doc__)\n", + "\n", + "import main\n", + "import parser\n", + "import entropy_video_coding as EVC\n", + "\n", + "# =============================================================================\n", + "# Constants and Configuration\n", + "# =============================================================================\n", + "\n", + "class FrameType(Enum):\n", + " I = \"I\" # Intra frame\n", + " P = \"P\" # Predicted frame (forward only)\n", + " B = \"B\" # Bidirectional frame\n", + "\n", + "@dataclass\n", + "class MotionVector:\n", + " \"\"\"Motion vector with cost information.\"\"\"\n", + " dx: int\n", + " dy: int\n", + " sad: float\n", + " bits: float\n", + " cost: float\n", + " ref_idx: int # Reference frame index\n", + "\n", + "@dataclass\n", + "class EncodedFrame:\n", + " \"\"\"Frame encoding information.\"\"\"\n", + " frame_idx: int\n", + " frame_type: FrameType\n", + " display_order: int\n", + " encoding_order: int\n", + " references: List[int] # Reference frame indices\n", + " data: Optional[np.ndarray] = None\n", + " mv_field: Optional[np.ndarray] = None\n", + " residual: Optional[np.ndarray] = None\n", + "\n", + "# =============================================================================\n", + "# Arguments\n", + "# =============================================================================\n", + "\n", + "DEFAULT_ENCODE_OUTPUT_PREFIX = os.path.join(tempfile.gettempdir(), \"encoded\")\n", + "DEFAULT_DECODE_OUTPUT_PREFIX = os.path.join(tempfile.gettempdir(), \"decoded\")\n", + "\n", + "# Encoder - MCTF-specific parameters only\n", + "# Note: -T (transform) is needed but not in VCF base parser, so we add it here\n", + "parser.parser_encode.add_argument(\"-T\", \"--transform\", type=str,\n", + " help=f\"2D spatial transform for residuals (default: {EVC.DEFAULT_TRANSFORM})\",\n", + " default=EVC.DEFAULT_TRANSFORM)\n", + "parser.parser_encode.add_argument(\"-M\", \"--block_size_ME\", type=parser.int_or_str,\n", + " help=\"Block size for motion estimation (default: 16)\",\n", + " default=16)\n", + "parser.parser_encode.add_argument(\"-S\", \"--search_range\", type=parser.int_or_str,\n", + " help=\"Search range in pixels (default: 32)\",\n", + " default=32)\n", + "parser.parser_encode.add_argument(\"--fast\", action=\"store_true\",\n", + " help=\"Use fast motion estimation (diamond search)\")\n", + "parser.parser_encode.add_argument(\"--gop_size\", type=int,\n", + " help=\"GOP size (default: 16)\",\n", + " default=16)\n", + "parser.parser_encode.add_argument(\"--num_gops\", type=int,\n", + " help=\"Number of GOPs to encode (default: 1)\",\n", + " default=1)\n", + "parser.parser_encode.add_argument(\"--max_b_frames\", type=int,\n", + " help=\"Maximum consecutive B-frames (default: 10, minimum for prediction)\",\n", + " default=10)\n", + "parser.parser_encode.add_argument(\"--hierarchical\", action=\"store_true\",\n", + " help=\"Use hierarchical B-frame structure\")\n", + "parser.parser_encode.add_argument(\"--lambda_rd\", type=float,\n", + " help=\"Lagrange multiplier for RD optimization (default: 0.92*QSS). \"\n", + " \"Higher = favor rate, lower = favor distortion. 0 = pure SAD.\",\n", + " default=None)\n", + "\n", + "# Decoder - add transform parameter\n", + "parser.parser_decode.add_argument(\"-T\", \"--transform\", type=str,\n", + " help=f\"2D spatial transform for residuals (default: {EVC.DEFAULT_TRANSFORM})\",\n", + " default=EVC.DEFAULT_TRANSFORM)\n", + "\n", + "# Parse and import transform\n", + "args = parser.parser.parse_known_args()[0]\n", + "\n", + "# Get transform name - use VCF's default if not specified\n", + "transform_name = getattr(args, 'transform', EVC.DEFAULT_TRANSFORM)\n", + "\n", + "if __debug__:\n", + " if args.debug:\n", + " print(f\"MCTF: Importing {transform_name}\")\n", + "\n", + "try:\n", + " transform = importlib.import_module(transform_name)\n", + "except ImportError as e:\n", + " print(f\"Error: Could not find {transform_name} module ({e})\")\n", + " sys.exit(1)\n", + "\n", + "# =============================================================================\n", + "# Motion Estimation Utilities\n", + "# =============================================================================\n", + "\n", + "def compute_sad(block1: np.ndarray, block2: np.ndarray) -> float:\n", + " \"\"\"Compute Sum of Absolute Differences between two blocks.\"\"\"\n", + " return float(np.sum(np.abs(block1.astype(np.int16) - block2.astype(np.int16))))\n", + "\n", + "def estimate_mv_bits(dx: int, dy: int) -> float:\n", + " \"\"\"Estimate bits to encode a motion vector using Exp-Golomb-like model.\n", + " \n", + " Each component costs 2·floor(log2(|v| + 1)) + 1 bits.\n", + " Zero MV = 2 bits total (cheapest), large MV = expensive.\n", + " \"\"\"\n", + " def _component_bits(v):\n", + " return 2.0 * math.floor(math.log2(abs(v) + 1)) + 1.0\n", + " return _component_bits(dx) + _component_bits(dy)\n", + "\n", + "# Bits to signal prediction mode in a B-frame block:\n", + "# fwd-only or bwd-only = 2 bits (1 bit skip-bi + 1 bit direction)\n", + "# bidirectional = 3 bits (1 bit skip-bi + 2 MVs flag)\n", + "MODE_BITS = {0: 2.0, 1: 2.0, 2: 3.0}\n", + "\n", + "# =============================================================================\n", + "# Motion Estimation\n", + "# =============================================================================\n", + "\n", + "def _diamond_search(ref_frame, curr_block, i, j, bs, sr=32, lmbda=0.0):\n", + " \"\"\"Diamond search pattern for motion estimation with RD cost.\n", + " \n", + " Minimises J = SAD + λ · estimate_mv_bits(dx, dy).\n", + " Returns (best_mv, best_sad) — the raw SAD of the winner\n", + " so callers can still use it for further mode decisions.\n", + " \"\"\"\n", + " h, w = ref_frame.shape[:2]\n", + " \n", + " # Large diamond pattern\n", + " ldp = [(0, -2), (-1, -1), (1, -1), (-2, 0), (2, 0), (-1, 1), (1, 1), (0, 2)]\n", + " # Small diamond pattern\n", + " sdp = [(0, -1), (-1, 0), (1, 0), (0, 1)]\n", + " \n", + " cx, cy = j, i\n", + " best_mv = (0, 0)\n", + " best_sad = float('inf')\n", + " best_cost = float('inf')\n", + " \n", + " # Evaluate center position (MV = (0,0), cheapest rate)\n", + " if 0 <= cy and cy + bs <= h and 0 <= cx and cx + bs <= w:\n", + " best_sad = compute_sad(curr_block, ref_frame[cy:cy+bs, cx:cx+bs])\n", + " best_cost = best_sad + lmbda * estimate_mv_bits(0, 0)\n", + " \n", + " # Large diamond search\n", + " improved = True\n", + " while improved:\n", + " improved = False\n", + " for ddx, ddy in ldp:\n", + " ry, rx = cy + ddy, cx + ddx\n", + " if (ry < 0 or ry + bs > h or rx < 0 or rx + bs > w or\n", + " abs(rx - j) > sr or abs(ry - i) > sr):\n", + " continue\n", + " \n", + " sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs])\n", + " mv_dx, mv_dy = rx - j, ry - i\n", + " cost = sad + lmbda * estimate_mv_bits(mv_dx, mv_dy)\n", + " \n", + " if cost < best_cost:\n", + " best_sad = sad\n", + " best_cost = cost\n", + " best_mv = (mv_dx, mv_dy)\n", + " cx, cy = rx, ry\n", + " improved = True\n", + " \n", + " # Small diamond search refinement\n", + " improved = True\n", + " while improved:\n", + " improved = False\n", + " for ddx, ddy in sdp:\n", + " ry, rx = cy + ddy, cx + ddx\n", + " if (ry < 0 or ry + bs > h or rx < 0 or rx + bs > w or\n", + " abs(rx - j) > sr or abs(ry - i) > sr):\n", + " continue\n", + " \n", + " sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs])\n", + " mv_dx, mv_dy = rx - j, ry - i\n", + " cost = sad + lmbda * estimate_mv_bits(mv_dx, mv_dy)\n", + " \n", + " if cost < best_cost:\n", + " best_sad = sad\n", + " best_cost = cost\n", + " best_mv = (mv_dx, mv_dy)\n", + " cx, cy = rx, ry\n", + " improved = True\n", + " \n", + " return best_mv, best_sad\n", + "\n", + "def _exhaustive_search(ref_frame, curr_block, i, j, bs, sr=32, lmbda=0.0):\n", + " \"\"\"Exhaustive search for motion estimation with RD cost.\n", + " \n", + " Minimises J = SAD + λ · estimate_mv_bits(dx, dy).\n", + " \"\"\"\n", + " h, w = ref_frame.shape[:2]\n", + " best_mv = (0, 0)\n", + " best_sad = float('inf')\n", + " best_cost = float('inf')\n", + " \n", + " for dy in range(-sr, sr + 1):\n", + " for dx in range(-sr, sr + 1):\n", + " ry, rx = i + dy, j + dx\n", + " if 0 <= ry and ry + bs <= h and 0 <= rx and rx + bs <= w:\n", + " sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs])\n", + " cost = sad + lmbda * estimate_mv_bits(dx, dy)\n", + " \n", + " if cost < best_cost:\n", + " best_sad = sad\n", + " best_cost = cost\n", + " best_mv = (dx, dy)\n", + " \n", + " return best_mv, best_sad\n", + "\n", + "def _process_block(args_tuple):\n", + " \"\"\"Process a single block for motion estimation (for parallel execution).\"\"\"\n", + " ref, curr_block, i, j, bs, sr, fast, lmbda = args_tuple\n", + " \n", + " if fast:\n", + " mv, sad = _diamond_search(ref, curr_block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv, sad = _exhaustive_search(ref, curr_block, i, j, bs, sr, lmbda)\n", + " \n", + " return mv, sad\n", + "\n", + "def _process_row(args_tuple):\n", + " \"\"\"Process one row of blocks for motion estimation.\"\"\"\n", + " ref, curr, i, bs, sr, w, fast, lmbda = args_tuple\n", + " mvs = []\n", + " sads = []\n", + " \n", + " for j in range(0, w - bs + 1, bs):\n", + " block = curr[i:i+bs, j:j+bs]\n", + " \n", + " if fast:\n", + " mv, sad = _diamond_search(ref, block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv, sad = _exhaustive_search(ref, block, i, j, bs, sr, lmbda)\n", + " \n", + " mvs.append(mv)\n", + " sads.append(sad)\n", + " \n", + " return mvs, sads\n", + "\n", + "def block_matching(ref_frame, curr_frame, bs=16, sr=32, fast=True, lmbda=0.0):\n", + " \"\"\"Block-based motion estimation with RD-optimised MV selection.\n", + " \n", + " Each block minimises J = SAD + λ · R_mv instead of pure SAD.\n", + " \"\"\"\n", + " ref_gray = cv2.cvtColor(ref_frame, cv2.COLOR_RGB2GRAY)\n", + " curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_RGB2GRAY)\n", + " h, w = ref_gray.shape\n", + " \n", + " mv_h = (h - bs) // bs + 1\n", + " mv_w = (w - bs) // bs + 1\n", + " mv_field = np.zeros((mv_h, mv_w, 2), dtype=np.float32)\n", + " \n", + " # For exhaustive search, use multiprocessing; for fast search, use threading\n", + " if not fast and sr > 16:\n", + " # Exhaustive search with large search range - use multiprocessing\n", + " from multiprocessing import Pool\n", + " \n", + " # Create block tasks\n", + " block_args = []\n", + " for i in range(0, h - bs + 1, bs):\n", + " for j in range(0, w - bs + 1, bs):\n", + " block = curr_gray[i:i+bs, j:j+bs]\n", + " block_args.append((ref_gray, block, i, j, bs, sr, fast, lmbda))\n", + " \n", + " # Process blocks in parallel\n", + " with Pool(processes=mp.cpu_count()) as pool:\n", + " results = pool.map(_process_block, block_args)\n", + " \n", + " # Reshape results into MV field\n", + " idx = 0\n", + " for ri in range(mv_h):\n", + " for ci in range(mv_w):\n", + " mv_field[ri, ci] = results[idx][0]\n", + " idx += 1\n", + " else:\n", + " # Fast search or small search range - use threading (row-based)\n", + " row_args = [(ref_gray, curr_gray, i, bs, sr, w, fast, lmbda) \n", + " for i in range(0, h - bs + 1, bs)]\n", + " \n", + " with ThreadPoolExecutor(max_workers=max(1, mp.cpu_count() - 1)) as ex:\n", + " results = list(ex.map(_process_row, row_args))\n", + " \n", + " for ri, (row_mvs, row_sads) in enumerate(results):\n", + " for ci, mv in enumerate(row_mvs):\n", + " mv_field[ri, ci] = mv\n", + " \n", + " return mv_field\n", + "\n", + "# =============================================================================\n", + "# Bidirectional Motion Estimation\n", + "# =============================================================================\n", + "\n", + "def _process_bidir_block(args_tuple):\n", + " \"\"\"Process bidirectional ME for a single block with RD-optimised mode decision.\n", + " \n", + " Mode decision minimises J = SAD + λ · (mv_bits + mode_bits).\n", + " \"\"\"\n", + " past_gray, future_gray, curr_block, i, j, bs, sr, fast, h, w, lmbda = args_tuple\n", + " \n", + " # Forward prediction (from past)\n", + " if fast:\n", + " mv_fwd, sad_fwd = _diamond_search(past_gray, curr_block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv_fwd, sad_fwd = _exhaustive_search(past_gray, curr_block, i, j, bs, sr, lmbda)\n", + " \n", + " # Backward prediction (from future)\n", + " if fast:\n", + " mv_bwd, sad_bwd = _diamond_search(future_gray, curr_block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv_bwd, sad_bwd = _exhaustive_search(future_gray, curr_block, i, j, bs, sr, lmbda)\n", + " \n", + " # Bidirectional (average of both predictions)\n", + " ry_fwd = max(0, min(i + int(mv_fwd[1]), h - bs))\n", + " rx_fwd = max(0, min(j + int(mv_fwd[0]), w - bs))\n", + " ry_bwd = max(0, min(i + int(mv_bwd[1]), h - bs))\n", + " rx_bwd = max(0, min(j + int(mv_bwd[0]), w - bs))\n", + " \n", + " pred_fwd = past_gray[ry_fwd:ry_fwd+bs, rx_fwd:rx_fwd+bs]\n", + " pred_bwd = future_gray[ry_bwd:ry_bwd+bs, rx_bwd:rx_bwd+bs]\n", + " pred_bi = ((pred_fwd.astype(np.int16) + pred_bwd.astype(np.int16)) // 2).astype(np.uint8)\n", + " \n", + " sad_bi = compute_sad(curr_block, pred_bi)\n", + " \n", + " # RD cost for each mode: J = SAD + λ · (mv_bits + mode_bits)\n", + " cost_fwd = sad_fwd + lmbda * (estimate_mv_bits(*mv_fwd) + MODE_BITS[0])\n", + " cost_bwd = sad_bwd + lmbda * (estimate_mv_bits(*mv_bwd) + MODE_BITS[1])\n", + " cost_bi = sad_bi + lmbda * (estimate_mv_bits(*mv_fwd) + estimate_mv_bits(*mv_bwd) + MODE_BITS[2])\n", + " \n", + " # Choose best mode based on RD cost\n", + " if cost_fwd <= cost_bwd and cost_fwd <= cost_bi:\n", + " mode = 0 # Forward\n", + " mv_f = mv_fwd\n", + " mv_b = (0, 0)\n", + " elif cost_bwd <= cost_bi:\n", + " mode = 1 # Backward\n", + " mv_f = (0, 0)\n", + " mv_b = mv_bwd\n", + " else:\n", + " mode = 2 # Bidirectional\n", + " mv_f = mv_fwd\n", + " mv_b = mv_bwd\n", + " \n", + " return mv_f, mv_b, mode\n", + "\n", + "def bidirectional_me(ref_past, ref_future, curr_frame, bs=16, sr=32, fast=True, lmbda=0.0):\n", + " \"\"\"\n", + " Bidirectional motion estimation for B-frames with RD-optimised mode decision.\n", + " \n", + " MV selection minimises J = SAD + λ · R_mv.\n", + " Mode decision minimises J = SAD + λ · (R_mv + R_mode).\n", + " Returns forward MV, backward MV, and best mode (forward/backward/bi).\n", + " \"\"\"\n", + " h, w = curr_frame.shape[:2]\n", + " curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_RGB2GRAY)\n", + " past_gray = cv2.cvtColor(ref_past, cv2.COLOR_RGB2GRAY)\n", + " future_gray = cv2.cvtColor(ref_future, cv2.COLOR_RGB2GRAY)\n", + " \n", + " mv_h = (h - bs) // bs + 1\n", + " mv_w = (w - bs) // bs + 1\n", + " \n", + " mv_forward = np.zeros((mv_h, mv_w, 2), dtype=np.float32)\n", + " mv_backward = np.zeros((mv_h, mv_w, 2), dtype=np.float32)\n", + " mode = np.zeros((mv_h, mv_w), dtype=np.uint8) # 0=fwd, 1=bwd, 2=bi\n", + " \n", + " # For exhaustive search, use multiprocessing\n", + " if not fast and sr > 16:\n", + " from multiprocessing import Pool\n", + " \n", + " # Create block tasks\n", + " block_args = []\n", + " for i in range(0, h - bs + 1, bs):\n", + " for j in range(0, w - bs + 1, bs):\n", + " curr_block = curr_gray[i:i+bs, j:j+bs]\n", + " block_args.append((past_gray, future_gray, curr_block, i, j, bs, sr, fast, h, w, lmbda))\n", + " \n", + " # Process blocks in parallel\n", + " with Pool(processes=mp.cpu_count()) as pool:\n", + " results = pool.map(_process_bidir_block, block_args)\n", + " \n", + " # Reshape results\n", + " idx = 0\n", + " for ri in range(mv_h):\n", + " for ci in range(mv_w):\n", + " mv_forward[ri, ci] = results[idx][0]\n", + " mv_backward[ri, ci] = results[idx][1]\n", + " mode[ri, ci] = results[idx][2]\n", + " idx += 1\n", + " else:\n", + " # Fast search - use sequential processing\n", + " for i in range(0, h - bs + 1, bs):\n", + " for j in range(0, w - bs + 1, bs):\n", + " curr_block = curr_gray[i:i+bs, j:j+bs]\n", + " \n", + " # Forward prediction (from past)\n", + " if fast:\n", + " mv_fwd, sad_fwd = _diamond_search(past_gray, curr_block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv_fwd, sad_fwd = _exhaustive_search(past_gray, curr_block, i, j, bs, sr, lmbda)\n", + " \n", + " # Backward prediction (from future)\n", + " if fast:\n", + " mv_bwd, sad_bwd = _diamond_search(future_gray, curr_block, i, j, bs, sr, lmbda)\n", + " else:\n", + " mv_bwd, sad_bwd = _exhaustive_search(future_gray, curr_block, i, j, bs, sr, lmbda)\n", + " \n", + " # Bidirectional (average of both)\n", + " ry_fwd = max(0, min(i + int(mv_fwd[1]), h - bs))\n", + " rx_fwd = max(0, min(j + int(mv_fwd[0]), w - bs))\n", + " ry_bwd = max(0, min(i + int(mv_bwd[1]), h - bs))\n", + " rx_bwd = max(0, min(j + int(mv_bwd[0]), w - bs))\n", + " \n", + " pred_fwd = past_gray[ry_fwd:ry_fwd+bs, rx_fwd:rx_fwd+bs]\n", + " pred_bwd = future_gray[ry_bwd:ry_bwd+bs, rx_bwd:rx_bwd+bs]\n", + " pred_bi = ((pred_fwd.astype(np.int16) + pred_bwd.astype(np.int16)) // 2).astype(np.uint8)\n", + " \n", + " sad_bi = compute_sad(curr_block, pred_bi)\n", + " \n", + " # RD cost for each mode: J = SAD + λ · (mv_bits + mode_bits)\n", + " cost_fwd = sad_fwd + lmbda * (estimate_mv_bits(*mv_fwd) + MODE_BITS[0])\n", + " cost_bwd = sad_bwd + lmbda * (estimate_mv_bits(*mv_bwd) + MODE_BITS[1])\n", + " cost_bi = sad_bi + lmbda * (estimate_mv_bits(*mv_fwd) + estimate_mv_bits(*mv_bwd) + MODE_BITS[2])\n", + " \n", + " # Choose best mode based on RD cost\n", + " ri, ci = i // bs, j // bs\n", + " if cost_fwd <= cost_bwd and cost_fwd <= cost_bi:\n", + " mode[ri, ci] = 0 # Forward\n", + " mv_forward[ri, ci] = mv_fwd\n", + " mv_backward[ri, ci] = (0, 0)\n", + " elif cost_bwd <= cost_bi:\n", + " mode[ri, ci] = 1 # Backward\n", + " mv_forward[ri, ci] = (0, 0)\n", + " mv_backward[ri, ci] = mv_bwd\n", + " else:\n", + " mode[ri, ci] = 2 # Bidirectional\n", + " mv_forward[ri, ci] = mv_fwd\n", + " mv_backward[ri, ci] = mv_bwd\n", + " \n", + " return mv_forward, mv_backward, mode\n", + "\n", + "# =============================================================================\n", + "# Motion Compensation\n", + "# =============================================================================\n", + "\n", + "def motion_compensate(frame, mv_field, bs=16, direction=1):\n", + " \"\"\"Apply motion compensation (single reference).\"\"\"\n", + " h, w = frame.shape[:2]\n", + " comp = np.zeros_like(frame)\n", + " \n", + " for i in range(0, h - bs + 1, bs):\n", + " for j in range(0, w - bs + 1, bs):\n", + " mv = mv_field[i // bs, j // bs] * direction\n", + " ry = int(np.clip(i + mv[1], 0, h - bs))\n", + " rx = int(np.clip(j + mv[0], 0, w - bs))\n", + " comp[i:i+bs, j:j+bs] = frame[ry:ry+bs, rx:rx+bs]\n", + " \n", + " # Handle boundaries\n", + " if h % bs != 0:\n", + " comp[-(h % bs):, :] = frame[-(h % bs):, :]\n", + " if w % bs != 0:\n", + " comp[:, -(w % bs):] = frame[:, -(w % bs):]\n", + " \n", + " return comp\n", + "\n", + "def motion_compensate_bidirectional(ref_past, ref_future, mv_fwd, mv_bwd, \n", + " mode, bs=16):\n", + " \"\"\"Apply bidirectional motion compensation.\"\"\"\n", + " h, w = ref_past.shape[:2]\n", + " comp = np.zeros_like(ref_past)\n", + " \n", + " for i in range(0, h - bs + 1, bs):\n", + " for j in range(0, w - bs + 1, bs):\n", + " ri, ci = i // bs, j // bs\n", + " m = mode[ri, ci]\n", + " \n", + " if m == 0: # Forward only\n", + " mv = mv_fwd[ri, ci]\n", + " ry = int(np.clip(i + mv[1], 0, h - bs))\n", + " rx = int(np.clip(j + mv[0], 0, w - bs))\n", + " comp[i:i+bs, j:j+bs] = ref_past[ry:ry+bs, rx:rx+bs]\n", + " \n", + " elif m == 1: # Backward only\n", + " mv = mv_bwd[ri, ci]\n", + " ry = int(np.clip(i + mv[1], 0, h - bs))\n", + " rx = int(np.clip(j + mv[0], 0, w - bs))\n", + " comp[i:i+bs, j:j+bs] = ref_future[ry:ry+bs, rx:rx+bs]\n", + " \n", + " else: # Bidirectional\n", + " mv_f = mv_fwd[ri, ci]\n", + " mv_b = mv_bwd[ri, ci]\n", + " ry_f = int(np.clip(i + mv_f[1], 0, h - bs))\n", + " rx_f = int(np.clip(j + mv_f[0], 0, w - bs))\n", + " ry_b = int(np.clip(i + mv_b[1], 0, h - bs))\n", + " rx_b = int(np.clip(j + mv_b[0], 0, w - bs))\n", + " \n", + " pred_f = ref_past[ry_f:ry_f+bs, rx_f:rx_f+bs]\n", + " pred_b = ref_future[ry_b:ry_b+bs, rx_b:rx_b+bs]\n", + " comp[i:i+bs, j:j+bs] = ((pred_f.astype(np.int16) + \n", + " pred_b.astype(np.int16)) // 2).astype(np.uint8)\n", + " \n", + " # Handle boundaries\n", + " if h % bs != 0:\n", + " comp[-(h % bs):, :] = ref_past[-(h % bs):, :]\n", + " if w % bs != 0:\n", + " comp[:, -(w % bs):] = ref_past[:, -(w % bs):]\n", + " \n", + " return comp\n", + "\n", + "# =============================================================================\n", + "# GOP Structure Management\n", + "# =============================================================================\n", + "\n", + "def create_hierarchical_gop(gop_size: int, max_b_frames: int = 3) -> List[EncodedFrame]:\n", + " \"\"\"\n", + " Create hierarchical B-frame GOP structure.\n", + " \n", + " Example for GOP=8, max_b=3:\n", + " Display: 0 1 2 3 4 5 6 7 8\n", + " Type: I B B B P B B B I\n", + " Encoding: 0 4 2 1 3 8 6 5 7\n", + " Level: 0 2 1 2 0 2 1 2 0\n", + " \"\"\"\n", + " frames = []\n", + " display_order = 0\n", + " \n", + " # I-frame at start\n", + " frames.append(EncodedFrame(\n", + " frame_idx=0,\n", + " frame_type=FrameType.I,\n", + " display_order=0,\n", + " encoding_order=0,\n", + " references=[]\n", + " ))\n", + " display_order += 1\n", + " \n", + " # P or I frame at end of GOP\n", + " if gop_size > 1:\n", + " frames.append(EncodedFrame(\n", + " frame_idx=gop_size - 1,\n", + " frame_type=FrameType.P,\n", + " display_order=gop_size - 1,\n", + " encoding_order=1,\n", + " references=[0]\n", + " ))\n", + " \n", + " # Hierarchical B-frames\n", + " def add_hierarchical_b(start_ref, end_ref, level, encoding_order):\n", + " if end_ref - start_ref <= 1:\n", + " return encoding_order\n", + " \n", + " mid = (start_ref + end_ref) // 2\n", + " frames.append(EncodedFrame(\n", + " frame_idx=mid,\n", + " frame_type=FrameType.B,\n", + " display_order=mid,\n", + " encoding_order=encoding_order,\n", + " references=[start_ref, end_ref]\n", + " ))\n", + " encoding_order += 1\n", + " \n", + " if level < max_b_frames:\n", + " encoding_order = add_hierarchical_b(start_ref, mid, level + 1, encoding_order)\n", + " encoding_order = add_hierarchical_b(mid, end_ref, level + 1, encoding_order)\n", + " \n", + " return encoding_order\n", + " \n", + " add_hierarchical_b(0, gop_size - 1, 1, 2)\n", + " \n", + " # Sort by encoding order\n", + " frames.sort(key=lambda x: x.encoding_order)\n", + " \n", + " return frames\n", + "\n", + "def create_simple_gop(gop_size: int, max_b_frames: int = 3) -> List[EncodedFrame]:\n", + " \"\"\"\n", + " Create simple IBBP GOP structure.\n", + " \n", + " Example for GOP=8, max_b=3:\n", + " Display: 0 1 2 3 4 5 6 7 8\n", + " Type: I B B B P B B B I\n", + " Encoding: 0 4 1 2 3 8 5 6 7\n", + " \"\"\"\n", + " frames = []\n", + " \n", + " # I-frame at start\n", + " frames.append(EncodedFrame(\n", + " frame_idx=0,\n", + " frame_type=FrameType.I,\n", + " display_order=0,\n", + " encoding_order=0,\n", + " references=[]\n", + " ))\n", + " \n", + " # P or I frame at end of GOP\n", + " if gop_size > 1:\n", + " anchor_pos = gop_size - 1\n", + " frames.append(EncodedFrame(\n", + " frame_idx=anchor_pos,\n", + " frame_type=FrameType.P,\n", + " display_order=anchor_pos,\n", + " encoding_order=1,\n", + " references=[0] # Reference I-frame\n", + " ))\n", + " \n", + " # All B-frames reference I and P\n", + " encoding_order = 2\n", + " for b_pos in range(1, anchor_pos):\n", + " frames.append(EncodedFrame(\n", + " frame_idx=b_pos,\n", + " frame_type=FrameType.B,\n", + " display_order=b_pos,\n", + " encoding_order=encoding_order,\n", + " references=[0, anchor_pos] # All B-frames reference (I, P)\n", + " ))\n", + " encoding_order += 1\n", + " \n", + " # Sort by encoding order\n", + " frames.sort(key=lambda x: x.encoding_order)\n", + " \n", + " return frames\n", + "\n", + "# =============================================================================\n", + "# CoDec Class\n", + "# =============================================================================\n", + "\n", + "class CoDec(EVC.CoDec):\n", + " \"\"\"MCTF Codec with hierarchical B-frames using VCF framework transforms.\"\"\"\n", + "\n", + " def __init__(self, args):\n", + " logging.debug(\"trace\")\n", + " super().__init__(args)\n", + " self.transform_codec = transform.CoDec(args)\n", + " logging.info(f\"Using {args.transform} spatial transform for residuals\")\n", + " \n", + " # Pass QSS to transform codec if available\n", + " if hasattr(args, 'QSS'):\n", + " self.transform_codec.args.QSS = args.QSS\n", + " logging.info(f\"Set transform codec QSS to {args.QSS}\")\n", + " # Recreate the quantizer with the correct QSS\n", + " # (transform codec's __init__ already created it with possibly wrong QSS)\n", + " try:\n", + " from scalar_quantization.deadzone_quantization import Deadzone_Quantizer\n", + " self.transform_codec.Q = Deadzone_Quantizer(Q_step=args.QSS, min_val=0, max_val=255)\n", + " logging.info(f\"Recreated quantizer with QSS={args.QSS}\")\n", + " except Exception as e:\n", + " logging.warning(f\"Could not recreate quantizer: {e}\")\n", + " \n", + " # Monkey-patch transform codec methods to use self.args when called without arguments\n", + " # This fixes VCF framework's encode()/decode() which call these without args\n", + " # Also capture decoded output in case decode_write fails to persist to disk\n", + " self._captured_decode_output = [None]\n", + " original_encode_read = self.transform_codec.encode_read\n", + " original_encode_write = self.transform_codec.encode_write\n", + " original_decode_read = self.transform_codec.decode_read\n", + " original_decode_write = self.transform_codec.decode_write\n", + " \n", + " def patched_encode_read(fn=None):\n", + " if fn is None:\n", + " fn = self.transform_codec.args.original\n", + " return original_encode_read(fn)\n", + " \n", + " def patched_encode_write(codestream, fn=None):\n", + " if fn is None:\n", + " fn = self.transform_codec.args.encoded\n", + " return original_encode_write(codestream, fn)\n", + " \n", + " def patched_decode_read(fn=None):\n", + " if fn is None:\n", + " fn = self.transform_codec.args.encoded\n", + " return original_decode_read(fn)\n", + " \n", + " def patched_decode_write(img, fn=None):\n", + " if fn is None:\n", + " fn = self.transform_codec.args.decoded\n", + " self._captured_decode_output[0] = np.array(img, copy=True)\n", + " return original_decode_write(img, fn)\n", + " \n", + " self.transform_codec.encode_read = patched_encode_read\n", + " self.transform_codec.encode_write = patched_encode_write\n", + " self.transform_codec.decode_read = patched_decode_read\n", + " self.transform_codec.decode_write = patched_decode_write\n", + " \n", + " self.block_size = int(getattr(args, 'block_size_ME', 16))\n", + " self.search_range = int(getattr(args, 'search_range', 32))\n", + " self.fast = getattr(args, 'fast', False)\n", + " self.gop_size = int(getattr(args, 'gop_size', 16))\n", + " self.num_gops = int(getattr(args, 'num_gops', 1))\n", + " self.max_b_frames = int(getattr(args, 'max_b_frames', 10))\n", + " self.hierarchical = getattr(args, 'hierarchical', False)\n", + " \n", + " # Ensure we have at least 10 frames for prediction\n", + " if self.max_b_frames < 10:\n", + " logging.warning(f\"max_b_frames={self.max_b_frames} is too low, setting to 10\")\n", + " self.max_b_frames = 10\n", + " \n", + " # Where original frames are expected for metrics\n", + " self.original_prefix = getattr(args, \"original_prefix\",\n", + " os.path.join(tempfile.gettempdir(), \"encoded_original\"))\n", + " \n", + " # RD-optimization: λ controls the rate-distortion trade-off\n", + " # J = SAD + λ · R (λ=0 ⟹ pure SAD, higher λ ⟹ favor cheaper MVs)\n", + " # Default: √0.85 · QSS ≈ 0.92·QSS (H.264 SAD-λ relationship)\n", + " user_lambda = getattr(args, 'lambda_rd', None)\n", + " if user_lambda is not None:\n", + " self.lambda_rd = float(user_lambda)\n", + " else:\n", + " qss = float(getattr(args, 'QSS', 1))\n", + " self.lambda_rd = math.sqrt(0.85) * qss\n", + " \n", + " logging.info(f\"MCTF Config: GOP={self.gop_size}, NumGOPs={self.num_gops}, MaxB={self.max_b_frames}, \"\n", + " f\"BlockSize={self.block_size}, SearchRange={self.search_range}, \"\n", + " f\"Fast={self.fast}, Hierarchical={self.hierarchical}, \"\n", + " f\"λ_RD={self.lambda_rd:.4f}\")\n", + "\n", + " def bye(self):\n", + " \"\"\"Override parent's bye() to prevent double video encoding.\"\"\"\n", + " logging.debug(\"trace\")\n", + " \n", + " # Only calculate metrics without re-encoding\n", + " if not self.encoding:\n", + " logging.info(\"MCTF: Skipping VCF's automatic video re-encoding (already done)\")\n", + "\n", + " def encode(self):\n", + " \"\"\"Encode video with MCTF.\"\"\"\n", + " logging.debug(\"trace\")\n", + " fn = self.args.original\n", + " logging.info(f\"Encoding {fn}\")\n", + " \n", + " # Check if input is likely a video file\n", + " if fn.endswith('.png') or fn.endswith('.jpg') or fn.endswith('.jpeg'):\n", + " logging.error(f\"MCTF requires a video file (e.g., .mp4, .avi) as input, not an image file.\")\n", + " logging.error(f\"Received: {fn}\")\n", + " logging.error(\"Please use -o with a video file URL or path.\")\n", + " return 0\n", + " \n", + " try:\n", + " container = av.open(fn)\n", + " except Exception as e:\n", + " logging.error(f\"Cannot open video file {fn}: {e}\")\n", + " logging.error(\"MCTF requires a video file (e.g., .mp4, .avi) as input.\")\n", + " return 0\n", + " \n", + " # Calculate total frames from gop_size * num_gops\n", + " total_frames_to_encode = self.gop_size * self.num_gops\n", + " logging.info(f\"Total frames to encode: {total_frames_to_encode} (GOP size={self.gop_size} × num GOPs={self.num_gops})\")\n", + " \n", + " # Read frames\n", + " frames = []\n", + " for packet in container.demux():\n", + " if __debug__:\n", + " self.total_input_size += packet.size\n", + " for frame in packet.decode():\n", + " img = np.array(frame.to_image().convert(\"RGB\"))\n", + " frames.append(img)\n", + " if len(frames) >= total_frames_to_encode:\n", + " break\n", + " if len(frames) >= total_frames_to_encode:\n", + " break\n", + " container.close()\n", + " \n", + " if len(frames) < 2:\n", + " logging.error(\"Need at least 2 frames\")\n", + " return 0\n", + " \n", + " self.N_frames = len(frames)\n", + " self.height, self.width = frames[0].shape[:2]\n", + " self.N_channels = 3\n", + " # Force original frames to be saved in /tmp\n", + " self.original_prefix = os.path.join(tempfile.gettempdir(), \"encoded_original\")\n", + " \n", + " logging.info(f\"Video: {self.width}x{self.height}, {self.N_frames} frames, {self.N_channels} channels\")\n", + " \n", + " # Save original frames\n", + " for idx, img in enumerate(frames):\n", + " img_fn = f\"{self.original_prefix}_{idx:04d}.png\"\n", + " Image.fromarray(img).save(img_fn)\n", + " \n", + " # Process GOPs\n", + " decoded_frames = {} # Cache for reference frames\n", + " \n", + " for gop_start in range(0, self.N_frames, self.gop_size):\n", + " gop_end = min(gop_start + self.gop_size, self.N_frames)\n", + " actual_gop_size = gop_end - gop_start\n", + " gop_start_size = self.total_output_size\n", + " \n", + " logging.info(f\"\\n{'='*60}\")\n", + " logging.info(f\"Processing GOP {gop_start}-{gop_end-1} (size={actual_gop_size})\")\n", + " logging.info(f\"{'='*60}\")\n", + " \n", + " # Create GOP structure\n", + " if self.hierarchical:\n", + " gop_structure = create_hierarchical_gop(actual_gop_size, self.max_b_frames)\n", + " else:\n", + " gop_structure = create_simple_gop(actual_gop_size, self.max_b_frames)\n", + " \n", + " # Encode frames in encoding order\n", + " i_count = p_count = b_count = 0\n", + " for frame_info in gop_structure:\n", + " abs_idx = gop_start + frame_info.frame_idx\n", + " if abs_idx >= self.N_frames:\n", + " continue\n", + " \n", + " frame = frames[abs_idx]\n", + " \n", + " if frame_info.frame_type == FrameType.I:\n", + " self._encode_i_frame(frame, abs_idx, decoded_frames)\n", + " i_count += 1\n", + " \n", + " elif frame_info.frame_type == FrameType.P:\n", + " ref_idx = gop_start + frame_info.references[0]\n", + " self._encode_p_frame(frame, abs_idx, ref_idx, decoded_frames)\n", + " p_count += 1\n", + " \n", + " elif frame_info.frame_type == FrameType.B:\n", + " ref_past_idx = gop_start + frame_info.references[0]\n", + " ref_future_idx = gop_start + frame_info.references[1]\n", + " self._encode_b_frame(frame, abs_idx, ref_past_idx, \n", + " ref_future_idx, decoded_frames)\n", + " b_count += 1\n", + " \n", + " # GOP statistics\n", + " gop_bytes = self.total_output_size - gop_start_size\n", + " gop_pixels = actual_gop_size * self.width * self.height\n", + " gop_bpp = (gop_bytes * 8) / gop_pixels if gop_pixels > 0 else 0\n", + " \n", + " logging.info(f\"\\nGOP {gop_start}-{gop_end-1} Summary:\")\n", + " logging.info(f\" Frame types: I={i_count}, P={p_count}, B={b_count}\")\n", + " logging.info(f\" GOP size: {gop_bytes} bytes ({gop_bpp:.4f} bpp)\")\n", + " logging.info(f\" Average: {gop_bytes/actual_gop_size:.2f} bytes/frame\")\n", + " \n", + " logging.info(f\"\\n{'='*60}\")\n", + " logging.info(f\"ENCODING COMPLETE\")\n", + " logging.info(f\"{'='*60}\")\n", + " \n", + " # Calculate and log metrics\n", + " total_pixels = self.N_frames * self.width * self.height\n", + " BPP = (self.total_output_size * 8) / total_pixels\n", + " \n", + " logging.info(f\"Total frames encoded: {self.N_frames}\")\n", + " logging.info(f\"Video dimensions: {self.width}x{self.height}\")\n", + " logging.info(f\"Total output size: {self.total_output_size} bytes ({self.total_output_size/1024/1024:.2f} MB)\")\n", + " logging.info(f\"Total input size: {self.total_input_size} bytes ({self.total_input_size/1024/1024:.2f} MB)\")\n", + " logging.info(f\"Compression ratio: {self.total_input_size/self.total_output_size:.2f}:1\")\n", + " logging.info(f\"Total pixels: {total_pixels}\")\n", + " logging.info(f\"Bits Per Pixel (BPP): {BPP:.6f}\")\n", + " logging.info(f\"Compression rate: {BPP:.4f} bits/pixel\")\n", + " logging.info(f\"\\nNOTE: The encoded size ({self.total_output_size/1024/1024:.2f} MB) is the actual compressed data.\")\n", + " logging.info(f\"The decoded MP4 is for playback only and uses H.264 re-encoding.\")\n", + " logging.info(f\"{'='*60}\\n\")\n", + " \n", + " # Persist metadata so decode() is self-contained\n", + " with open(f\"{self.args.encoded}_meta.txt\", \"w\") as f:\n", + " f.write(f\"{self.original_prefix}\\n\")\n", + " f.write(f\"{self.N_frames}\\n\")\n", + " f.write(f\"{self.height}\\n\")\n", + " f.write(f\"{self.width}\\n\")\n", + " f.write(f\"{BPP}\\n\")\n", + " f.write(f\"{self.total_output_size}\\n\")\n", + " \n", + " return self.total_output_size\n", + "\n", + " def _encode_i_frame(self, frame, idx, decoded_frames):\n", + " \"\"\"Encode I-frame.\"\"\"\n", + " logging.info(f\"Encoding I-frame {idx}\")\n", + " \n", + " i_orig_fn = f\"{self.args.encoded}_I_{idx:04d}.png\"\n", + " i_enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " Image.fromarray(frame).save(i_orig_fn)\n", + " \n", + " # Temporarily set args so transform codec's encode() reads/writes correct files\n", + " saved_original = getattr(self.transform_codec.args, 'original', None)\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " \n", + " self.transform_codec.args.original = i_orig_fn\n", + " self.transform_codec.args.encoded = i_enc_fn\n", + " \n", + " # Recreate quantizer with correct QSS before encoding\n", + " if hasattr(self.args, 'QSS'):\n", + " self.transform_codec.args.QSS = self.args.QSS\n", + " from scalar_quantization.deadzone_quantization import Deadzone_Quantizer\n", + " self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255)\n", + " \n", + " # Use full encode() to ensure DCT transform and quantization are applied\n", + " O_bytes = self.transform_codec.encode()\n", + " \n", + " # Restore args\n", + " if saved_original is not None:\n", + " self.transform_codec.args.original = saved_original\n", + " if saved_encoded is not None:\n", + " self.transform_codec.args.encoded = saved_encoded\n", + " \n", + " self.total_output_size += O_bytes\n", + " \n", + " # Save metadata\n", + " with open(f\"{i_enc_fn}_type.txt\", 'w') as f:\n", + " f.write(\"I\")\n", + " \n", + " # Decode and cache for references\n", + " dec_fn = f\"{self.args.encoded}_dec_{idx:04d}.png\"\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " saved_decoded = getattr(self.transform_codec.args, 'decoded', None)\n", + " \n", + " self.transform_codec.args.encoded = i_enc_fn\n", + " self.transform_codec.args.decoded = dec_fn\n", + " self._captured_decode_output[0] = None\n", + " self.transform_codec.decode()\n", + " \n", + " if saved_encoded is not None:\n", + " self.transform_codec.args.encoded = saved_encoded\n", + " if saved_decoded is not None:\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " # Use captured output if available (avoids FileNotFoundError when decode_write path differs)\n", + " if self._captured_decode_output[0] is not None:\n", + " decoded_frames[idx] = self._captured_decode_output[0]\n", + " elif os.path.exists(dec_fn):\n", + " decoded_frames[idx] = np.array(Image.open(dec_fn).convert(\"RGB\"))\n", + " else:\n", + " raise FileNotFoundError(\n", + " f\"Decoded frame not found at {dec_fn}. \"\n", + " \"The transform codec's decode() did not write the expected output.\"\n", + " )\n", + " \n", + " logging.info(f\" I-frame {idx}: {O_bytes} bytes\")\n", + "\n", + " def _encode_p_frame(self, frame, idx, ref_idx, decoded_frames):\n", + " \"\"\"Encode P-frame (forward prediction only) using VCF transform.\"\"\"\n", + " logging.info(f\"Encoding P-frame {idx} (ref={ref_idx})\")\n", + " \n", + " ref_frame = decoded_frames[ref_idx]\n", + " \n", + " # Motion estimation (RD-optimised: J = SAD + λ·R_mv)\n", + " mv_field = block_matching(\n", + " ref_frame, frame, \n", + " self.block_size, self.search_range, \n", + " self.fast, self.lambda_rd\n", + " )\n", + " \n", + " # Motion compensation\n", + " pred = motion_compensate(ref_frame, mv_field, self.block_size)\n", + " \n", + " # Compute residual and map to [0, 255] without hard-clipping:\n", + " # residual ∈ [-255, 255] → /2 + 128 → [0.5, 255.5] → round → [0, 255]\n", + " # Max rounding error from mapping: ±1 per sample (vs up to ±128 with old +128 clip)\n", + " residual = frame.astype(np.int16) - pred.astype(np.int16)\n", + " residual_img = np.clip(np.round(residual.astype(np.float32) / 2 + 128), 0, 255).astype(np.uint8)\n", + " \n", + " # Save residual as PNG and encode using transform codec (DCT + quantize + entropy)\n", + " residual_fn = f\"{self.args.encoded}_res_{idx:04d}.png\"\n", + " Image.fromarray(residual_img).save(residual_fn)\n", + " \n", + " enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " \n", + " # Temporarily set args\n", + " saved_original = getattr(self.transform_codec.args, 'original', None)\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " \n", + " self.transform_codec.args.original = residual_fn\n", + " self.transform_codec.args.encoded = enc_fn\n", + " \n", + " # Recreate quantizer before encoding\n", + " if hasattr(self.args, 'QSS'):\n", + " self.transform_codec.args.QSS = self.args.QSS\n", + " from scalar_quantization.deadzone_quantization import Deadzone_Quantizer\n", + " self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255)\n", + " \n", + " O_bytes = self.transform_codec.encode()\n", + " \n", + " # Restore args\n", + " if saved_original is not None:\n", + " self.transform_codec.args.original = saved_original\n", + " if saved_encoded is not None:\n", + " self.transform_codec.args.encoded = saved_encoded\n", + " \n", + " self.total_output_size += O_bytes\n", + " \n", + " # Save motion vectors\n", + " np.savez_compressed(\n", + " f\"{enc_fn}_mv.npz\",\n", + " mv=mv_field,\n", + " ref_idx=ref_idx\n", + " )\n", + " mv_size = os.path.getsize(f\"{enc_fn}_mv.npz\")\n", + " self.total_output_size += mv_size\n", + " \n", + " # Save frame type\n", + " with open(f\"{enc_fn}_type.txt\", 'w') as f:\n", + " f.write(f\"P:{ref_idx}\")\n", + " \n", + " # Decode residual to get reconstruction (encoder-side decode for reference)\n", + " dec_fn = f\"{self.args.encoded}_dec_{idx:04d}.png\"\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " saved_decoded = getattr(self.transform_codec.args, 'decoded', None)\n", + " \n", + " self.transform_codec.args.encoded = enc_fn\n", + " self.transform_codec.args.decoded = dec_fn\n", + " self._captured_decode_output[0] = None\n", + " self.transform_codec.decode()\n", + " \n", + " self.transform_codec.args.encoded = saved_encoded\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " # Undo mapping: (pixel - 128) * 2; use captured output if available\n", + " if self._captured_decode_output[0] is not None:\n", + " residual_img_dec = self._captured_decode_output[0]\n", + " elif os.path.exists(dec_fn):\n", + " residual_img_dec = np.array(Image.open(dec_fn).convert(\"RGB\"))\n", + " else:\n", + " raise FileNotFoundError(\n", + " f\"Decoded residual not found at {dec_fn}. \"\n", + " \"The transform codec's decode() did not write the expected output.\"\n", + " )\n", + " residual_rec = (residual_img_dec.astype(np.int16) - 128) * 2\n", + " \n", + " # Reconstruct and cache\n", + " recon = np.clip(pred.astype(np.int16) + residual_rec, 0, 255).astype(np.uint8)\n", + " decoded_frames[idx] = recon\n", + " \n", + " logging.info(f\" P-frame {idx}: residual={O_bytes} bytes, mv={mv_size} bytes\")\n", + "\n", + " def _encode_b_frame(self, frame, idx, ref_past_idx, ref_future_idx, decoded_frames):\n", + " \"\"\"Encode B-frame (bidirectional prediction) using VCF transform.\"\"\"\n", + " logging.info(f\"Encoding B-frame {idx} (refs={ref_past_idx},{ref_future_idx})\")\n", + " \n", + " ref_past = decoded_frames[ref_past_idx]\n", + " ref_future = decoded_frames[ref_future_idx]\n", + " \n", + " # Bidirectional motion estimation (RD-optimised: J = SAD + λ·(R_mv + R_mode))\n", + " mv_fwd, mv_bwd, mode = bidirectional_me(\n", + " ref_past, ref_future, frame,\n", + " self.block_size, self.search_range,\n", + " self.fast, self.lambda_rd\n", + " )\n", + " \n", + " # Motion compensation\n", + " pred = motion_compensate_bidirectional(\n", + " ref_past, ref_future, mv_fwd, mv_bwd, mode, self.block_size\n", + " )\n", + " \n", + " # Compute residual and map to [0, 255] without hard-clipping:\n", + " # residual ∈ [-255, 255] → /2 + 128 → [0.5, 255.5] → round → [0, 255]\n", + " residual = frame.astype(np.int16) - pred.astype(np.int16)\n", + " residual_img = np.clip(np.round(residual.astype(np.float32) / 2 + 128), 0, 255).astype(np.uint8)\n", + " \n", + " # Save residual as PNG and encode using transform codec (DCT + quantize + entropy)\n", + " residual_fn = f\"{self.args.encoded}_res_{idx:04d}.png\"\n", + " Image.fromarray(residual_img).save(residual_fn)\n", + " \n", + " enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " \n", + " # Temporarily set args\n", + " saved_original = getattr(self.transform_codec.args, 'original', None)\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " \n", + " self.transform_codec.args.original = residual_fn\n", + " self.transform_codec.args.encoded = enc_fn\n", + " \n", + " # Recreate quantizer before encoding\n", + " if hasattr(self.args, 'QSS'):\n", + " self.transform_codec.args.QSS = self.args.QSS\n", + " from scalar_quantization.deadzone_quantization import Deadzone_Quantizer\n", + " self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255)\n", + " \n", + " O_bytes = self.transform_codec.encode()\n", + " \n", + " # Restore args\n", + " if saved_original is not None:\n", + " self.transform_codec.args.original = saved_original\n", + " if saved_encoded is not None:\n", + " self.transform_codec.args.encoded = saved_encoded\n", + " \n", + " self.total_output_size += O_bytes\n", + " \n", + " # Save motion vectors and mode\n", + " np.savez_compressed(\n", + " f\"{enc_fn}_mv.npz\",\n", + " mv_fwd=mv_fwd,\n", + " mv_bwd=mv_bwd,\n", + " mode=mode,\n", + " ref_past=ref_past_idx,\n", + " ref_future=ref_future_idx\n", + " )\n", + " mv_size = os.path.getsize(f\"{enc_fn}_mv.npz\")\n", + " self.total_output_size += mv_size\n", + " \n", + " # Save frame type\n", + " with open(f\"{enc_fn}_type.txt\", 'w') as f:\n", + " f.write(f\"B:{ref_past_idx},{ref_future_idx}\")\n", + " \n", + " # Decode residual to get reconstruction (encoder-side decode for reference)\n", + " dec_fn = f\"{self.args.encoded}_dec_{idx:04d}.png\"\n", + " saved_encoded = getattr(self.transform_codec.args, 'encoded', None)\n", + " saved_decoded = getattr(self.transform_codec.args, 'decoded', None)\n", + " \n", + " self.transform_codec.args.encoded = enc_fn\n", + " self.transform_codec.args.decoded = dec_fn\n", + " self._captured_decode_output[0] = None\n", + " self.transform_codec.decode()\n", + " \n", + " self.transform_codec.args.encoded = saved_encoded\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " # Undo mapping: (pixel - 128) * 2; use captured output if available\n", + " if self._captured_decode_output[0] is not None:\n", + " residual_img_dec = self._captured_decode_output[0]\n", + " elif os.path.exists(dec_fn):\n", + " residual_img_dec = np.array(Image.open(dec_fn).convert(\"RGB\"))\n", + " else:\n", + " raise FileNotFoundError(\n", + " f\"Decoded residual not found at {dec_fn}. \"\n", + " \"The transform codec's decode() did not write the expected output.\"\n", + " )\n", + " residual_rec = (residual_img_dec.astype(np.int16) - 128) * 2\n", + " \n", + " # Reconstruct and cache\n", + " recon = np.clip(pred.astype(np.int16) + residual_rec, 0, 255).astype(np.uint8)\n", + " decoded_frames[idx] = recon\n", + " \n", + " mode_stats = [np.sum(mode == i) for i in range(3)]\n", + " logging.info(f\" B-frame {idx}: residual={O_bytes} bytes, mv={mv_size} bytes, \"\n", + " f\"modes(fwd/bwd/bi)={mode_stats}\")\n", + "\n", + " def decode(self):\n", + " \"\"\"Decode MCTF encoded video.\"\"\"\n", + " logging.debug(\"trace\")\n", + " \n", + " # Read encoding metadata if available (makes decode self-contained)\n", + " meta = f\"{self.args.encoded}_meta.txt\"\n", + " if os.path.exists(meta):\n", + " with open(meta, \"r\") as f:\n", + " self.original_prefix = f.readline().strip()\n", + " self.N_frames = int(f.readline().strip())\n", + " self.height = int(f.readline().strip())\n", + " self.width = int(f.readline().strip())\n", + " self._meta_BPP = float(f.readline().strip())\n", + " line = f.readline().strip()\n", + " if line:\n", + " self.total_output_size = int(line)\n", + " \n", + " # First, scan all frames to determine decoding order\n", + " frame_info = {}\n", + " idx = 0\n", + " while True:\n", + " type_fn = f\"{self.args.encoded}_{idx:04d}_type.txt\"\n", + " \n", + " if not os.path.exists(type_fn):\n", + " if idx == 0:\n", + " logging.error(\"No encoded frames found\")\n", + " return 0\n", + " break\n", + " \n", + " with open(type_fn, 'r') as f:\n", + " frame_type = f.read().strip()\n", + " \n", + " frame_info[idx] = {\n", + " 'type': frame_type,\n", + " 'display_order': idx\n", + " }\n", + " idx += 1\n", + " \n", + " total_frames = len(frame_info)\n", + " logging.info(f\"Found {total_frames} encoded frames\")\n", + " \n", + " # Decode frames in dependency order (handles hierarchical B-frames)\n", + " # Keep decoding frames whose references are ready\n", + " decoded_frames = {}\n", + " remaining_frames = set(range(total_frames))\n", + " \n", + " while remaining_frames:\n", + " progress = False\n", + " \n", + " for idx in list(remaining_frames):\n", + " frame_type = frame_info[idx]['type']\n", + " can_decode = False\n", + " \n", + " if frame_type == \"I\":\n", + " # I-frames have no dependencies\n", + " can_decode = True\n", + " \n", + " elif frame_type.startswith(\"P:\"):\n", + " # P-frames depend on one reference\n", + " ref_idx = int(frame_type.split(\":\")[1])\n", + " can_decode = ref_idx in decoded_frames\n", + " \n", + " elif frame_type.startswith(\"B:\"):\n", + " # B-frames depend on two references\n", + " refs = frame_type.split(\":\")[1].split(\",\")\n", + " ref_past = int(refs[0])\n", + " ref_future = int(refs[1])\n", + " can_decode = (ref_past in decoded_frames and ref_future in decoded_frames)\n", + " \n", + " # Decode if ready\n", + " if can_decode:\n", + " if frame_type == \"I\":\n", + " self._decode_i_frame(idx, decoded_frames)\n", + " elif frame_type.startswith(\"P:\"):\n", + " ref_idx = int(frame_type.split(\":\")[1])\n", + " self._decode_p_frame(idx, ref_idx, decoded_frames)\n", + " elif frame_type.startswith(\"B:\"):\n", + " refs = frame_type.split(\":\")[1].split(\",\")\n", + " ref_past = int(refs[0])\n", + " ref_future = int(refs[1])\n", + " self._decode_b_frame(idx, ref_past, ref_future, decoded_frames)\n", + " \n", + " remaining_frames.remove(idx)\n", + " progress = True\n", + " \n", + " # Check for deadlock\n", + " if not progress:\n", + " raise RuntimeError(f\"Cannot decode remaining frames {remaining_frames} - \"\n", + " f\"circular dependency or missing references\")\n", + " \n", + " logging.info(f\"\\n{'='*60}\")\n", + " logging.info(f\"DECODING COMPLETE\")\n", + " logging.info(f\"{'='*60}\")\n", + " logging.info(f\"Total frames decoded: {len(decoded_frames)}\")\n", + " \n", + " # Write all decoded frames to disk with consistent naming\n", + " # (guarantees files exist at the expected paths for RMSE and ffmpeg)\n", + " decoded_prefix = getattr(self.args, 'decoded', '/tmp/decoded')\n", + " if decoded_prefix.endswith('.png'):\n", + " decoded_prefix = decoded_prefix[:-4]\n", + " for idx in range(len(decoded_frames)):\n", + " out_fn = f\"{decoded_prefix}_{idx:04d}.png\"\n", + " Image.fromarray(decoded_frames[idx]).save(out_fn)\n", + " logging.info(f\"Wrote {len(decoded_frames)} frames to {decoded_prefix}_XXXX.png\")\n", + " \n", + " # Calculate quality metrics (RMSE) if original frames are available\n", + " try:\n", + " from information_theory import distortion\n", + " \n", + " total_RMSE = 0\n", + " frames_compared = 0\n", + " \n", + " for idx in range(len(decoded_frames)):\n", + " original_fn = f\"{self.original_prefix}_{idx:04d}.png\"\n", + " decoded_fn = f\"{decoded_prefix}_{idx:04d}.png\"\n", + " \n", + " if os.path.exists(original_fn) and os.path.exists(decoded_fn):\n", + " original_img = np.array(Image.open(original_fn).convert(\"RGB\"))\n", + " decoded_img = np.array(Image.open(decoded_fn).convert(\"RGB\"))\n", + " \n", + " frame_RMSE = distortion.RMSE(original_img, decoded_img)\n", + " total_RMSE += frame_RMSE\n", + " frames_compared += 1\n", + " \n", + " if idx < 3 or idx == len(decoded_frames) - 1: # Log first 3 and last frame\n", + " logging.info(f\" Frame {idx} RMSE: {frame_RMSE:.4f}\")\n", + " \n", + " if frames_compared > 0:\n", + " avg_RMSE = total_RMSE / frames_compared\n", + " \n", + " # Calculate BPP from encoding metadata\n", + " BPP = 0\n", + " if hasattr(self, 'total_output_size') and self.total_output_size > 0 and hasattr(self, 'width') and hasattr(self, 'height'):\n", + " total_pixels = frames_compared * self.width * self.height\n", + " BPP = (self.total_output_size * 8) / total_pixels\n", + " elif hasattr(self, '_meta_BPP') and self._meta_BPP > 0:\n", + " BPP = self._meta_BPP\n", + " else:\n", + " logging.warning(\"Could not determine BPP from encoding metadata\")\n", + " \n", + " lrd = getattr(self, 'lambda_rd', 1.0)\n", + " J = avg_RMSE + lrd * BPP\n", + " \n", + " logging.info(f\"\\n{'='*60}\")\n", + " logging.info(f\"QUALITY METRICS\")\n", + " logging.info(f\"{'='*60}\")\n", + " logging.info(f\"Frames compared: {frames_compared}\")\n", + " logging.info(f\"Average RMSE (D): {avg_RMSE:.6f}\")\n", + " logging.info(f\"Bits Per Pixel (R): {BPP:.6f}\")\n", + " logging.info(f\"λ (lambda_rd): {lrd:.4f}\")\n", + " logging.info(f\"Rate-Distortion Cost (J = D + λ·R): {J:.6f}\")\n", + " logging.info(f\"{'='*60}\\n\")\n", + " \n", + " except ImportError:\n", + " logging.warning(\"information_theory module not available, skipping RMSE calculation\")\n", + " except Exception as e:\n", + " logging.warning(f\"Error calculating metrics: {e}\")\n", + " \n", + " # Create output video\n", + " logging.info(\"Creating output video...\")\n", + " \n", + " # Use ffmpeg to combine frames with optimized settings\n", + " import subprocess\n", + " try:\n", + " # Verify decoded frames actually exist before calling ffmpeg\n", + " first_frame = f\"{decoded_prefix}_0000.png\"\n", + " logging.info(f\"Decoded prefix: {decoded_prefix}\")\n", + " logging.info(f\"First frame exists? {os.path.exists(first_frame)}\")\n", + " if not os.path.exists(first_frame):\n", + " logging.error(f\"Cannot create video: first decoded frame not found at {first_frame}\")\n", + " return 0\n", + " \n", + " output_mp4 = f'{decoded_prefix}.mp4'\n", + " cmd = [\n", + " 'ffmpeg', '-y',\n", + " '-framerate', '30',\n", + " '-i', f'{decoded_prefix}_%04d.png',\n", + " '-c:v', 'libx264',\n", + " '-crf', '18', # Near-lossless quality (0=lossless, 51=worst, 18=visually lossless)\n", + " '-preset', 'medium', # Encoding speed (slower = better compression)\n", + " '-pix_fmt', 'yuv420p',\n", + " output_mp4\n", + " ]\n", + " \n", + " # Debug: show command\n", + " logging.info(f\"Running ffmpeg command: {' '.join(cmd)}\")\n", + " \n", + " result = subprocess.run(cmd, check=True, capture_output=True, text=True)\n", + " \n", + " # Get output video size\n", + " if os.path.exists(output_mp4):\n", + " mp4_size = os.path.getsize(output_mp4)\n", + " logging.info(f\"Video saved to {output_mp4}\")\n", + " logging.info(f\"Output MP4 size: {mp4_size} bytes ({mp4_size/1024/1024:.2f} MB)\")\n", + " \n", + " # Compare with encoded size (if available from encoding metadata)\n", + " if hasattr(self, 'total_output_size') and self.total_output_size > 0:\n", + " ratio = mp4_size / self.total_output_size\n", + " logging.info(f\"MP4 vs Encoded ratio: {ratio:.2f}x\")\n", + " if ratio > 2:\n", + " logging.warning(f\"MP4 is {ratio:.2f}x larger than encoded data!\")\n", + " else:\n", + " # Try to use metadata loaded at start of decode()\n", + " if hasattr(self, '_meta_BPP') and self._meta_BPP > 0 and hasattr(self, 'width') and hasattr(self, 'height') and hasattr(self, 'N_frames'):\n", + " total_pixels = self.N_frames * self.height * self.width\n", + " encoded_size = int((self._meta_BPP * total_pixels) / 8)\n", + " if encoded_size > 0:\n", + " ratio = mp4_size / encoded_size\n", + " logging.info(f\"Encoded data size: {encoded_size} bytes ({encoded_size/1024/1024:.2f} MB)\")\n", + " logging.info(f\"MP4 vs Encoded ratio: {ratio:.2f}x\")\n", + " if ratio > 2:\n", + " logging.info(f\"NOTE: MP4 is {ratio:.2f}x larger - this is normal for H.264 re-encoding\")\n", + " else:\n", + " logging.debug(\"Could not calculate encoded size for comparison\")\n", + " \n", + " # Show ffmpeg output if debugging\n", + " if result.stderr:\n", + " logging.debug(f\"FFmpeg output: {result.stderr}\")\n", + " \n", + " except subprocess.CalledProcessError as e:\n", + " logging.error(f\"Failed to create video: {e}\")\n", + " logging.error(f\"FFmpeg stderr: {e.stderr}\")\n", + " logging.error(f\"FFmpeg stdout: {e.stdout}\")\n", + " except FileNotFoundError:\n", + " logging.warning(\"ffmpeg not found, skipping video creation\")\n", + " \n", + " return 0\n", + "\n", + " def _decode_i_frame(self, idx, decoded_frames):\n", + " \"\"\"Decode I-frame.\"\"\"\n", + " enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " dec_fn = f\"{getattr(self.args, 'decoded', '/tmp/decoded')}_{idx:04d}.png\"\n", + " \n", + " logging.info(f\"Decoding I-frame {idx}\")\n", + " saved_encoded = self.transform_codec.args.encoded\n", + " saved_decoded = self.transform_codec.args.decoded\n", + " \n", + " self.transform_codec.args.encoded = enc_fn\n", + " self.transform_codec.args.decoded = dec_fn\n", + " self.transform_codec.decode()\n", + " \n", + " self.transform_codec.args.encoded = saved_encoded\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " img = np.array(Image.open(dec_fn).convert(\"RGB\"))\n", + " decoded_frames[idx] = img\n", + "\n", + " def _decode_p_frame(self, idx, ref_idx, decoded_frames):\n", + " \"\"\"Decode P-frame using VCF transform.\"\"\"\n", + " logging.info(f\"Decoding P-frame {idx} (ref={ref_idx})\")\n", + " \n", + " enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " \n", + " # Load motion vectors\n", + " mv_data = np.load(f\"{enc_fn}_mv.npz\")\n", + " mv_field = mv_data['mv']\n", + " \n", + " # Decode residual using transform codec\n", + " residual_fn = f\"{self.args.encoded}_dec_res_{idx:04d}.png\"\n", + " saved_encoded = self.transform_codec.args.encoded\n", + " saved_decoded = self.transform_codec.args.decoded\n", + " \n", + " self.transform_codec.args.encoded = enc_fn\n", + " self.transform_codec.args.decoded = residual_fn\n", + " self.transform_codec.decode()\n", + " \n", + " self.transform_codec.args.encoded = saved_encoded\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " # Undo /2+128 mapping: (pixel - 128) * 2\n", + " residual = (np.array(Image.open(residual_fn).convert(\"RGB\")).astype(np.int16) - 128) * 2\n", + " \n", + " # Motion compensation\n", + " ref_frame = decoded_frames[ref_idx]\n", + " pred = motion_compensate(ref_frame, mv_field, self.block_size)\n", + " \n", + " # Reconstruct\n", + " recon = np.clip(pred.astype(np.int16) + residual, 0, 255).astype(np.uint8)\n", + " decoded_frames[idx] = recon\n", + "\n", + " def _decode_b_frame(self, idx, ref_past_idx, ref_future_idx, decoded_frames):\n", + " \"\"\"Decode B-frame using VCF transform.\"\"\"\n", + " logging.info(f\"Decoding B-frame {idx} (refs={ref_past_idx},{ref_future_idx})\")\n", + " \n", + " enc_fn = f\"{self.args.encoded}_{idx:04d}\"\n", + " \n", + " # Load motion vectors and mode\n", + " mv_data = np.load(f\"{enc_fn}_mv.npz\")\n", + " mv_fwd = mv_data['mv_fwd']\n", + " mv_bwd = mv_data['mv_bwd']\n", + " mode = mv_data['mode']\n", + " \n", + " # Decode residual using transform codec\n", + " residual_fn = f\"{self.args.encoded}_dec_res_{idx:04d}.png\"\n", + " saved_encoded = self.transform_codec.args.encoded\n", + " saved_decoded = self.transform_codec.args.decoded\n", + " \n", + " self.transform_codec.args.encoded = enc_fn\n", + " self.transform_codec.args.decoded = residual_fn\n", + " self.transform_codec.decode()\n", + " \n", + " self.transform_codec.args.encoded = saved_encoded\n", + " self.transform_codec.args.decoded = saved_decoded\n", + " \n", + " # Undo /2+128 mapping: (pixel - 128) * 2\n", + " residual = (np.array(Image.open(residual_fn).convert(\"RGB\")).astype(np.int16) - 128) * 2\n", + " \n", + " # Motion compensation\n", + " ref_past = decoded_frames[ref_past_idx]\n", + " ref_future = decoded_frames[ref_future_idx]\n", + " pred = motion_compensate_bidirectional(\n", + " ref_past, ref_future, mv_fwd, mv_bwd, mode, self.block_size\n", + " )\n", + " \n", + " # Reconstruct\n", + " recon = np.clip(pred.astype(np.int16) + residual, 0, 255).astype(np.uint8)\n", + " decoded_frames[idx] = recon\n", + "\n", + "# =============================================================================\n", + "# Main\n", + "# =============================================================================\n", + "\n", + "if __name__ == \"__main__\":\n", + " main.main(parser.parser, logging, CoDec)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import Video" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install -r ../requirements.txt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Help about basic functionality" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py -h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Help to encode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py encode -h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 1: Encoding a Remote Video\n", + "\n", + "We'll encode the **\"mobile\"** test sequence (352x288, 30fps, 300 frames). This is a standard test video with multiple moving objects (calendar, toy train, ball) — challenging for motion estimation.\n", + "\n", + "**Parameters used:**\n", + "- `gop_size=16`: each GOP has 16 frames (1 I-frame + 1 P-frame + 14 B-frames)\n", + "- `num_gops=2`: encode 32 frames total\n", + "- Default QSS (quantization), default block size (16x16), default search range (32)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Encode and decoding a remote video" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Video(\"http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use -o for original video, --num_gops to specify how many GOPs to encode\n", + "# Total frames = gop_size * num_gops (16 * 2 = 32 frames)\n", + "!python3 ../src/MCTF.py encode -o http://www.hpca.ual.es/~vruiz/videos/mobile_352x288x30x420x300.mp4 --gop_size 16 --num_gops 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Video is automatically created at /tmp/decoded.mp4\n", + "Video(\"../tmp/encoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 2: Encoding a Local Video\n", + "\n", + "Now we use the **\"coastguard\"** sequence — a surveillance-style video with a boat moving across water. The water ripples create complex textures that are harder to predict.\n", + "\n", + "We encode **80 frames** (5 GOPs x 16 frames each) to see how the codec handles longer sequences and multiple GOP boundaries." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Encode and decode a local video" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!wget http://www.hpca.ual.es/~vruiz/videos/coastguard_352x288x30x420x300.avi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Encodes 80 frames (gop_size=16 * num_gops=5)\n", + "!python3 ../src/MCTF.py encode -o coastguard_352x288x30x420x300.avi --gop_size 16 --num_gops 5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"../tmp/encoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Default encoding and decoding" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!rm /tmp/encoded* /tmp/decoded* 2>/dev/null; echo \"Cleaned /tmp files\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py encode -o \"your_video\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 3: Hierarchical B-frames\n", + "\n", + "Here we enable `--hierarchical` to use the tree-structured B-frame ordering. Compare the **BPP** (bits per pixel) and **RMSE** in the output with the simple B-frame demo above.\n", + "\n", + "**Expected result:** Hierarchical should produce **lower BPP** (better compression) because each B-frame references temporally closer frames, yielding smaller motion vectors and residuals." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using hierarchical B-frame structure" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py encode -o coastguard_352x288x30x420x300.avi --gop_size 16 --num_gops 5 --hierarchical" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 4: Fast Motion Estimation (Diamond Search)\n", + "\n", + "The `--fast` flag switches from **exhaustive search** (tests all positions) to **diamond search** (follows the gradient).\n", + "\n", + "| | Exhaustive | Diamond (`--fast`) |\n", + "|-|-----------|-------------------|\n", + "| Complexity | $O(\\text{sr}^2)$ per block | $O(\\log \\text{sr})$ per block |\n", + "| For sr=32 | 4,225 SAD evaluations | ~20-40 SAD evaluations |\n", + "| Quality | Optimal | ~95% of optimal |\n", + "| Speed | Slow | **10-50x faster** |\n", + "\n", + "**Expected result:** Very similar quality (RMSE) but **much faster** encoding time." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using fast motion estimation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py encode -o coastguard_352x288x30x420x300.avi --gop_size 16 --num_gops 5 --fast" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 5: Effect of Quantization Step Size (QSS)\n", + "\n", + "The **QSS** parameter controls the trade-off between quality and compression:\n", + "\n", + "$$\\text{quantized} = \\text{sign}(x) \\cdot \\left\\lfloor \\frac{|x|}{\\text{QSS}} \\right\\rfloor$$\n", + "\n", + "| QSS | Effect on coefficients | Quality | File size |\n", + "|-----|----------------------|---------|-----------|\n", + "| **16** (low) | Keeps more detail | **High** (low RMSE) | Larger |\n", + "| **32** (medium) | Balanced | Medium | Medium |\n", + "| **64** (high) | Aggressive zeroing | **Low** (high RMSE) | Smaller |\n", + "\n", + "We encode the same video with QSS=16 and QSS=64 to demonstrate this trade-off visually." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Different quantization steps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Lower QSS = better quality\n", + "!python3 ../src/MCTF.py encode -o coastguard_352x288x30x420x300.avi --gop_size 16 --num_gops 5 -q 16 --fast" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode -q 16" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded.mp4\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Higher QSS = more compression\n", + "!python3 ../src/MCTF.py encode -o coastguard_352x288x30x420x300.avi --gop_size 16 --num_gops 5 -q 64 --fast" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!python3 ../src/MCTF.py decode -q 64" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded.mp4\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Demo 6: Hierarchical vs Simple B-frames — Quantitative Comparison\n", + "\n", + "This experiment runs **both** configurations with identical parameters and compares the **BPP** numerically. This is the most rigorous comparison in the notebook:\n", + "\n", + "- Same video, same QSS (32), same search (`--fast`), same GOP structure\n", + "- Only difference: `--hierarchical` flag on/off\n", + "- We extract BPP from the encoder output and display a comparison table" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical vs Non-Hierarchical B-frames Comparison\n", + "\n", + "This comparison demonstrates the compression efficiency difference between simple (sequential) and hierarchical B-frame structures." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Clean up previous encodings\n", + "!rm -f /tmp/encoded_* /tmp/decoded_*\n", + "\n", + "import re\n", + "import subprocess" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "# Encode WITHOUT hierarchical B-frames\n", + "print(\"=\" * 70)\n", + "print(\"ENCODING: Simple (Non-Hierarchical) B-frames\")\n", + "print(\"=\" * 70)\n", + "\n", + "result = subprocess.run(\n", + " ['python3', '../src/MCTF.py', 'encode', \n", + " '-o', 'coastguard_352x288x30x420x300.avi',\n", + " '--gop_size', '16',\n", + " '--num_gops', '5',\n", + " '-q', '32',\n", + " '--fast',\n", + " '-O', '/tmp/encoded_simple'],\n", + " capture_output=True,\n", + " text=True\n", + ")\n", + "\n", + "print(f\"result stdout {result.stdout}\")\n", + "print(f\"result stderr {result.stderr}\")\n", + "\n", + "# Extract BPP from output\n", + "bpp_line = [l for l in result.stderr.split('\\n') if 'Bits Per Pixel (BPP):' in l][0]\n", + "print(f\"Found line: {bpp_line}\") # Debug\n", + "\n", + "bpp_simple = float(bpp_line.split(':')[-1].strip()) \n", + "\n", + "print(f\"\\n✓ Hierarchical B-frames BPP: {bpp_simple:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "# Encode WITH hierarchical B-frames\n", + "print(\"=\" * 70)\n", + "print(\"ENCODING: Hierarchical B-frames\")\n", + "print(\"=\" * 70)\n", + "\n", + "result = subprocess.run(\n", + " ['python3', '../src/MCTF.py', 'encode', \n", + " '-o', 'coastguard_352x288x30x420x300.avi',\n", + " '--gop_size', '16',\n", + " '--num_gops', '5',\n", + " '-q', '32',\n", + " '--fast',\n", + " '--hierarchical',\n", + " '-O', '/tmp/encoded_hierarchical'],\n", + " capture_output=True,\n", + " text=True\n", + ")\n", + "\n", + "print(f\"result stdout {result.stdout}\")\n", + "print(f\"result stderr {result.stderr}\")\n", + "\n", + "# Extract BPP from output\n", + "bpp_line = [l for l in result.stderr.split('\\n') if 'Bits Per Pixel (BPP):' in l][0]\n", + "print(f\"Found line: {bpp_line}\") \n", + "bpp_hierarchical = float(bpp_line.split(':')[-1].strip())\n", + "\n", + "print(f\"\\n✓ Hierarchical B-frames BPP: {bpp_hierarchical:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pip install pandas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Display comparison table\n", + "import pandas as pd\n", + "\n", + "if bpp_simple and bpp_hierarchical:\n", + " improvement = ((bpp_simple - bpp_hierarchical) / bpp_simple) * 100\n", + " \n", + " comparison_data = {\n", + " 'Mode': ['Simple (Non-Hierarchical)', 'Hierarchical'],\n", + " 'BPP': [f'{bpp_simple:.6f}', f'{bpp_hierarchical:.6f}'],\n", + " 'Bytes/Frame (estimated)': [\n", + " f'{(bpp_simple * 352 * 288 / 8):.2f}',\n", + " f'{(bpp_hierarchical * 352 * 288 / 8):.2f}'\n", + " ]\n", + " }\n", + " \n", + " df = pd.DataFrame(comparison_data)\n", + " display(df)\n", + " \n", + " print(f\"\\n{'=' * 70}\")\n", + " print(f\"COMPRESSION COMPARISON RESULTS\")\n", + " print(f\"{'=' * 70}\")\n", + " print(f\"Simple B-frames: {bpp_simple:.6f} bpp\")\n", + " print(f\"Hierarchical B-frames: {bpp_hierarchical:.6f} bpp\")\n", + " print(f\"{'=' * 70}\")\n", + " \n", + " if improvement > 0:\n", + " print(f\"✓ Hierarchical is {improvement:.2f}% BETTER (lower BPP)\")\n", + " print(f\" → Savings: {bpp_simple - bpp_hierarchical:.6f} bpp\")\n", + " else:\n", + " print(f\"✗ Hierarchical is {abs(improvement):.2f}% WORSE (higher BPP)\")\n", + " \n", + " print(f\"\\nWhy hierarchical is better:\")\n", + " print(\" • B-frames reference temporally closer frames\")\n", + " print(\" • Smaller motion vectors (less to encode)\")\n", + " print(\" • More accurate prediction (smaller residuals)\")\n", + " print(\" • Better rate-distortion performance overall\")\n", + "else:\n", + " print(\"⚠ Could not extract BPP values. Please check the encoding output.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Decode hierarchical version for playback\n", + "!python3 ../src/MCTF.py decode -i /tmp/encoded_hierarchical -O /tmp/decoded_hierarchical" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hierarchical result playback" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Video(\"/tmp/decoded_hierarchical.mp4\", width=640)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11. Summary and Conclusions\n", + "\n", + "### What we built\n", + "\n", + "A complete **Motion-Compensated Temporal Filtering (MCTF)** video codec that:\n", + "\n", + "1. **Exploits temporal redundancy** via block-based motion estimation and compensation\n", + "2. **Supports three frame types** (I, P, B) with mode selection for B-frames\n", + "3. **Offers two GOP structures** — simple and hierarchical — with measurable compression gains from the hierarchical approach\n", + "4. **Provides fast and exhaustive ME** options with parallelized execution\n", + "5. **Integrates with VCF** spatial transforms (2D-DCT) for residual coding\n", + "6. **Uses Rate-Distortion Optimization** with $\\lambda$ to balance quality vs. compression\n", + "\n", + "### Key Results\n", + "\n", + "| Feature | Impact |\n", + "|---------|--------|\n", + "| B-frames vs I-only | **Large** BPP reduction (temporal prediction removes most redundancy) |\n", + "| Hierarchical vs Simple GOP | **Moderate** BPP reduction (~5-15% depending on content) |\n", + "| Diamond vs Exhaustive ME | **Negligible** quality loss, **significant** speed-up |\n", + "| Lower QSS | Better quality, higher BPP (rate-distortion trade-off) |\n", + "\n", + "### Relation to Industry Standards\n", + "\n", + "Our codec implements the **same core ideas** used in H.264/AVC and H.265/HEVC:\n", + "\n", + "| Our codec | H.264/H.265 |\n", + "|-----------|------------|\n", + "| Block matching (16x16) | Variable block sizes (4x4 to 64x64) |\n", + "| Diamond search | Multiple search algorithms + fractional-pel |\n", + "| 2D-DCT | Integer DCT (4x4, 8x8, 16x16, 32x32) |\n", + "| Deadzone quantizer | Rate-dependent QP with scaling matrices |\n", + "| Exp-Golomb MV coding | CABAC / CAVLC adaptive arithmetic coding |\n", + "| $J = D + \\lambda R$ | Same Lagrangian RDO framework |\n", + "\n", + "> **Key takeaway:** Even our simplified codec achieves meaningful compression, demonstrating that the fundamental ideas — prediction, transform, quantization, and entropy coding — are what make video compression work.\n", + "\n", + "---\n", + "\n", + "*Authors: Youssef Zerbouh, Hamza El Qadiri -- February 2026*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/PNG.ipynb b/notebooks/PNG.ipynb index 4eb155ba..0089e01d 100644 --- a/notebooks/PNG.ipynb +++ b/notebooks/PNG.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "id": "1e42347e-49b9-4b47-9637-51da1c5fca58", "metadata": {}, "outputs": [], @@ -21,85 +21,240 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "id": "5f4ae642-27d8-4f04-91f7-e31c721fa533", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloaded http://www.hpca.ual.es/~vruiz/images/pajarillo_512x512.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "%run download_default_image.ipynb" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "id": "ff5131a5-c8cb-44d0-affd-f917d48026ac", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "usage: PNG.py [-h] [-g] {encode,decode} ...\n", + "\n", + "Entropy Encoding of images using PNG (Portable Network Graphics).\n", + "\n", + "positional arguments:\n", + " {encode,decode} You must specify one of the following subcomands:\n", + " encode Compress data\n", + " decode Uncompress data\n", + "\n", + "options:\n", + " -h, --help show this help message and exit\n", + " -g, --debug Output debug information (default: False)\n" + ] + } + ], "source": [ "!python ../src/PNG.py -h" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 84, "id": "976d4c1c-efd2-48d6-a97a-aa7dfa481634", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "usage: PNG.py encode [-h] [-o ORIGINAL] [-e ENCODED]\n", + "\n", + "options:\n", + " -h, --help show this help message and exit\n", + " -o ORIGINAL, --original ORIGINAL\n", + " Input image (default: /tmp/original.png)\n", + " -e ENCODED, --encoded ENCODED\n", + " Output image (default: /tmp/encoded)\n" + ] + } + ], "source": [ "!python ../src/PNG.py encode -h" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "id": "ee8e6818-eda2-4f3e-a3d2-56c25e4886a1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "(INFO) entropy_image_coding: Written 215071 bytes in ./encoded.png\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "main Namespace(debug=False, subparser_name='encode', original='./original.png', encoded='./encoded', func=)\n" + ] + } + ], "source": [ "%%bash\n", - "rm /tmp/encoded*\n", - "python ../src/PNG.py encode" + "rm -f ./encoded*\n", + "python ../src/PNG.py encode -o ./original.png -e ./encoded" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "id": "cba7aef5-b4fa-41e0-99de-0ddc97d14565", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "usage: PNG.py decode [-h] [-e ENCODED] [-d DECODED]\n", + "\n", + "options:\n", + " -h, --help show this help message and exit\n", + " -e ENCODED, --encoded ENCODED\n", + " Input code-stream (default: /tmp/encoded)\n", + " -d DECODED, --decoded DECODED\n", + " Output image (default: /tmp/decoded.png)\n" + ] + } + ], "source": [ "!python ../src/PNG.py decode -h" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "id": "a42485ad-beff-4ae7-bbe2-2f70fd4fa758", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "main Namespace(debug=False, subparser_name='decode', encoded='./encoded', decoded='./decoded.png', func=)\n" + ] + } + ], "source": [ "%%bash\n", - "rm /tmp/decoded.png\n", - "python ../src/PNG.py decode\n", - "python ../src/RDE.py" + "python ../src/PNG.py decode -e ./encoded -d ./decoded.png" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "id": "3ed1f3ba-cf79-496b-918d-3710870a0b93", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "display(Image(filename=\"/tmp/decoded.png\"))" + "display(Image(filename=\"./decoded.png\"))" ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "629e9b53-ce51-4c6a-9835-ffb740fde7b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Code-stream file: 2D-DCT.ipynb length: 4326\n", + "Code-stream file: 2D-DWT.ipynb length: 3524\n", + "Code-stream file: color-DCT.ipynb length: 3931\n", + "Code-stream file: color-VQ.ipynb length: 3779\n", + "Code-stream file: deadzone.ipynb length: 7231\n", + "Code-stream file: decoded.png length: 215071\n", + "Code-stream file: download_default_image.ipynb length: 288968\n", + "Code-stream file: encoded.png length: 215071\n", + "Code-stream file: gaussan_blur.ipynb length: 2776\n", + "Code-stream file: Huffman.ipynb length: 2778\n", + "Code-stream file: III.ipynb length: 7944\n", + "Code-stream file: LloydMax.ipynb length: 7094\n", + "Code-stream file: Makefile length: 269\n", + "Code-stream file: no_color_transform.ipynb length: 4333\n", + "Code-stream file: no_filter.ipynb length: 3795\n", + "Code-stream file: no_spatial_transform.ipynb length: 2350\n", + "Code-stream file: original.png length: 215071\n", + "Code-stream file: PNG.ipynb length: 585329\n", + "Code-stream file: PNM.ipynb length: 2531\n", + "Code-stream file: TIFF.ipynb length: 2964\n", + "Code-stream file: VQ.ipynb length: 6522\n", + "Code-stream file: YCoCg.ipynb length: 4407\n", + "Code-stream file: YCrCb.ipynb length: 4162\n", + "Code-stream file: zlib.ipynb length: 7184\n", + "Original image: ./original.png 215071 bytes (6.56) bits/pixel\n", + "Code-stream: ['2D-DCT.ipynb', '2D-DWT.ipynb', 'color-DCT.ipynb', 'color-VQ.ipynb', 'deadzone.ipynb', 'decoded.png', 'download_default_image.ipynb', 'encoded.png', 'gaussan_blur.ipynb', 'Huffman.ipynb', 'III.ipynb', 'LloydMax.ipynb', 'Makefile', 'no_color_transform.ipynb', 'no_filter.ipynb', 'no_spatial_transform.ipynb', 'original.png', 'PNG.ipynb', 'PNM.ipynb', 'TIFF.ipynb', 'VQ.ipynb', 'YCoCg.ipynb', 'YCrCb.ipynb', 'zlib.ipynb'] 1601410 bytes (48.87) bits/pixel\n", + "Decoded image: ./decoded.png 215071 bytes (6.56) bits/pixel\n", + "Images shape: (512, 512, 3)\n", + "Distortion (RMSE): 0.00\n", + "J = R + D = 48.87\n" + ] + } + ], + "source": [ + "%%bash\n", + "python ../src/RDE.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8c60c8a-4169-404b-aa4f-4ce22952bb73", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Ubuntu(env)", "language": "python", - "name": "python3" + "name": "env" }, "language_info": { "codemirror_mode": { @@ -111,7 +266,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/notebooks/PNM.ipynb b/notebooks/PNM.ipynb index 94219cd0..c7993f52 100644 --- a/notebooks/PNM.ipynb +++ b/notebooks/PNM.ipynb @@ -110,7 +110,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.7" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/notebooks/color-DCT.ipynb b/notebooks/color-DCT.ipynb index 9f6e97e3..7ecb2289 100644 --- a/notebooks/color-DCT.ipynb +++ b/notebooks/color-DCT.ipynb @@ -160,7 +160,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.7" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/notebooks/download_default_image.ipynb b/notebooks/download_default_image.ipynb index 5f30520e..6b4b0da1 100644 --- a/notebooks/download_default_image.ipynb +++ b/notebooks/download_default_image.ipynb @@ -23,18 +23,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "a21cb35b-1f0b-4980-aaa7-02d4e96db952", "metadata": {}, "outputs": [], "source": [ "%%bash -s \"$default_image\"\n", - "wget \"$1\" -O /tmp/original.png --quiet" + "wget \"$1\" -O \"./original.png\" --quiet" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "2aa817f4-367e-4816-88df-23f57c23875b", "metadata": {}, "outputs": [], @@ -44,18 +44,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "a36837a5-0613-473a-8c87-0e0cdc0fb82a", - "metadata": {}, - "outputs": [], + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAIAAAB7GkOtAAEAAElEQVR4nOz9aYwlWZaYiZ272v5238Njz6Wysipr66qaXqrJ5rRIkCIpYFoQIE1LGAz4YzCChJEG0HBIiQIEjcT5J/0YCPrFwcxAhIjhTItkiyBFsprN3mvPrKzMjMhYPMLX52+z3exu+mEenp4R/iLDIp+ne0TYh4KVp4W9a9fM7r3nnnPPORcZY6ChoaGh4dWD/j/+z3/3sVNa61MvnScq5p0nhJx6vm7588AYn3peKXXqeYROr8+8cuYxr/7zypn3XHXrX7d8c3oxc6GU1ip/HvPeT10wOr0+c8tH9b6LnvN+5l5fs90iXO+7g6nZDo08/b4Inf4Ddfr5ufUn9d5D3X5k4PQPUHecWdT3nVefeZz1ODb3O85BytPbwzwQxgBA8zx/xgrNbShzKjpvIJvHogaaeYJnXvl1B6y6DX2+QDr9vS1qACJzBtB5CCFqXV+3ncxj3nvQ6vQGPff9zxEAcwesmgKmdr+YIwDmtgc4vd3OA8+5fF75FLFTz897Xi1qDrg1+9G8Abdu/51/g5r9aE59agu2c5owzWPu+Kw1AJzSB+Y1oNoSuG6DWNTAMa9Bz5s41pS0dQXbPOY9b12BMY+69ZxXfl0BvzABOWdAnPtccwRA3frXvX6uAKg5k635eWt/37NuV3XLqVt+fQFQb8Jatz7zb7uYcWxR5czvLwgA6JPdta4KVlczOOsHnj+DO31Aqdsgzus91H9v9Z6rbj0XZuqZpwJDTQ1jzuPOfW9zflD3PdfVAOZOpFBdE0rN/lLzfS7KEjCPuvWv3+/qmVbm1WdeOz/rcaxuOXW/45EAePLxFiXJz5pFDUB1y6n7fuo2oLoD7twPX9OkcNYz+nnUXSta2Puf834Wdd95zH0/Nd/zPHkx1zQ6RwDM18DqDaD1TUCLWUuoy3wT0NmaYuYx32KxGAvK0/sXffJnC1uEWdBicl0WZZKax6Ik88I60ry1DbMYwbaoRa15zH3eOTbc+RpA3fe2mPc89/vOmVEubMZXs3/Naw9z+8sZ99O6M+76/a6uQDpbjaQudScctSeOAHCqCeisbfeLov4iZL1F13ksatG47kBw1l5AZ+0NNY+6msei3v+ivIDqUtfkNY+6A/o8J5f536veAF3fC+hsB9B5zPcCWoyTSF3OWuN5ev9agAloUQNWXeqbbhbTsRe1WDqPRWlUeI7b6zwWpfnVdUer+7xz22fNGdA8t+BFmYDmXT7/Pddsh7je887zCpv7veaUf9FMQHMnUrrujHgx3l91WVR7e76J1CltYlGLkIuSnItaLD3r+9ZehJnDohaR0ByNZ1Gq66LcJesyv5yaE5GaXmFnbfqr7+RSs3xdz0as5rygszZxfGb7rH74md38vCaadXmOcRUhhDGufmiM0VobY2rHExgDpwqAhoaGhleNRQn+s+a4nicr9tyz3kYANDQ0vDCcHP4W66/4oggAAEAIHT9+9cdzV7KGADjrF3FeJoL65dTjvBrQi3LfRcUx1C1/rjPRGbtBn/Xz1uUCDnCn8uR3+ayavxju7HWpqwE8/S01GkBDQ0PDmdv6LyaNBnDmi8yLWtSty1kvki/qvvP96M+2PhdNAziv+WrdyOrz4tjicXzmldUAqgevjsdL4s/n3NFoAA0NDS8Mjw1/iy351PMX0ESGEDrWV57i//MsNAKgoaGh4YURAHU1gKdDTY2A0Xr+3ZW/6skqwqdl12Oc9QdAqO7i8MWKJ6hvqqoX4j+vYT1WgeMzZ58lsW47mVfOnOvnlD8/QvUz3v9j72deINK87zKPue9tTn3mloPmZYWsVUxt6n6vZxxPji+en9ytXtZSPSdOoi5Pyclzsn8dH+v26+N+d/zDz7N6cYYawOP94fO5K118zsvmftYcd7zjL/hiPdFL3OQaXiCMMY/57VyErnSGAqCyTJ185kpSnfsznxEvqwCAJx7txRpSv5janp1/esPLwcl5+snJ8fn2pjP0AjoWcc+o8rysnFc8wYs1TD/Ji1L/+v7prxYX7W2ce3zMcYN5wQRAw9M56xw458XJ53oRn+Wss3s2NDwLx0trj/1xvixAA3j6IsZJufcKTv/h7OMJzitZ3llzXvETdZnnn/6ivOez5qK1w/Oqz2PlX4TRH85UA3jS4v/kqsDLxMv6XHDi0U4K9bPOY74ovrA1gDPyT294OTg5UTjZoc63H52hAHjMaeRz+qtefF7W5zoZcgIv4GO+cBVueCmZtyZ6vrU6ZUvIeczbVP0zVapnfNS6G608X+hzHepuMHJe9VwMjz3Xk4v2jz1g3TiPecx7D/iMU248NjV5hlb6TN934Xnq65osqu9S/euxFv7cycKe/b51y3nujZiedKZ8vnKePH9qHMxn9vcnJ/WntqvH7rvwCXHtdgUA82K7Gho+kyfjPODiSbWGhoan0HgBNTwnr1qcR0PDy8dLmA30VWP+ezvbrKIY4ybO4xWk6acvE40JqKGhoeEV5QzjAOryovh9XzTmfpczLr+J83g1uWh+/Q2fh2YNoOE5edXiPBoaXj4aE1DDc/KkBgDNNLCh4YWCzsty/iRz0puDMbX9eU/1t527lDlvTKmZv/vZn/T4FzXLr+kHPef8/OetF38w7w7za3n6bOAZHdufe+I/74d1M/U8R0oM8+QFCM3bLwHm5JefT833Wbs9P80U81g6CmPM/P0D5pzHNdtzXdOQqbsvwrx/qbffwzxOjYOpkjjPqdDxfdGnqoHgUbs68a8IYM4Id9ZJHp/eTl4AE9BZ27gbzpdGaWhoOC9eAAHQ8HJz1jvBNTQ0zOMFEAB1/dznqzwLqtAZU1fjabwyKl6U/RJeFI32rFMUoHN64ov23c+3Pi+AAGh4uambW6mhoWFRvAACYP4i0pzTjQZQXf+iPPCCeFH2S7hoM+J5nPk+FrVrtBgu2nc/r/inRgNouBC8aoKqoeHi8AIIgPkaQLNI+DLQLAI3NJwXp+wH8IWpQidv9JTePs9GPM9NeVEDyrwQp4Utji2klAUOoBdscazu/hB1y18UizI5nnU9a7eTufOuBZksappw62LOOI5nUfU8r/Zc3beJBG5oaGh4RWkEwGew8Il/Q0NDwwXhlDWAuavVZ1yVi8aTqlkjAy4CL8pXuGj1vGj1abgINBpAQ0NDwyvKAjSAl9WN72RSrYrHEmw1nAsvStzDRavnRatPw0Wg0QA+g2YNoKGh4WWlEQANDQ0Nryj0ySz/dSe65zU1lkaf9ND/zE3J66ZSmOcXv6iUDHVl77zs5ot7/7X9oE99/9W+YE9SM738ufllzy9n3hebF69Q875nbYmZFwcw5/L6+2ecDiHEPMqqX8X0VP9Jcc3y5+T3n59ioV7x9U1kp9fnOG7psfghVbN/nXV/qUb+FyASuKGh4cXlePSvZgwv3MbRL7fttxEADQ0NZ8hjkfyfzItfkHH1+RbPT64dXmSB16wBNDQ0nCGnDqAXeUz8nCCEHnu6Yx3oAtJoAA0NDQ1zmbemdWHH9Fo0GkBDQ8MZcupk/+UYPU+l0QAaGhoajsAYHy8CnzwS9GLMPp9v7K6Wu5/7518YjQBoaGg4Q469hBFCJ91AL9gGaHN5uSOoT9kPYB6LygO+8DzaJwv8Ar7K2fubz7l+IXddHI/ZRk+NCYAnvKGf5KynSIuy4VZzOq318XNhjI8nep+//IvGovqvlPLJkp/y3uZzPv3uc76HT4apWnd9pDk92d7m7Y9Sl6pijQbQ8Jy83DOjJ6nmrcdP91xDWEPDs1J346znoxEADc/JqyYAtD6KPK9UiuPQ1nkaRkPD5+Q4dA4eTTgW3rleIQFwXvO1uQPlF1yP8+aivf/nK6dSw6szlXr+suoBL+tzvSjM0wAW255fIQHQsFiamW9Dw4vOKyQAzstkMX/T7VdLB7ho77/ufR9bujzWx19WU9jL+lwvCvOSLS7quzQaQMPn4lUbII792Ss3jOP1gEV5ZTQ0PMbJ3LoL9P85SSMAGp6TV00AVM917JYHn14PaGhYLPM0gMXehepnLrFuS6/rH33WfQnNSbBtzBy5as7Wxq1qf8vF1Gfu/gRzt0WY897mfK55i1cazLEv89EZrY0xeN7+DTX9r8mcFjq/HdZVmY8m/icDUMz8/Q/Oq/3XLX9R19el/nYD9dq/MaruDeaUc07xBwSbaheB4x9iBDDX+fjZR/KTNBrAK8f8hni2AvjYe/KkhHgJZtCNt0zDi0sjAF45zmtR+qwjG8+LV80U1vAy0QiAhi+IupGNtVNlNDPxl5pX7ft+Mc/bCIBXjrn++2fc3qqZ/sm7n3SneXF5ufPFN7zcNAKg4QtinlfDWS9OvugCpqGifhK3M6rIF8QX054bAfDK0SwCL5Zmpt/w4tIIgFeOZhF4sTSaR8OLywIEwKJmQMfZFuuaCB7LOP+iz8jmDyiLKX9R/t11A1WklOgRlRiovviiTD3z4gnqvs+qVsdhX/C8mspZL2I/X+j/2V2/KBYnUM+2/nVNmnX5YlKkNBrAhWP+ouIXXJGGhoaXlqNcJuddjc/LSzPxb2hoaPjCqPTaF1gDeFJFejlkwDybOELkC67J+fJyfM2GhovMCywAGhoaGhqej2qi+QILgCezsR+7l5xbnRZBswZQ0XjXNDScNc0aQENDQ8Mrxwu/BvCy0qwBNDQ0nDXV1Jk+u2XhrCfYlf/1Y7linpJvXT+e7vuRZWBhfrinnz9r08TxzlMnLVoIISkFfgQA6EcQMk8w1FPvdH0361N9/5+234A5smQd5e43T8vKrxfk516FGphHW7rDJ9HIp+eLP2lZ/LR6eT7q8vz61y7n1PMXzd9//vXzvtf5mAQNRo8eoGorR7V5vrz8Ne67oH0mLlwcwKnGnKd83VfNFlz3/TQ0NDQ8nQskAODRZOd4dfcpYaJw8WY0Z83LmkunoaHhvLhAAqCZ4T6dY3H4mGnoogm8uaroF1yPhk9z0dpJw2J5vqHyAgmAusxfLG2GmoaGhobP5gIJgBdlhnte1N1R67w4r3TTDU+niat4uXk+k/gFEgAAcDI58FP8f44v/kIqdVE49pI6XiN5updUQ0NDw9O5QAKgrgbwqi0C102/3NDQ0PB06JMjyDy/4y8mP/VJz5an+zuf9di3qPzs89YqnjGf+PH5k+7/x/96HDRw6h1q1f+sOUcTxGPuUtV/Lqr9LHB/hc88f+qnf+w4TyN8Sj3nTSxO3RfhZd1XYFH1nBfHs6iNjz5T4681NbxAGsCLTjMZfzVZlDNC3YHpsX5+0oW6oeEZaQTAwmi8kho+D3UFwPGs/PjMsb5+BrVreDF4bELwmdc3AmBhNAP9xeSsB8T52Vu/iC0JHzPgNF5zF5azNj2dasz/zF81AqCh4UKwKBtxQ8Oz0wiAhfGqeSW9KJz14vN5mf5OTvzhGVKnNJwvX4wG8Jizw2f+qhEAC6NZA2j4PNQdIJ60+D+5KtDwqvGYSfAzaQTAwmgiLV9NFrUGUFcAHC8APOYG2rS3hmdGv8ACwMzJ5z4PBPU2VHlGP/1j6kbkvmrJ7xTMeZ9zrsfodH/quV4x8wqa80pRbc17XjzH6VfPqych5DiKGwCOo7uVqrcGoJSo/qjeDMZHCemNqVdO9TXg0w/yWNv8PNvu1W3RSs3t16e2n7r9bnFWsnnv+agTH7+0R7edJ8jr3XXe9YQ89g9Ht3uaBokaDaCh4YvlsbDKxnD/GHM3gGoWyRcLesE3hW9oeBGpcjrBp434Wuvn23HssUXgxVXz3Jj3FI+Ztl/ZwLdFmZrNRdsRrKHhVeA4ycpxj63MQfVNAY//4OXQJD5zpn/SBPSZl50di4r0rsui1pYqG1GTSLKhoeHF4GROp8fyOzU8H40G0NDwhfJYSrXntmM8ORF+0hP8RYSQ0501TtUMnvKw56UBXDRvwLn3RQgaAdDQ8AVznC3ypNs+xvj51jgfcwN9uXnMC+jVXD+fK3jmeUU+dU2lEQANDV8oxwmWjwevR+sBr9xYdiqNt8/Tma95PE85pwiAk4pk3dxyT95gIZy6P0HtnbBqvqBjf+3jmRrGGGN80Roomrt/w3nX7NPUjXtQSqFHPFomfabVv3n3fYznmDyemh+/bgS4lPIxL6BHO7vVm4095u//md3tObxEasXBoDkbOj3l/Zx6/bNU7Fke6rz2A3hKnNC8uJY5/fdsTUzVd2kWgedyUvidOng1vMo0LaHhLPiClwoaE9DTOGlnfGX9jhsqnlRBmvbwOXmsT72aL/PkCPPYmfrUMk5gaATAUzipATx5suEV5FQZcK41OoWLNox+psnoWS7+AupzXuXAHBlQr3ykARBArSohaExADQ21uMhD/wtH49d/zHmpQY0GMJe6i2ANLzcvignorBc561J3dfqiRfB+AeWcagKqqQEgAN1oAAumSdrVcJInp/9Nk3huHnP7eXYvoJePJ6f/z/sezDP/74hGA5hLowFcWE5NIY0eT4P8lMkNxkY/28iNAfSjI8Bnj/gnb/qpWmoE2IBGWiOMkAGojo+SBZ9S3U/d97HiGrFzzqAF+4Kfx6iiATB9skHX9q+fg6mpXhhzeiQbQgge2QdPOmbWnnzNuf7pA/1jXsznOvrP23gEjut12rr1iwoBBOZTj2cQGDAIf5LJ/1gSIND4hAM1xhghjAxoXTnZG6SP1GqEEMYIYyplqY9a1iPrs/okU5sS0rIsAFQUOSFIKaNBU4YJplWTUEphTAnBlSM/QohSihCu0tkTQgxCQojqb621kJIgbDlWWQqEEQAyRkujARCl1CI0iUNCCCEEY4wNaKNBG2PUo/6oP3lspAEwYKJPaxJqjnRAuLbUMNU+AVWB6FMnT7taV9eczINvnha5Cqde/xQzxqn99OkXn3Lfefsl1OwyGKCW140GfKqWMy/u6rlkzCnP8NSxwDQaQMMLRtUtqqH/E1XAgAIDRgIAGGKMAVBGI2MMIRQAkK6iycAYo6WSYDA+moMDANIGALQBrbVRGjMGgIqi1FJprRFDYIzSUiqNTAkIYYQAIS2VlJIRqrRCBhkDoI3UCmmMqUYIIUo4oZhRpZQGJMtCxJIQogATQAqM1lqDAQlaa25bGNAnTwMAoDE+oQQgDQYvfO7Z8Ly8DB+iEQANF5q5+3wBABzt6nUkDIzRBuFHE9RqVcyYo/z7BBDGBMzRlJkgrbUySh2lZHikN2CElDYYEGWsLEtGsO25jDEAwAxLLUAbTInNHcKoUboa7oWSRmmDQAmVFbkS0iBTlgXWRBlQRmOMKect3weMkyRBBjAGBMhgUpmGMCAlxLEKXCkllFSzwkfTfAOAjv42CNfVsBsanmRuKoiGhosMMifsP0eJzQ1CCI5sdxigyq6DqxD8o2h7c2xGACUkIE0AIYwppYwxh1uMMd9vEUI4ZWmaYozb7baUUimhQR3nBcGYVkZIrbVtu1prjDEhREmdZVlRFApMlcoiz/MwDLMiV0WZlkJrTRjFBrABhJA+2vfSGK2r1CMnDQJCGWMUw6wSEupo9D8a98/ayFfXjDjv6kWZIxeVAmFx5tG676fmfWvXc268xVN+02gADS8YxzaRk9N/AMCIaqMRMgghBAQBMqDBACVMa62FVkppLQEAA0LYYECWZfuOa9s2Y4wQQjHBGDPGiqIgiCKjCELIqGg2kVIyRjTSWmshRFlKKSVUCV40IoQ4jue6LsZYKwlGY2MIxpZjd9ut5UE/z/Msy6IkSdOUIAwGjDYGKoOUllpprYNOcDJDnNZaSimUJgQbAI0eN70/caKhoTY1NICXYWGx4aXgpHPM8dIowogAMdUiZdVUDQIwWZYBANIIIcQYo5hQSgkGx+KubXmeZzGmlMrzPE1jLVUURbPZpNPqFmXGmR20vIODA8oYZZhSWukTShoA4JwzTCezGcZYl8IIiTEuikIIYYxxXBcZRWzP82zfckrX6XW6ADAcDpXRSqnjVIOllFKrPEml0cYYQghjDGNMmYUwfeQmhODYIGYwII0AobM0Q7/oGsDZj2ONBtDQcGY8af0/GusRwGkeUUgjo49XAMCAqWw0RhpKKefMsizOOWeMEELA2BZnBCHQWRLneV4UhdYaI8QoRqBdm3MKhDCbUd+xl5eXp7OxQahy1GHM4pxzziml3U7naNSmFgCUZVkZf3q9XprFWgE2uhQijmbGINd1PcdSSlW2JIRIZUpSRk+TWVGWQgitpUSEUowAEUQ0GAA4cvg5UnowMov3RGw4Wy7k92oEQMMLD3o0STbGQOW2ixCqkkgr3W13KKW2ZXFOCWEAGhRoLSkYUYgiT7MsU0pZlrXU7QWBVxSFy9ja2lpepLIoMaOBY68sD2yLCSW1VIARp4xQjgFppRlgBZpowKApZtx1KSaEYQxAwNic+q2gKESRxHmeS0F0KbXRxhhKiMUtyhjBWCHoLfWiNJnNZkmSKGXKsgRlpNaO4xj0SOAZDMcWsHN51w0vFzUEQN3F4bn+wjWZq8otpPQTKtLnzDM+L55gUXEVdTmvQLbHkuh95u1qq+oGTi6WIoSQrv4TEYQwOWrSlFLbtm1uua6bJAkoiQymCFzPQwaF4UxLJUUBSluUASXG6Gg2TeNoNBqtrSylcZhlKQIwBVCCdx48cF3XsS0JZVYWBlAhpSxKgxEnHDDGGOdpaaQxGFmUUYtTrLWSpSjHIjcaWYxy6mFK2n6AMZ5MZkmWWYxq0HmaWZ7ju+1Wu7u+uiGllFIVopyOJ+PpJM/zPM8t7tieWy1BW4wZo0ohKzfWav0ZYyyEKIrCsqw57/P013nRUiPM47GtIk/ttmdRn/nlL6T4uXwxKT0aDaDhBeN4ox6kDQKEEUYUIYA8KTHGiFLGmGvZtm1blkUZcSyHAmghhSzGk9lQCyl0EocWp91WmzFWliUGY9u2lHIWThyL53kWzqZCFEEQOI5VllqKYjxJXcevVgsSgKIosiw3xriuizElhFBKCSEY0QIhhI2URbXqYNs2IRQDEEoI4xa3lFIW41prJUQ1nVdC3v34DubMtm3f94Og1et0V/pLZVkKIba3t8MwFELkSaK1dl2XWcy17FzkVaxZJQMIIZ7nVavTDYtiviB5GRbhGwHQcCacnKA931zsZL4HdKKvyaIkhHBKKSfGGCmlKEstlWt5lBDOmW3bnHNCCNJa5uU4jLM8kaXIsmQ2ixAynuNzRvqdrs0tjDHFBGPgnGPQjsUm45GSyBhFCKIEaSXyLE3S1CAspRRClGVpWRbjzLLalmXFcay1VEoIUUUUY6WUUoJRRAjhnGslECJSKUIoY0wIlZflI0dSZLtOp9UCyuK8xIQQwHmSJWGMMfY9NwgCRuh3vvZ1rfWtW7cebm85jqOUure1NdhYVUpVig4AFEVRliUhpHHWWCzzNPj6OwPWvZ589iWfm0YANCyYJwegx5Idfub1R7+aU37VIZWUUohKulRu+xtLK4xSSikAlGWZZ2meZlKVolTaSM92gl6343uMscDzGWNS6uFwKITodtuMWVE8M1K5rtPrdTinSZJMZ+PRKK9CBPqDrpAaY2qMUUpV5ojKOOM4TmWRUkeUWoMxxuY2wgZjkFJKmZdlCYhwbnFuKyEQJwAwm4VFUQCAUMa17KwQWZlTDEqpNE33itwYwwj+6le/eu3K5vXNdZeYSmWRIouKvFCKUso5R492XiSEVLkoTr7VR3+f7Yz1rE0uZ33feZxX/EH952q8gBpeaqpkNpZlVcZuIQQjtNVq9Xq9TtCyEEEGpJRJkiRRlOepMYYQBAgwof1up9trq1KkaVoURRxObddPsrTMM8exGGPGmDzPy7K4fuOq69qdovQDN0mS6XQyOZzAIXS6A0JIWRYAhlKslAqjaRzH7VbXdV3P8yyLS6ke2WSQbVOtpUEAxmAMhBCEKaUE4ChxEDzaJ9YoDcooobM4U0otDXpraysE48P9/f2D3cno8A+//y+2Ny+98frry61gMpm0HP69737nRx/eGqVJmqZxHAOAMaayeqVpCk+sADU0nEojABoWzGNpreD5NYDTZ15xHHPOW62WZVk2txzHcV3X4/ZsOJJlmcZJFM2KoiAEtXzfcz3GWJYlqsijiU6SZDab5GmRFfnNN95qt9tTJUejkQHV7/dRqxXFsz/90z9tt4NW4HW7nWvXrgJcTZJISj0LIyn1sZen67oAuNVqDQ9G1cjrOE5ZijzPpZQIAaHUCKW0AtBaG62lUlJKWb0YRAjGtHIkNcZQSnMpLctSUsZh9FDIlu/Y3Lqyvt5x7fHBvi6KIpxxxhgonefh4eGVq5udQiRJUom0oijyPB+NRpVF6EkN4KwD/F9WDWCeqQfjRgNoaJjDcbrWhWcWqQbfpf4gCAICqCiKNIojMS1msyLLizSTUlJKHdtihGopuGOnWmVpUuRJHMdZnlBEXdcNw1ADIoxKraoxHTMKBH/jG98wRkXRbBrOsiwjBFFKfb/1+uuv56Lc398fj8eIEAWGWpTZLBAld7lGkIuyFGUhS601QQYQ1aC1VhhjhI1SKitKUarl5RXOudQgRAkAaRpPwxklnDmB5wZCm+3tB9PR2LZoN2hZHPc6rdeuXV8adJUosyTyOSuK4t7dO93XXrcc1/O8Kqogz/Pd3d2dnZ3Fvu2G+V58z+HX/+x94QvS2xoB0HBRMEgjg6sjfHrhF59ISHxpfcO1bNdxkdRJliVJUmSZloIhDACEMzfwA8+hlBZFlqbp9s5DIUTguUEQGFBayBKkBhzhiFl2v9/v9/ueaxdFMZ1ORan2hgdLS/21tQ2lRJqm48moLKOsKMM4ch2PE9pttTGmuSjTNNUaXNc1Gs1ms2ogphgYY4QSKWVljmeMY4wBEWXAaDGLo8BvSymV0a7rAjYi15ZjEcoIoxi7S0srS70+wWYyPLj14cct1yZfen1j0OI2lrNUl7Lr2M5m/6e3fmb3eq4XcMvrttpWa6nFuE/4wegQ4FG2YoQVQoARAGD9qXTrVSgZNvpEClLQQA0CDRjDk/srvAoc78HwyREhcur5mhObT0LX4ShU/enH48rULb8e9Cz1wnp1wp+eMx5bMOf63dfMhrjwuIGnn/9MC2z9xaWa3xgf53Ovyj066kcd+/Eaztkipb4qehwH8MmxusHj16FPrkMImSp/P9LIGABgiALgqlYEYcuyHItxzikm8XQGZRmFoZSSc55MJtyxFcDK+qrN6Hg8nkWRbduYgADd6/en0+lkNo2S2HEswplSwmgYj8eE8bLMtdaJ62KMGbeXVz0hRJqVWTpxXdcL+m7QmU6n4WQ8G00GvZ5QOkkSxm3LcRlmolQEs8onVRZllicYTLfbDbpBlqWMMcdxjIGi1K2g1++tpnl5cDjsLPWzLMuyLOi1iqLQoe70Ou3O+q2P7jBCVjcuIS2QkavLvbXlNjXlbLT7wc+mb964cqlPRZYbcegQ9LqXR9HWbFdk1HU2brbXNtsKJYja7UEuRZjG0yRTjLAg0JSWIrcQIqAAcNXwCDLYSC0LTgk2RiNkAEuEBVCJGAZgSBKzAI/SYxPKEz1inmllXkl12+Hp5T81XufUzbP0o6IeO9bqL4gcPcLjgmTu0cx9hFPLB/j0pOmT+pz+A2UMNBrAK8vFWRtECCmlhBZVQmaCCRCMtNFKgzZHAoCAllJhpAGlZZrnOQfQQiKlEdYYDDbab3fyogjDaRiGZZYneUwIMUoNowiUDtqtXq+npQjDMHCDwdLaaBZFcV6WxXA4xBhrrTnnrutyi1bePGEcc85t2+ac9ZdXOCxhMLNpaAzK8zJJS4SQ5brxbGaMwQaMMRQTY1RZFGEYzmbTKIq63d7mpSuU6uFwqLXhtut5XhYngDTjOE1CAM0Zmk0OZpP4zdduFll+eLDTbvmezYQqLq12scocNbNQDtkhptzH0pC8LItNz8yQpEkSJ1m2R2aiFJqgMLEpvnn1CnXdDx/cv7OzU2SRcRwwEoxAYAwCA6jamoRggjHHSiLQ2GCFjkY6g7B+Raf/tY51wZ/+4zOPNe9y2uj/mTQC4FXkePT/QsXAE7lQjkw9CGGMOeKVQydCSGvQWmlpKMaUM865xQillGJCMVaiNEbFcZwkCWjlum7lbl+WeZWKGSHEOJFSlnkBYHzftx3u2Y7WOk1TrTUgUkqhtSYE+X53aWnJsqwkSYqiYIzFccwY4w6XUqZpOp1OAYAg1HK4a3GNgFtWmuZxnNqet9zpFaXURiIDGCMjHSELrWSSJEppy3YAocPxCDSyLYsxVgrBCMmSqW1zl9O8SC2LuS4ZHYyn423VdYjSJjlANHOdFvdQYFOV5dgDnRUiGSrstAOHc5wYVaWSFraReaLjA0G147atFtvd37ZlsNL2sG6rbLg9nqoiY46rhQLAGhmEiDZIAiBAGBNhDDYIAehHmw08mvgvRgac5pB6njymiKBPdmB/GQK7np3qDTQC4Nw4c6+Az7r8cTFwxqkCTtNFERztrYgppQgRrbVSWisAgwLfY4RyzrlFGSagjZZSiKIsS2OMVAohYwCKoqiSqXU6ncqVU4iCU2rbtt9xGWNFmdm2PZ1Ot7a2CILLly9jjO/fv9/tL+d5nqapMcayrDzPEUK+74/HY8dxXM9mjFmWhRCqXE5TMJRSTBizsAM0E2o6i5Li9vrKuhAFADCKCSGqLJUslZEIU4yBEFYUBTLgeY7NuRQZA6A2tTmhzASW41gMY/BX2qsO3/nwR4HvXh30sE5dBYNWUCQjGwniI0URlnEZThVtIceydAJAENHaMVDqsAhZaTzXOI4f6sPpvR87MLm8tkGu9E16OE6TlscjENJgBZZGIBGWyhQaG2wo4hqpRwZCRJA5SrdX5dWu8Xnnpi449Z8W5eVS9/rHUpU89p+fn/nlnPHz1u2/xiCEGgHwinI+SsAnk8pPDL1KaESxNkZrKaVECNmW49pWr9UxSiiltJC5KqUqZVFKKafjiWUzmzDP87TWWZ6URZGGWSly23WX+t3KUxNjlKZpmqZxEnLOkzCaTqdLS33X9zhlCKEwDLMsq1LoVPFTCCEpZafTKYpiOgkRQlVQsWNToyUBkAaKOFUA3d7A7y/v7e3t7e/npRRSGmMAGMaYcMYYwwSEOByORw63VldXQZvxaKiloGCQ66yuDJTIZJ53+z0CRSnyy4M271gfzB5wojY7PayRFFMdznAet3x30KFEu+EkjiaHqYmYZ0shHM/BgIFr4wosszyZCT22Sn/AoiIZ4rHqrDg8QLMWtoqcyFhqEyuMNGCLEMyE1tpoAWAQwSCJ0YAMGECgH2kAi2kYVazDQopaFFUGqeO/4ZXcBav6Lo0AODfqJntauAYAj4mBM9UAkD7h3nBcOQQAR8nLFCglCWDHdrrdbssPRJmJQiZJIsq8yrdMABGCtJFa4ijNLZshhMqytG27SsTvtXzHcRCCOI7TNJ9NpuPx2POdoihc237zzTd93xVClHkRBMGdew8wYe12m1JaPWOVTaHf71cOPNU+XwAAgKUstRI9q0c5LbI0yYuW5a6tXxqsrEazkCLLGKMR5IUwWhJAjFHCLdu2kYEkDkFrrCUyZZnn4+iwZak0nuXpjIklZFSeJu76SjgdX1nieZ5nw7v9XjeKJ6PZeHmpZ5KQuxbhqG2BpoJqRQwgEJCWWisKpMMAHBnrDMoEZzMTTlqW6ypXj+4y4lxytd22YyilpkKIRGqEObYMpVRqAxgbozUQZCQxEhAQMNX28+STz/RsX/gZNIBnzLc47w51LtZ1K784RXchGkC9+j+l+KdE2jcawCvNeSgBBpvH78UI1RoMMq7FLGo7jmNRG7SZjSdlkZVlCUoTQgCMBjDGcMooxWmcAapSMhjf97R2uG0VRba3szOZjtI0pZR6nnf9xlVjjBDCdd1utytEcTgaIW38dufb3/2O1FAURZIkaRwhhLhjc863tneqfcFsxiilGsBoZDAxygBlnFmFQXGShXHOOfdaASDCbcoIBaOKNMnKArRhinq+Q0hf5FkWxwSZlX6HEW8y3CmSMh7vyiKBMk0OS4cRC5l8tB0e7LorfQsM5Cofx3k4NSK3DCviDHLsOxTr0nepxTDmBulSpHlWFAYz7npdz3CklVKc6QKFWKQ61NJGzO10ECYOeIgwcJTJRFxKkSJqY0wQIgZhBUCM1oARwthoBAZXK8Cobi6a09cMjhuXMQahkzKgbpbc51iTOPUnRxb/47n/o1qdddbe+vV/rnXdZy27WQNogC/aBPTEvQwuc2GMIYS6zHJdjxCSpelslKZJBFoCACEIIZNlWZamWZZwyhgPXNfpdDqEkDRNEUJZnszCSZZlxpggCHzfL4riKBeb1pWisLu7K0RRpf5XSv3svfc8LyCEVBP/atAHgCBoW9WCbVlGYVItElBKhRDTOMKYtrudfm8pF+V0OpvFMULIdZ2OTwmlhDCMKGBFKaUIRtMJRrC6PODYiCIu8txlaHVjUMQTzi2OGTWy3/VbgVemUWe9H44PlpaWet3O/u6uLmdLnY4WMQMl8iJVyKKUU0QIBlUmScQByTKTkFEGhFEMudElUvjmpaXt7e1yJvlSH6yuk2dFqTqeZQduVBRxVKayMDI3GBmgCOiT3+TRZpO1/NAvIC+yI9NZDv0nOUUAVLah4+1JKyeNylfv1CIWOIKc6js/r3w9x299XuTevFrW3ufgjEPV614/12T0bPsQfLIINueC+aHwdUYHgynGlbdlWZbIAKUUAEspjQTG2MrSssOtg4ODPM8xplkaWwwsTrMsy9LM8zyLU1lgxWi/3yOEGMqyLKla5u7+zng0unr1qlJCSkkIIoQiZIQQSRKNRqMrV64AwO7uLkKk0+kAwGg8RoTnZSaEKorC9/1erydKNRqNdnaHm5ubly5darW7vT4ghDjnlOKHDx9KrYpcZGlxL7xvMOLMJowUeV4UeTgeAWiLUM6pxRnFYHF6aW1NlrkUWaEKrAWSuZaZhfHKai+LQwpqbbAkyzQd7/d7nUky6vda/V6LEUOJuXHt8u72wyyRy4MepcRImZcZRoYKjDHYnksxgSydTafjaMYsjjGiBFGEk1isDLpZWubR1HZbIs2KuOj3lxgWmz0/TfK7hyOtkeVThJEBRAlV0hglFGhCMEbIGKWUwWROP3re/v4F5yZCCJ06jB7txgxQNXmEEQAgQKZmHEx9k2y9uAGMsTHqyXF4fhbS55HWp+8JfNJs95RQrIaTXAQXt7NgUc9FKQ/D0BjTarUIwlGUKKU8x+0vL4HW2ECaJEZrBIC1siiVZUawxmAopQRhRgm3mNJyMBhMJqM0jatmWS3erq4ux7Op41gE0Gw2wxh3u13XdeM4XllZqTx5KKVS6oPhUClFLa50AQDGIEJIWZZxHFvcGQwG6+uXKq/Q7e3dOI4ppe122/M8bjnUSEo4ISTJ87IsU5WhwuRZFriu4zoItCzyPCtAMuJYaRgGvt1u+0Vh4nFcZqFNjO+ytseJUZsr/Sye3bv9i6V+7+qltbLIPN8Jp5M4CZd6XcviQhQIG8eyKcVSVOmElEZIY4UBI61dUmWVY4RgwhiA1kaLUjELa6mM0loJEKVWJQKFVIHymSVxh6v1tp0ylkMBRmPsSZljLTEYhKq5PzIIA36Rp88AAPrpJvSL31uN+VRW1zNarD5FAFQqMzya4lW3rJ/8+pVjcXnDLxbznqtuW6yCZjHGYHBRCiWN5/jLS8u+62qpwjDM4gS0xsYIUVKKmc0JQVgbIcsiS5WgWkotyjQKw8lUCNFq+wAwnSYA4HutLI6SNKSEtTyPEJJGoQJjWZbvB3meazBLK8tg8OHhoVJqsLK8uzdUSjFGbdvGmKZpCgYHQXBwcNBqtYKg3Wl3bcspyzJNsiiMbddmjBHOqMVdjCvbkZQKlM6yTIoCI0NBOZy7rht4lsoikSWZTImRnsUssEwZyaKkyJ2O9m3UGfRaMu2k4eRwSD3PcVz34c4DDSoIPIzxselJKSWlLESJjGKMYUwNQlrpzJSlNohxbjsWd7SRqiyQkdogqUFqI4SAPJeyBKSRzrFStiZ9G3Hbi7G1G5ZlnlMERiiMESbVlBkbBNogg/DZ2+i/gDWA0zknF7jn5EwreboGAACVulGdqdSQ89racB5n77dbj7reO+dV/7n1mXP9gkxeGCPqOLwsyzBMHMve3Nz0XQ8ZE81CSmkWJ3ES2tySoszz3HNtQrBR0hithczLkvOjXP+Hh4dpFld7siOELMvSWlJKV9dWhvsHGkyrHTDKx+OxAtPpdPK8lFICAs/zGLXyPM/KwrbtlZVlhHAVelYUIk3TPM+reGAh1HQyq/RgxizPCyilO3sPOece8izf8zy/StmfZWlvYyOJwziaIa0923YdC4FOwpnHjCkKJTS1kMORRlgAQQLSZMYoPtjfJbq8emVz54HZ3t6+dGndaXmAaVaUs9lMSSGLonJRBV2KspBSUoo5IYQxY4wxqiiVNNpgQrnDXR+0MbTEWss8UaoQCojUWZEKpRDGSmY2Ba1FizDfs2NsZ1mWhAkgzQkHgzEQjYhCRgE2UEkCg0/78ufm517z+nnVfHL0/6LiYGqV/0n+jMeS6S7s/TeLwA1fKIaUpSpz4dju5UubKytLWZw8fPhQlIXNeJbGaRxpq5RSaq0pssNoShByHMexudaSc+44DsJGCOE4R7neDEbMZoTYhFFZFEHgxXH8cOs+t51Op4MpS5KkUsCklJPJhDArF2We54eHh0Jqy7E5twCAMr6yukopNwYhIHEcT6ezOI6l1BZ3giBwPRsjlOVJkiTWzLJchzFmpNJCjg4PsyxRRcooVhwJAXkmTZEQh3o2cixuEVTmsSgSh6F2pxtNRmvLvXAid3Z2GEYrK2uc20mauq1gbW0jiSbTWeTZjDHGKBdlmme5UQIACGIUA0FGaaWUMggMAoMIwhQjCwhoRQC0hlIKYTTRGoqi0MZgzIzKLUqlkrYxFkOBx5KE52mmqJZYaWRKZAwAAowQ0ogZY7AxL/Y6KsCc+ms4GkbNiT++mNntqfV5ysCt4VHeafMZyTmes/6nCIAqSuJ43veZO0uc1wrBi6IBzF2UXtRi73w/31rX110ErqnZkOkktG13dfXS6uqyxfjh4TicTJVSBFCWJ9Xmt1oJQojNOCaghECU2g4H4EVZIoQAaSFEkiS+7zNW7QxsKvt+OJnosgBtqogBjHGWZYWIsizz/RZjTGsdx7Hr43a73Wq1MCWtdhcAkiSdTCZhHmOMlUJZlq2tbkgpGWPtdleUKs/z8Xg8nujVlUFZ5nGcTqdTy7K8VtDyfMe1xocjjIzFODIyS1KRG5tx1+IURBbFIgXPYYwYDFJLk6ZCG7m7u73U63ZaQRjGBOOg3Y2zNCvKjY2N3Yd66/7H7uoSxphTqgothQQjEUJgsBISgVbSaCUYI4RSAhghogwyEpUFIKUJWEoXCBhCSCgJGGEGWmdaYFQqApqbwmWw2raVUoJZcSFTYUyppDGGUoOwxkRrw5BCT/jsPuW7XywNABmEzKk/OVn/E9NqA2jBi96P1QcAfWZ9TvLkGsBT99U4/WGfWqU5GsBx5F7V80+uBzQ8hZf1FS1qDcD3W4P+0trKKmXk8GC4t7djlPA8RykVx7EQgjOGtHJsbtu2ECVjTBsppSzLcjIeW5YFJijzQmuptTSGYYwBGaVUnmdJHLdsG2HtuH4QBMro6XQqipwyIkRBOcEYY4w5557nSWWUUu+99x4AUMo451XGZsexO51OWZRKKWMAIVI5klqWwxixLItSbFlWmmdKGgLIdnin01keLFkcWwQrkSfhLJ5N0yxJk7TX98IoibMU2l6/26KUFGmUREnLtyeTietYSxubRprD0cTzhO14u7u762vLRVHs7ux0PCszQnCqVa5EgUAihMpcgjZaEYwpxoAxIhQxxBi1GLOEksZgJQ1BxBiEEcaIKqOqBEvGSJHFIBECI7MZcTyX4KWWbWxvHOUoLbKiMBobYwwmgLHRx4kw6/DszouniZZFlv8shb0gKwFnGqt8ugYAj+z+1ZlqPaDxBXo6F01DWhTzNQwFANiARoDNURL505PbGgwAb335LcdykyTZenAvjmPHYmBwFIagVDQLGcWua2PQrusSgsfjSGudZanWOk6S3d3ddqfTavnM4u1uS2sthDBGA8EYY9d1PcdKZtOVpWUweGtrK0ridrvNuRWliefzY6U2TeMwDMfTSRJntu1IrVp+2/daCJHJZKJU5jq+lBIhzLlNORdCiSIvywLlRqrMcS3KGRFlHM/iJCyLJE9CVYp+r31lY31z8xJB63s72x998P7O/s5ma9Ol1A3cwHXAqLLIldaMOwbz9WtvRGHyk1s7g8Gy9vyx1MvLgw8+fLCas7shurUvWitMZLnPlWdjaggBSUFWmhjFNqWUMEuCAkwJYsy2Le4iJSVBkmhllASMCDGEaZAYE4ypMagoCkIYNkLlMxFzjLiFLMo9YZOkwBg0KEDEUIO0BqMVwhKQAvhksD6K3jaPBYhV8wN9ypD+6JRGJ6/8pKxT1xg+zQkJVHv0/8yUy6ZKQn9UMWRqi6XqJ89yfOxZnoHK9IJOxCg/5p8552GfvfIanr4I/OTJhTBX3i4oNULlF3h8wfHR6NOTm8/zl6/7yPMy6D6WbeqTzzmnnPmmlXl3nmN6mvuDOXeec/ncempFKaWEKK2N1sgYZADAEERFWSiNEMZSKUzI2tr61ctXZF4kk4PpdAois4kRWSSEQFoLUfS6AWPMslgYhnGaBkFQSIExxoxPptNCihs3b/aWBnkaD0ejPuratr21/aDX662uru7t7TDGBr3eZHiwu7+HEGp1g/7SYDQaTaPp6urq8HDseS6lOMuELrVWEHju5UubZWEYtxmlpRBJnCFDbYtZli10atuebduIUEINobwsSyGL4Wj/zeU3Wi1/BYBzOjzY291+GE2E7/Ldh6PJ3tba6mDQ7ZRFjo1qOxZRymacMi6EOJxMqEXXN9f7S8t/9qOfmki7fi8tze4eAmRFiegUKFn55n/9Rzs3r30T33A/iAGXCYyGK10CeTJoU2bypY5diJJiPFhe29q6j20O1KKUi1JhkJTbrkdzSpJ4GiytZMksLIpWt4MQSmPh2DbGMAsjg6DFMC4nSFPOPCgYNrQssrKU3Gph7pZaa1lQ0K5NtJFKKaWMMQYBQQhhRLVWYI4yZGBz1G40QgZphB5NFgEZYySA0YgQcmRdMVhXk1kABAYZoY8TxBoMj0YvhKpCT/amoyTVc1riU8BgEKBPHTE6/rsamo+GaTQ3G8pTxh8Dz36saaIhhB3d/tH48Qw2hhpDFoaXdD+AkzITHgnSc5+GX3A18zkghAAyWquqhRIMYI5aKKfMGEQpdR3f8zzHsiejkUiS0fAwz/MgCIKOn6b48DCJ4/irX337wYMHcRwGwZrv+4eHhwghzizPd/f29jDjVzbWGWPj8dgYc+3atQ8++ODS5nq73UmSJAzDlZWV2Wz2s5/9rB20osnEdV1K6Xg0BYBerwcAlmWFYaiUtiwLUbK7uxuGYRynV6+8RrAlpSxzwZjVbncp41LKlbWNvb29rYfbCKF2t9/pdDwcCFEsL/fu3P3YYvTK5oZrO/1ux6Xk3p2PrJaTlnkhoUis3STe390usrQXuEWerW+uJ0kUzxIv6B5MhtnWztLmzW/+6l+4fffhv/r9H6xuXL99//7P37/zS9/+lVs/+OOJSjq97l7mxyPMhAqonR6q9etvWKq9t//BWs/ZH4e+Rdvt7sP7DyzbAc4M4VKYPE/zDHkuppRRbjtBi3EstTAlxoQDACGIUAtjQnkuZalkKlItJEhWIswZ71qUYqSLXCFdAnE4QtKUZVkapE2VMsZgANAGaaNYNTBV39o8yiCNkNDVJL3aKgsDIAJGHf378eT0U+Pg8e5vR6nCDX6UA0c/uhgq/cE8xwT9+Orqj8881tYwznr/gDNFAyBA+iUUACfl5Ke2GDu3Gr0w1sZaYEaVUlpVjgoUEHqkcyBCiCik1IIHrNvugNazyTQNZ0IIQpEBlWWZlHJpqX/9+tWDg4PqtQyHwyrxMmMsiqLhcEgIabVanNsA4Hmebdvdbvu3fuu33n3vp5TStbW1MAzfe+/9MAyX+l1CSFlI18F5Vu4ND9vt9sBy4jh2HFcIYbD2261Ou9frDsqybLe700mS57lQElPCmFUtHdu2/fDhw7IsPc+jlGpZ7u9uG0Q4p+urA8/zyjy7d++eEvLK5fU3btzY3FiZjUedlkcwICV2Hm7v7OxQjNq+HYsyVjIS5TgrbUwV96aFev/uzvXXvxSV+MP7D2l7rQT88fAh+/D9W/fuF0QVH338/T/4ky5prfcGti53Rx8O+q2v3OwIGsRKcMPbtltImEbpwLJlWVKbARAptEalZSuOLcYYoQ7GWnBbI62rLDcYA4DURmlQyhRZXhayBIqQQ4y2GW8HdluWRayFQogyQEQrJCRCyFQzekLMMdVWVYCUMQBIHk2tDCCsAODTs2hD0NGMHgzSCE4ajzQ6dZmhfhK0hs/BAgTAWac6eO7rTzoywSNvqrO777MX+PSSL5p309PLV2AIIQiQMUZpjRDKsszmlm3bFmWMkDLN8jwPJ9M8SzAgy2a2bTuOI4SIotnOzk4cx4PBwLJYtUsiQohz7vv+8vJyu912HKfK2m9Zjtbm4OBwMpklcdbtdu/du/fw4cOr1y6//vobnm3vbG8vLS15XlAq2Wq1Op2OZVlZXvi+zzkvpS6KIooiy7Iwpnt7B+3WYDY9jJKYUqqUybKMW/ZgMKCU2bZNGC+KYn9/fzKZ2K6/srL07rvvXrt+NU/5cH838Pwyz2/fvr3S72RZtr687Np8d+eBECIIAs+xGeeDjdW9cIYQsto9ifDG5o0sF3/0k/d+/0e39sfhMCxvP9j76td/6Te5v727+5f+2l9bu36tFPpnP/55PJ797L0fuGBW+Orvfv9PC/HmW1eXJtnOZm/Z8vnBeNiynFkYF7ps9YjrdLFLMbIsy8IYS6m01lKWxhhKuNFIKa01lFJbjGPKzNGGCoVEjHEPGe1Z1qrfA5/og/QwkhrbCnEpsUEMIW0AVeHBCBuAKgRNVZsJG2yMMcf7/CAA/MnYrRFUZnaDqws+sbRqgGo/18oz5qRPjobqDDLokzkb+cSdp2YPrtmga15+xnLqjPsvQgjBS5kN9HjR/LE/znfHn5dPCdAGKQ2ACMIUENKlMAowRshgx/FWBkuu7eR5OR2NoyiSQihR9gddy7Jms9n9+/eVUgBaKdXttuM4TNM0CALXc/b39ykjg/6S7/tJkkXRIUJIKZXnqTGGMhJFiePYvt+KomR7e7ff7xuNfr63t766sry2TjCN43jz0mXLsQ2A5wVpmgtlECJFIaZhhBBKk3w0Gl+5rLXBvd6g2+16flAFduV53u72i6LQWjutwPf9OI7TNNWyvHb16t7O7mi4v76+unlpc+fB3Tu3b8cbqxgZjsFzrNFolGWZbdudTsfzHa/f2xrtawXd3hLjTiTZg93xu7d27j/YTfISUffwF3ew12OOHRUFtZ3/4H/5Hw3H0+s3fyjSsvuPN370x3/kLLXubx/80c/udLvvLLmdRMrJTOhC+wxJKaWWSmlCiM09BBxjrLTWYIqyFDLDxDBGlVLKAMZMaWQ5nhBCyFIVqZRSY6CiVHluUeZ2e1a3XZJE4CQqiVLYEIaJNkZoY4zRGo6cgzDRgBWAAtDGKEDKGFwN98jgo3Q6xyLBaPzI3R5AHDccAACEweDHPS+PMvS8JB3kheACaQC1/dznjOePlXNi5H3GCn7GfT8PzyIGXggNwABIoxUYijDG2GitDCIE2Za9uXHZtWyLcVmW8SwMZzMAaPmeNhbGeDabbW9vT6dT17W73a7neXme53m+s7PjOM5gqd/pdCr94Be/+FCpI2NRt9vd2NhwHKcoMqPh5z9//+GD3bW1DctyhBDGkOs3X4/DKcFUSh2nGWMszYs0TQFTy7LCgzEhxLJtKRWldHl5ZXPz6q2P7npeUBTFeDzuD5bW19cZY/v7+4iwKgeD4zhe0BJCDIfD0WgYRdHa2tqVzY37d+/84M/+7Gtffesrb37pF+//7MaVy1rL4XAYTmdlnpegXdvyWm6hJLbsaBYH1Pa97g9+/P6f/ehdaVgqrExR32tz2/7Bz35huxZj7B/909/90je/8x/+h789HRf37j387b/xH0iFfu8Pf/dq68Yw2v7oweGV77wWzrZUHF5b7hbppNP2C2NXU36KjTFaiBwjwjgFACGERShhXKkCEGLMAoQKqQulpdJaAyHE5jZ3HGpZWkiigduuF3Avt0WGdIk0FcZIbUqlpDHSGDBYG2wMBi1zAKWMAoSNxsYoAALGcEQAATLqaDdzZBBCBjRC5tji/Mm8HhkECBBCJ6ZlR7P8Ty7Cj85XeoJpNICFFv/CawDzvG4APnG5OTr56ZZ2PrxkSoAxyADWCCtAYBAAti2n3W4PBgMtZDQLR8NhGifVto7VTx4+fBjHYafTuXHjGkJof3//wYP71YjPLVaKgjFWZeucjKeAUTvouZ6YTqcIU0K5kHo4GmOM+4MlAEwoa3e6Wuter6eEVLYI40RJk6XFQXRILc4Yk1K02904ybUxQqm8KGyEDOBSqO9895e1NsPh8O7dux988MHBwcHS0lKn0wGkOWdGo8PDw9Fo5DiOxehSfxDFswcPHlzZ3PiVX/mV+/fu3b9/T+XFO++8Q4zOsziaTdI0VUp5ju3aNkKolIIwGnQGtuNPo3L3YBYlwGwHSMtr8Van2+l3w3hmubTVCg4n7/6d//3f+e3f/u3vfe/6va09ZfBv//t/4/1f/Axwqak7CvMo1S3qUsg4ZcjiRkvH9dNSZllGkAMI5ZmklHGbU85MDgawQUQqUAYz7hqMhBJSgVAGADGCLcvijBuM0zSVo0lm23npEO452EY25UqXIjZKaqO0lsYYAwIbA0hrTQFp0NqAQkYhrI0xgIyCytWiyhmsATRBGiGDQANoDAaMBpBHw/onnfGko+fJ/8OfnDX4yQ2lP5svKqPyC80LLQBO59jt53E30PN2BKp4OUZ/ODa1aWQ0MhoQQpZltYPW6GBIEI7DMIliRmi73c7TdHdnR2iBMV5fX2+32+PxeGtrC2O4dOlSmqZVHv9er2dZ1tbWVpqmjHLLcafTKWNsfX3dGPPxxx9HUYQx5hbtdrvGGMty8ryMooQxazQabV5am47GlmUx28nHk6V27/Lly1ESp1kWtDq+70spoyhxXTfPyzt3Prr10d319Y0333zzrbfe+vjjj99///39/f0bN25kZeH7vm251daSCKEwDA9HBysry2+88cbWvTvvv/fupY2Ny5c2szi+9dFH2OiWZydRPBqNOKWXLl3aWFspVbm3s/tgd2dl9UoUJT/+6cezadZuDd67dW/QXyOWjRHb2x21up5jWQ+3HnJKk0T8ynf+wv/qf/2/uXz12tb97X//3/vNP/jX/6P/+r/8v/ewNkC37m9/9621tpHhbHhl4G7v3O9fup5npSTEtQ0mWEpZDZ2U0iMzjTal1ICJxoRSajuO1EKUmcyVAVxKI9JcyNi0y7gMI8pT0jfMpZZrI4tqwDkCrQBpY4xSQmutldRaEuoC0kgbY7QxBo78LFRRZBopY7QxCsAQMIA1BjAgEFSuoxpAPvLvNAbUCa/8kw3rpEfQyWVjdL5W3JcS9H/6j/93n7eIM17UXRT4kQw4GVH9FMFw0Uwx5/WeCSFSSiGEMYYxxhgzxkhlAFNEMGiUZRkovbK83G21iyRrB969O3fD6dR3PQxoOh4bpVuddqnKVss3xhwcHMRxWC0FG2OyPL1+/frW1tZ4PI7j0LKsN998czKZZbmwHY8QMplMZrOZ53mu61az7NXVVd/3q1xpd+/e3d7e5pTdvHHNtrnneYTRMAzH46mU0rJtIUSvN7BtO85So9FgMFhaWrJt9+7de7NppLUeDAYrKyuEkFk4CcPQd9ylpSWtNaV0OBx6njcajdI0jaJwMBgsDXpJEu3u7GAt+p2OzXG/02bY3L97p99rd9vt6Xi0ujzw2+7uwYM/+9EPXb//4598pJB/5drb/+aP3w0zZbvtQirLtXqDHiZyONmL4xAhpAxNMuG4rb/9d/7O9RuvEQO3fvHzv/t//Jsy2f3yRucvffuNN1bZEp35aGKSA24Rq72isE2oQ7BtNDMaYcY4Z6VIpRZCFKWSDFvcdm3Lw5QpJaTIy3iSZzFSElFbgB1pG9qXc2s1t9dya6mkfcXbhPmIMEBCFImU0hgjpay2tmeMCSEwxpQQjKiUUktpjCEEpSIzSGmppCqlLMEorYVRglCjpQQkOcUYH4XjUGIYkaXIwChKMUJIiAIDMEarfT4eOSgSAEAaG6wROloafoz5E7t6KUzqptNBC9Iw6qaQWRC6yq3yEmoADYtFa00IOd44Fx5FiSPASmiEkMMt13GW+wOLcZEV29vbhBDXdrIscyz70qVLQojZbMJttrW1VRRFv9+/evVqWZZJkiil+v1+tVEMYywIAkIIABiAbrebZllRSM55r9drtVrdbhdjnCRJkiSHh4etVsvzvJWVFSl1lmXTWaSn0rZc3/fLshyNp4eHh2UpbduOkmIwGBDCAEyUpJhOHbv81je/naZpkiR5nle5KAhFg8HA4ZaUMkmSXq+3vr7u+36e55PJZHNzczqd7u7udtrBzWvXtSqiyeT+/ftYX/IcvnnpUhJNXdvpXrs2Pjx4663Xv/HOm9Fk/JN3P5J5ZhB/cPeeRagu80RGth/02j3PcZN0JjMBUjHLci2vzKdpNLp76xedlkcxolhuXlo9uDfVQuRpmsY0YbHvGj9wfN9NNaKUE8oJppQ4mHKMiQZNuKtACWGhLCsLbUqFsbEoVhobIAbbBgsDxGAmjSWRdXA4Vb7HyLKxmQZTFAU13HapMtV2bAQhRAhDiBgFGBGFMAICmhqEEHBCgWGKKGZuqZBUSpVlLotcqlKWpcKCUDBQai01IGOMQYogjLAWKsKIEcIIwUoLY5A5iiEAAACkweBP4gYMrmvSWVQKk7PmfE0CL7IAqG0WJCdNQ3Der/5FodobvQqv01pXoz/FBCFsMOacu7bju67N7TiO9vf3ZVkapRkC3/cJwmmeG1BeKxgO94PA8323LPPhMHccx/NdrXWSJOPxOIpm169fV0rdunVrb2/H8fw0jaMkti13aalf+ThijJVSg8HA9/1q0/aylL7funKFTyYTpdTDh1uTyZbneZ1Ox3G8117rO14Qx3Ge5+PxtN3prq6uBkFQFMXe8PDg4ND3W51Oh3PLAaCUWpbl+/4P/+xPpJRhGFqWxShZW1vzPO+N118bjcez2UyUuRRFJ2h5Ll9eXl5e6oIU9+/eXlteEkX+3nvvvfnazRvXrtuMxbPDb371rZbf/s632L2H091h+vMP/pDRVmmkTQkjWJUijeI8yaSUFOhwuieUIozubd8brg1m00NUloGNRyrPE62lYMwBQFIrqVScJpnRxHCqMGhNOLI4GAN5mXuek4ksyzKpDEacUI4J10Bc35WqAABhQAohFIQSTUv1YDgppswuW6vumt/2uWHSAMEyT7Lj4HkljRIKGQwEO5aLMaWIIoQxoowxTi3CcAG5QsIYo7VSWiiljBTGqMl0VOZ5KXKtpFZaqtIYQ7GyCSIYE4SNATAYIYIMeg5Tbd3I+YsmAM5XUNHPPwiem6mkrkkETmlbL5A3znmZgBhjUkop5XFLJYQQzMpMWtzpeG3Xs5GBJEnGh+PDg4N+t8ccy7EYaDOdTsMwdGze63WWlpaMUbPZLMsy13Vt246T6MGDB2EYfu1rX+t22+PxOMuywWDgONa9rQetdtcYzTjhFkXYFEWRpmkYhpblVOag2Ww2nYbVykHlKaSUWhqsDQaDXq9XxUBxbiVJYgCMMVlWbG/vJvkd27YDv93rdMqy3Nvb01qDVhjjykXV933GWK/Xm82mD7a2bt++7Xne8vLym2++eWljA4NRWkSzMJnJVuA7DBMMnLLt7e2NteVCp1tbW5c3N/Z2HlKIZJ5e3VjpDDY/+PB31ldWGdaYKs8NLIcoWeRFmSWpUgo0UsowxrhtZ3nyZ3/6h9PpXjgevXnz2rXLazsfIFylOTVQCBlDISFF2CSy8APu2AyMwQYTzABjabTBKEnz2WyKidXpeNz2AdOi1I7LlChLRSRQTZkhVGqTGhin8cPdh3pY3kSt66xNLC/NwnIi79y5Yzm257iMWQBACHMd3+Hc8/xq62OMEMFHqfQMUsJgCQIDwpRgMFUqSUxgdWUpy7I8z4QQZVHESZKlsVE5BgPaiFIhrDFBBDOCDBjzyAsIwaP/VUkaEKrnqKN13S1s6/avWpfP5axN0HN4GbyAanMcGVD93WgAzwLnvHpjVaxsNfVGWmLAFuOu7WCD4ygqy1yVwnN9hFC/3wct7927N5lMgiDAhOzs7eZpVpa54zgbGxuu58RxLKXs9/s3b15P07QoilarRQgaDodS+jduXMvyslRSgX64u10UBaOcEJIW6XA8Msa0213HcahFDTZSa0xpEmcWd7r9YDAYcM7jOM6yPEmLard3xhhhjkGE57lt20G7U+0NizFgjAmxKKUEgTGm2oHL4qzb6fS63TxPCcKE0el0CgBGySxPVF72Oj4hJAxnnXbw1a9+9Yc/+NODg4PN1fWHD7f+9E//9M9/7zur3dYPf/BHSQlr65c6HV6Y7Bvf/NK/+rMfDFzLEJdaxkgC2AhlKMbUsoqi5IwJWUxno+G+lUWzaOJ3HMt37YAxABxGSWEKi2Jm2a5Np6P0aFWG2pT7rusxi7URGKPcwhVKasBSQ5rnCBTGdBrFaRrHcayMthwP2wHjlDHAHsSj8cGD3VD+eGc44ZanlAZMP7p1d3lt9erm5V6v7ziO4zidTivwWpRWO94ToxSAIqTUOpdlgYhBWiCEKOGUEI0MIYQxttRdqQK8pdFFmo1n09l4kmUzC1tlEWZppJTAGFNGMSilioUGAj97/v2XM5XvZ3IOGsDCJF7d6x/d9rEbzVchGw0AAKAsSyklQohSaowRQkgpKaKXVq4xalmExlk6G0+klJzTVquFEYxGoySaRVFU7eGVFXmSpnmWLQ/6g8EAIVTFTDHGWq1WUWSMMaXUbDazLHb58mUASPOsLKU0ukoWnSSZ67q+F2CMHceZzWZCiPX1da31eDymhK+uruZJoZQqy3Jra6uqMOM259x1XSklYNput69evYoxnkXxdDolFHue59pcKZXneVEUoiyUUhsbG0VRMEqklEHgFUWhpUqSxG+1XddlBM8mo+l4gkAOh8OH9z7++te+OhwOr127Nj7Yy/McIfTBBx+8fn1t4C1/6xtf/Td/9IPR4c6/+z/9d/7e/+t3BsvByqC3N9rpEuS3fSewSUQKWZZgbNLOiwQTggnp9Tqrq0tstUew3tvZzrLkcn/ZbwWYS8/uWoHQymCb+wFjjFXiDRMilFTCEIKyIkcEu74vJaSpKKPcsdutjocwxsTCRBRCGkWIIYq5CPDG9W5iTfT2JEzTDz543xjku16r0+12WqtLy5sbl1ZWVlzXZZwwxhhGUgqCtNEyLzIpJYApiyJNU6WElCUhxAt8x7IxZbZtU+SXmTBaU4odyl1OEGiQgmHluzRPLYJoms0AJAIDRhuDMCKAdBUPXCXqQQgBrhYtn73ZaozJqWP9nPGndrK2Rc0e5+23ccaLwC+JBvDsZjJ0vADwjF5ADRVFUVSBUVUSZqWU4zjdVtfzPFWqIivzJBdFqbVWGJRS0ujDw8OiyNrtNrdolmXawNLS0urKCqdkMpncvXs3y1Pf95Mkun37o2vXro3HY8ti1WrwdDoty7I36I8m40IIy7J837VtmxDiOLaLHKOBcwqA8zxFiGRZBpC12+3+8hLBLM/zMAwLUVY2n8PD8er6+vr6erfbz7Ls7v2tNE1xleif0bIsD4TIsoxT3O/3L1++3Gq1Pnj/Pdd1+/1+nueB5870rDRlURQ7H320vr5+7crlq1evZkvLskzjKPQsOhwO98v8G19/p//aa9PR2LG5FuU/+2f/LJve+PVf/45l0x//6I+/5fnLq+2d6fSXvv3Vf/57f1KIJEynHXfF9l1msawosrwMWh0FKpqMLRtPp9M3b1ymRsk4krJcXV1dWlmzzCxoedyKp4eHqJC264lCRVEEhjCLlVkmjSIEYUpKWSiDqv0MEMGIMEKIMUApx4yXaRmnoYyl5CZnwdLGJrTXO+vFJEyTJNdSeY7tua2gsxZ0lnqdDqcUGSULkUSTLI3KMicESVEkSSxViTHIokySRJdFURQYUzfwPdvBlLuu7wctZlsA2LLtIGhTSo3MQBdgFBhucddzpZRlUcZKaYoxxhRAHueYexbmTHReGOX+fPcReWEFwHMEhlzEPFNPz1f+2JGc5fWn1g0AgFIMgAkhxhglDaPW6mD96uVrt39xu8hKY0zlMYkxBqSzLJtMxu12e2VlRSlhjPEGHqOWNvLnP/85QUfNXQixt7fXbrdv3rw5m82uXLniuvadO3eGw2EQBLZtT6dT1/HzcmoMarU6hDBjjO8FnucBQBynW1tbo9HkypUrb7/99nQ6LfJiFm5TSstSZlnmOE673SaEJUmSZVkURVLqyWQSx7HjuZ1O23XdIAiSJB6NRnmSKiHjcLaVRlqqVjvI4vjubLK3s7O0tMQYCYI2Qqjb7W5vb9+6dQtrYTF6aW350sbKW196Y3y473B2+8MPOKPrK6ue0/3KV7u3fvGjH/zxj6PR6K13vr43DP/pP/7H/5N/72+Mkt/9+a0HN29e2hnOknTcku1Op9PrLw2Ho7IsZ9HIcywLq8BmpixsykRSZlG80u9vbqy3fDsc7RalZJDlReo7LQMQpRGCnDuOTX2GMAiFMG63uoezSZFmzLLdoEU10hrFAiZRaAjLcrIXo8NQCix5mxLfabF+t8ODHkWEcYoRMkaUhTCTUBiZ7e3eN8YwRjGBNI3jaJJlKSZQlnmaxshoy2JKqTSLfWYnSSKlrPZq1hq4bfm+z20XMHJdt9vt2rZdFMU0jNI0fe36a4xSyoBQ0IXQUlKOGWNC6KO2Z463kziZHPSZu5bWp5qA5giM+vn0n4dTeh9C8/opqtnfax3h0X4AT4ykdVM11NWF5iVlq7ZAe1ZMVc8atzbGPNoF9FER8/NJPOWf6ptWnnJ9FSX/qeMj/+LHj1V8DYBBCACOM6sDQo9icYw5Po8QMubxkj+j/BPN4qTHHTIGgcEGhFAEyFJ/tdtamk6i6TRM05RS7HmeBjMaHdo2X1tbq4wpTPF2u5Pn+fb2g8lkhsGEk6Hrup7nuK57uXeVcyalzLLs6vVrH3744dbWPdu2V1eXq+xvWVxQ5kwOJ0JII+HSpUuO6yAgspCMsU7Q8d/wwzDO4kwWMvCDQd97uLfb7nY4t9I0lVIyQg1G7V5bKzg8POx3TOB6DFM38Fuen+RZWZbXrl3DBnqtIPAcx+L3791tdVvLg348C5UW/cAdDofjSZhMQ+o4rd6gVKC1brd6Ny6tU6yGu9tb0RSBfvP111ZXlvMknU5nSprLly//yq/8hZ/+/j/9+U8+Rsj/1V/73h/86If3Pvzg137pa//iX/3L7/7yn/s3f/LjDz/euXTpsu85ly9fHh1GnBlTJAEqvZ7Xd6wrS2u2YkUsRVx8+2tfW1/trSz5Pbsfj26lxbjtWaqIE6K5xyliYTTSWly5cp3bwfhwPJvFyNhSo/EoZ7bVGixpQ/aj5CA1hdbC+DJYpe02pS3PX3ZbPctqr/Z6g36nKKP9w+04mcVZfHA4wsSJ43Qazsqy5JxjDFEUTSYjpZRSSiNdeQYrLQEAY1BWKWSR53k+zqSUxiiEDUIGIaNAG2Mow65r93q9paV+EHSlHnLkco48VytphFRKayOr/kVO9BvzyOden+4IOqefEoRPHdCfaoKuIWPq2g3wUfbTJ/93LKg+dayiIcA86/GR0cw847F63hdWA3gZOH0gfvrxhPRCc65BT/3XpxyfqBvSAMAoD2eRMaTd6raDju+1oyg5PDwsy9JxnCDwLMs6PDyMomh/Pz44OMiyzPd9Y8xkMplMJlX4rmtbV65e10oYo4wxcRwbYzBGlNLf/d3fbbVaN27c6Pf7QhSHh4dpmhLCEELf+MY3GbV2dnY+/OCW53mdTq/a3VdrbVmO7/v9fl8IIUoldWK7TikFYGQ5FmSQ5bljua+99lqa5FEUVWrK0lKLcy6lVKWYhDPXdX3PUyUNPK8s0isb6/1+2+XWriilQMRztVQYkOd57f5gFKYrKyuDbqsskjCcgS4BdK/fSWazn/zoh5vrG0qJlt8OgtZPf/KTwKa/8au//t//g50f/MmP253eX/qNf/sf/fN/2lpe/c/+D3/z7/7f/otrl1a3H+4Pd7eToFxavXLz5s0sHqcksnDZ8vzNzc21lfUsTrbuPbh77843v3QV6xKpgqLSs5GFbJBFnKYYI9vG1OJCyTCaDocHy0vM8VqTeGyoA4yXiESZmuxHSSEOZpHXX6VBv9/d8LobVrBGrA5GNgCaDIfT6VQWsZDZ6PAwTKd5UWRpnhcTrTWoQoq8yBUASCkJBUJJngsjpcJACNFal2WplBjt75Aquw9obaTWUimhjcjz1LKp77uO7bUC4rmGktLoMI72ReFhjIuiULpEyFTOxqcN0Pp50vVfLI7ND8+8fwA64+PLuiHMS8y8CIYzim+otnLEiHDOW353eXmVYJalZRynUkrLspQS+/v70+l0MpkYYypfz+HhAaU0y7IkSaQsLYsVRXFwMFOiuHL5kpTlrVu3hBCbm5vGoPv377/11lvGGIxhMpkkSZKmKWPE8zyl0f3797XWnufdfO2667pxlI7H435/qSxLhAylWEpZLQjbrptLlRU5pWxpaandbhNCdrf33n///Xare/Xq1U7QiaJoMhkrpQgizOJvvvlmmiZaa22k77vjIk7T+N692wxhQlDl72Tb9tXrV8Iw/vGPf0xt7/LVK8vLA5BBnsXxdFRKRZDpLy1du3J5cjiKoxkBc3lj5Xu//O2f/uCPfu/7/+LXf/1X/uRHP/jow1/cfbAFFt16+ND1/L7rTmbTv/ybv/F7f/ATkSWqyL75zbd/9rOfXLr0jSSa2rbNg/4sF9vbO8Pp2HFsIJpx5FhESgQIKBgAQ7XJs5ghwp0AMzSbxvv7Bxi7TmtwGKbEsXLDcmSXmCHiKQuo7ysdEO0XBVFx7tLIZUSjJE3jSTxUZcEwklKHYVwKCdRC2E/iEQKllKIYHMsmnBljyrIcDodCFEVREEEopUqpsiiELMAoWZZCCKlKAE0IYpxSSr/85S/bDvd9z/ddx7Usi1FKCWFZmkkB1Xs2xlRxHl/Aglzj+3eSU7yAztrb5Ny8YhZy1wvwfh4b6E+dND1XfEOVphE9+uvoaFkWIazf63c7/SRJk2RSloJTtj/cppQKIYQQnHPfd7vdrmXz9fX1MAyTJFFKcM4JIYQQMOry5UuTySTLkqWlpSqLg2XxL3/5y+PJYRWrRSm2bbsauwkhIpfVZF8IMRqN9vb20iTP87zaa6yK1YqipCiKbrfrt1pI6aWlJaX0w4cPq5Nra2uXL1/+xfsfEkLyPJ9Op67r9nq9OIxns6kQZZYnFJPh/u73k5ARvLm2rLQIJ9PXbtxstVof3vpoa2treXl5ZWWt1fIBk/HhcDLcI9RYjOkypxh7XhCGk8O93SwK33zjNVSWH/38pzeuXb95ZeNgu4yS8I2bN+5u3ZvMJrvDgzff/mqH8//5b/07bm/ld/7p93/9O9/4+//dP0miOMuT1eW+IRSYSxCepWU0Pjzc2w5868brb3sODzzbcUiaapnnSCU2MQG3QQqQGmnl2q7yQWkapnlqolZ3uSRuXiBZytIwQj1NGdFKCVRmJs7G6d6IeLtOJyiEmM4mxEhOqM2tstRpIhyn7Vm+NmWaJWURlWVpWVa322WEJkkynkyyJEyTJM9zgwAhJKVUSoHRSCuEDSGo5fmtlt/rd7vdruvarZaPSRVRDMdGeaMRJfy46WKMK4exyn1rfuuswZkP9LW7dc1AhtpOkc/jxYT+s//kP3nGghblvll7jaFmOXOvX9DcYnEDer33edJ56ck/qt2a4ER8Q/3vVSXe+mRNqNqzu9vulWXZanU67UGWZKPRJAqTLMsoBotTKWUcx1pry7IAIMtSy7Imk1F10hiDsKlShO4+fIBATyaTw8ND3/evXbvmeW4cx0mS2A73PK9yBlVKVEG5UZx3+r2iKB48eGA0XL58udPp5HleDfpRFOV5bttuu93GGOeFiJKs1ekwxvI859QaDAaO40gpe+2eECLPc8uyMJB79+5FUbSxsRHGM993Xdsp8/Te3dvrayv9VivN4kG3t7+/l6YpACRJmhZ5lQwHIxqGodJifX1tc2MNGU0wrPS7DOsPfvbT1UE3C6e79+9yAi7lb7/1+spK/+fv/8zzvMFgkKbxH/zxH/lB92vf+tbbX/92b/3K9/7i//CX/9xfWr362n/3T/75nYe719/4SlwSTG3X5gRkmYyxSK+stt68vPSly4NLXdYiWX54Nx8/5CZxiNJaWm47jDNuOUG7T6hjqKuxk0qqeJBJPi0g0QycjhV0BbAyKyb7I87cEiASUlKKbBan0Wg0NFoMuj3f86IwTSLZ7q+2O0tFkdz+4AdSpkIISqnruoDRdDo9HI0oIaUQUkppqvA0wzm3LNbyXcex2u12t9tttQPHcSilGENRZAg/WqQyGo4CSggCgjGtZHwlACon47kCoGb/PWsBUHMD+WprhBquK7U3qH8+AfB/+Zt/8xkLagTAc953oQLgsWuO/zj1X2vWBz2WmhEbAMCgTafTW1pa0Qr2dvZms0grKMqs324JIabT6Ww2I4S02y3GWFFkSZJMp1OtdbsTOI5TliUhxPMcm5Lbt2/neX716tVWqzUej8uyaLfbjDHLshgn1ZpwZVyyHceynEk429vbi6Io8FuVuX88HkdR8vbbb29sbAyHw62thwCwsrLS6y8RZt29f39/f9/3/fXVDcuyoiiazWbRNPrud79r2/ZPfvKTcBptbm76vh9FMw3KdW2CcScIDva3N9ZXk9l0e/uhRRnnvN/vM9sajyez2ayKfbu8sRGFYZ6nvu9Tzh7cv7e785Bis9QJrl9au7qxko4Pk9GBy/BkuP9g6976lY1r167lSUwpjaZTz/P+9e//G2Fwd2ll8+abP7t17x/93o/+Z/+Lf9cfrPz0/Vv/8P/7LwarbyhgDGmHm7ZL15a81zb7V5eDr722UU4fFqMtiEc2pA4IEElRFIPVjd2DUSmVF3RarSW/uwLMm2YqkTzXLEe2tlpud81q9xSQPM0O7t0FbcJSDMM0kSAJlqCLIpeiaPmeZbHZLJqFqee3vaCb5cnHH73r2syyrEr+VfFxQlVLvpgxxm2LUspsKwiCIPAGvS4hiFKOMQBgrWX1K8ZIlUsKE9AKtJFGIwDQGiqbT2X/OdYA5rbbRgA8lUYAfNb1L4sAmGcC+txZTj85X1n/kQEAnGXZjRuvrSwtP3yw88EHHyJEOu2eAbX7YItSUikcnHPOeVmWcRwyxuIk1Fp3u912u62UmM1mcRwzBJzzytTrui5jbDKZ7O7uDgb9yuZT+ZJWi4p5WWCM0yJ3HGdpaYkSlqYpIaTb7d6//6ByRLFtezBYbrVaaZoejiYHhxPGrGrr4CRJdnd3RwfDsiwvXbq8tbU16PW/+93v9vv92WxmM76yvrazt42QYZRg0LPJ2HPtjZXlfr939+5dQFqUKkkSxvj6pQ2M6PbDLZuYNAqH44kxptvrcYtqKTmFrY9vtTie7G1/48uvrXT8w4f3L6+tYAy3Hz6wbbvXaf/kBz+8tnkpTzNjDKG2QuSf/Ivvf+8v/hUStP/eP/hvf+nX/ryizG2vv/eLvTiToHLPRoOOtbHsv3Zl6fpap++Yw4cfxXtbls48rCBPdJEaY/xOfxLFQirKXdvxO4M17naTEqjfTSSOS5xpbrhjmCs0lEXqk1KU+SgSu9NsGIpMEsI9y7IoxVk6VTorZB4loUaauzYCsr213fbarutWTQszalkWpZQxhgi2bbvK50EYtW3bsqyyzI2p7PkKIUIIopQSQrKswBgTQirPTClLraGKLKkyzSml4FHWuXlRUbA4AbCo8acRAM9940YAVHwuAXBSDJyZAMAA2LKs5aVVZOCDDz7c3d1fWVnpdQdxOD0c7jNGjyIAAJQSWZZleWLb1U5VMs9ThJDjOJZlYQOtwBNCVLstVgJDSpnn+WDQL8syiqLxeFzlh8CYIIIGK8uVXagoijwrAI4mjK+//mZZllmWRVFSufYDALectY3LluVkWVZtLh8EgWvZUsqPPrrd6/W+9Mabg8EgiiKlFDYwno2/+s7bD3ceOhZvB97ayur+3g4GDVpPJhPKsG25aZ7t7e2nec65zZBxsdaqHI+nQskr165tXFoTeRZODls2H+09hCyS8WStE3gMZ+Ho5s2b3qD/8d07LrMcRnfu3XcYT5Kk1+0jzn/4s/eXr17783/1r/83//D/s3Lt2ne/9+f+i//nf9XpXFUSHBt3WxYjJcPFldXWzStL4cGDcP+hiMcuKJUm8XiINbTbbYmxxoQxSxuQCvmtntvqlBJNU5FKM81UUmoBjNo+sWxGzKCNMMYS+bMS743VcJZLYzHb9mz7zt0P4nTEHVLIJC4i6jDf6ww6GxRxRCghyHE8z3OoZQNozm2lBCBCGUZAijLLC1EZ7ipBXqUO1FpXmlOVSqiKF6nG9+oaKWXlSFpFF1atqNIGTm+djQB4KgsTAIu6wTzOWpDMvf6LUiEfG6DnP+/Z1qfu9fgo7J4QQjBU7n1SKbW2vI4x2d3dnUwmg+6AMTadTosiQ2Bcm1cqPGNMKVEFASmltrcf+L6/tr6SJMlsNrMsi3MuSyGEqPLDVOcdx1leXn40mkdFUViWFQQBY5YyUmrtt4I8z4UQrVZHSlnllhClklIOBoPLl68WRXHr1q3JZOK6vjK40+4NBoPZbGaU6nQ6ZVlqrWVZbG5u3r979969e57nvfnmm5PJJGi3o3jmeM7K0qDbDtI4mYwPfddeW1vd392zbfve1hbn/Hu/9uc+vH1rOBzZFGQ0Flk8GAxmUTiLZzdu3PBdZ7i37VHcdohlZDYdXV7u3fnFu+O9XUTgne9+ZzgeZWF8aWkpnU57rXYaxXGSxGnG/dafvPteKGVB6K/85m/+1d/6H/+D//fvrPQu/+SHP3EdevnS8ualXqdlZdGw5WCGxcO7H5OycCgZ7x+UaebbjtHAg6BUmjFWRclRixNqpXmZZmJ3OPTaPQmEMDvN5cramlKl4yCgxO2sSdL+6P7k7s4oFxgwjZJQ6bwUsTS57bPOoNvqtbgdcNpFwAERjKEKVtIIA2gpNYA26JPAIgO42jfm8SZlqjG9aodPDuv1YjnP2g20bn+pKwAQQJ3AtDMXANV6zDm4gTZuWBeTozzPlABAWZZlKRlj7Vb3ypWr3//+95MkWV5eTuJEKeV5HgKdhKFipLIhUEqFwMYYraWUotNtVYmdi6JYXl5utVphGA73DzqdDmMsyzLLsm7cuKGUmkwmRVEghCzLchyHUl557KRZFibxsgHOOUKkLMuykEoaRoltM9f1pZTvvvsuxrTfX1pfv5RnhdBmb/cgz/N2u+37PgBQStfW1vZ2tieTCef8q1/96jvvvPPgwYOdnZ3XX7+ptFgaDFQpf/KTn4GSly6tO7a3tfXAKD2eTn/+859/95d/9f0PPxgsrRSl9mwcLHX2HtyxOFnudwOPOxRkMkFFOugNPI73H+x0XV7kydWrl5EoXc/+8L33+8v9Kxvr8Xg86LSj6aTf7ty4cumjO3epxa9vLB2myZ2d3Q9/+Iebq11LTr/33b/4Zp//4R9+/ze++StZOqY4mwzvj5PQtRBWMpxMDvMisD3Hayml/VZnFEbUsijnpVRCFtxoUOnhZJxlWcdvpdOdbn+wubkyC+Px4Z0r166leRanWVjspHqcTmNdxAgoJZZFE8YR5x51Ol7gO+0AMa40yQsBgBCqssAKcyJ+0yCAo7BNZRAAqGarrheOahw+BwEwT8V7ivnvheCkYHshhRwyCBAyYJSuzLKe7S/1l3Z3dzc2Nve2dw73D9vtdhAEo8OD/f29fretlABgj3w5pDFKSiWE2N3dZYxtbKwTQsIw3NnZBoBOp12WhVIyCAJKWRiGlUKgNWCMtDZSSqMJtqjFHcqsm2+86QeB1jpNUyFEDKmUWkpNCArDWEqptSEY51lR5KUQSiljM9vhThZnZZ5zzuMwGu4fIKPeeuutmHPLsm59+MH9+/f/8l/+yx989GG1H9l0Oo3j+OrmpXfeeUcW5Y9/fIgQKnLx9a99M8/LX3zw47/61//a7t7BV968QXVqMeo5FhgxG07u729xYjq++6M//L03bl7zOOp1Ap3nRpig3V5eXpolH2Ghtu/fi6eTzW98A0lvPBmG0eTq5poEJEGwvd00sUU6+fmf/n6R5e//y//+rTdeH7CcpnvJ3kOM5aW+f3e2x6j14S/eF0J1gvY4FZ12rxV0DydTv92j3KIUp0mUJEmRJkqWs9EQgXE7dqljF3soHg44TcsRitu+3U2idBKNQikLBZwKxgi1Csc3rusGrbbXHjhux1A3SuUszgGUwQQQ0o/8yuDT09JqzD/utPiT/A2ncrJ3v6KpNy8U1TiM/q//6X/6jD+4aIPaBTQB1frJhTMBVUZ2iYRQhLBW0Om0OrbtPnjwQCkVTqaMMdu2P/744+lkdOPG9Zbvai0RQkqJypFfSlmUWVEUm5uXWq3W3t7ew4cPKaVVyn6j9OrqalmWH374YRhGg8HAtu3ZbNbrDQCgMhkzanme5zgOpuyDjz7ClBiDGGPtdrvVahFCwKBq9biKFq6MyJZleV5wOBxXc//d3d28SNvtdhxGSZJ8/Z2v/PSnP/3KV74ShiFoNRgMDg8PZ1H4q7/6q0me5UnKGO132oyT3YfbH398a3PzSpQmrVaLMuvHP/lZIeU3vv6tw737r691du99EPh2p+Vx0J5NHE6Wuu07H76fzCZpHIaT8Y3LV4ssAwAlyn67Hfj2cG+/23IdzrHRW/fvdjod33dbnXYu1a27d4bhBChLilwWZTqZfOtr70wm40631eu1Pr5z6y/8hd84PNgTQty6dUsL02q187wEgzudHsLU8oKylMYoJcsiiznHgWdrLXce3rMtbjNuWSwOk0ub6zZ3prHorby5M0nvHRzGRpHA1Q5TxGCLua7LuG3ZAbPbmHYKyUazYjSLEcEaaYxpla/GIA0Ga1CgkUEaAGv0qQwzZK7j+mKG+8YE9HTqj1dNJPBC+WLiGM8URmghZFmWvU6wtrJKKZtMZlmc7e3t9ft932/d+vCDaBa+9tpr6+trD7fuKFlW7t4IwLE5pW6e83a7XRT5x7duT2fjfq/X7/fDMPz49ke//G/96v3796MosizLtsXHH38cBO3XX39dlKpyIyGEIEQAoCjKPIovX70mlFJKCyEKIWdRTAiRUrdarf7yyipjShpCiG3bVeLPIBBxnFRbC3BqWczmPba2thbH8Te/+U3QKppNqzRzH9368H/wF/+S1iBK5ThOu93K4uQXv7gTh6HvtzDlG+u9w8PxP/yH/+2v/Nr3kiy7c+fet7/+5eHddymlNuPxbJqHhxxJh0I56Iz37/c7ndevvDE6HCtldvb2KeEMQSsIsunYxnRtZTWLIq1lf2lg2/z2x7dXVlaCTmAz6Hu2IdTFpr2xzNDl27c/yrIszYJrl/+t3YfbH/z8F4Neb297/8/9+d/cvnv/zp07ly9fHo+nh8PdX/veb0RZcTgcCylt26ZYAZK2zV23NT7cLYus5blSla5nx3HYWW93uVsUOSHEdjhhtHNpHXt2Zkpicdt1pEalQFmhyiwppZ2WoDQBZAAjU+UOQGAQGGM0AoKwRgCmihKpBvfKPDRvADpVs2+UgAtBjf0AFqUBLCr/9VlHAn8eDeBZvPIvmgZgpFJYVf55juNwbmVZMTwYhbOYM3s6nU6n006nc+3aNW3knTt3jMiFLBzH4ZwXRYYxpZTmef7xx7cJIZTh9fV1Y8y9e/e01teuXfvggw+qXAJRFNm289ZbbzFmJUnie63KFSTPc62hys6fZoUwh9yx2+0uQiTLUiGU7/sIyMH+YRyl/f5St9tFCEVRFIZRWZZIm6IolJJRFHU7HcuyptPx3t7ejWtX+v3+f/Vf/r3Lly97nlcUxW/8xm+UZTmZPBxNZlqWQeDZjAPgTrvnB26SJL//+39g2c5/9L/9j+/c2/rx/+9f/pW/8lfuP3iIirxt251OCyQhLdayEDXFoB1c6vtZlmw/vGdbvtbmm7/0nTjJQYo8nm1vPRgMBocHw5bvTWeHvu9mWdrrdw5He7vDbc6pY9t5nhFZOKjVXuqNZoNib08Z2BsednqDw+HYd4MwTKDU1XpJv99fXV22GNnZvt/trRJkDEKUYW2IkiovC21KINgL/EJLo8xrr127/eFHH318++YbX51MI2K1Wm1P2fbS8oq2HVIU3LFLpbTRhZSztMiFVgik4dgiAIAQIIQMqnZpxmAMroJDEAEE6Chy8OiozSMr0DO1Q1N7E/ZaV9endn9/LqebGvc94/GhGocv0BrAi87J0f8pXpgXliMjDONB0HZdN4qiyWQWRZExJk3TyXh89erld9756u7u7vu/+NB1nWuXN8Jw6jiO1mo6nWZZZoweDofV7u1hNP3444+DIOh2u3me7u3tISBxHHPONzc3W612WZZS6m63i4AkSTKZzOI4xphWjvy2bTNEFBgwmDHm2LpyPE/TvNvtD4fDg4OR67qcc621Y3vdXns2ngRBYHPLYhZlRCkVz8KD3b311eW///f//ltvvfX222/f37o3HA7LW8WVq9fiKNVaG42KQtiMu66bZdnO3oHneW+//ZX+YPA7v/M7H9+9/5f/yl+9cuWqSGdf/tK3Z/t38mTGdLHU9X2m9h9sh/tbl1aXW67rXbtKuLv1YC9JszAtocyz7b215ZX19fUonoRJPA1DatFOv9fuB/nH6Xj7Qbvd5q6NOeWgR8ODSZbdfOstu9UZ7u3fuvfAsVuA7dks58z9yU9+ppRwbXu4v9fynV63dev2rSTJilwAQJYCJtr3PcpwHIeIECfw8zwnnBQGrFZ7PJrujYbYDfw+hZLnyCbMKyTPMzAkGE1nQFipSKlMqaTEucFKE0wRR9UYjREAHIVsoU8mcJ8a7JEhVdjgp9vUiQs+LRvqZPxvOAuO1gD+7t/6W0+kkDz9iBB+xiufr5zKl/3zlzPneOZrABgf1ccYfXx8Sj3P3O0VoU/lUHxqD8QGKSmxIb7f6vf7nNjj0eTwcJxl2Ucf3W75wcbGBmNkFk5s23ZdJ5pNLI7H46FtO8bo3d09hMDzvMlk0u12Cam20wpc171z5877v3ivKIqrV66vbaz3Ol2DAAO2HFtJE0URISwMw+FwlCSJY3tLS0udTodw3uuv7O7vS6k5p5TyTqeDENrZ3QNjuGXFcTwajbrd/ptvvhkEQTidHQz3ZuNJt9v1PC9N4uFwmKbx5uZmp9PJ83RzY2M0GhZFEccxIWQaxnkpNi9duXbtWuC7WZyMxsMoipSQly9fDsMwL4vZbPbtX/ruLI5Go8mV9V56cLvt6K5rhQfbw4e3k8lu28LfeufLvm1Np1PC+GgcO0G3kJg73mR/X472X7u6sbe3A8h0Oq1+v7v14J5lcdemZZmPDg8wxoxgy7I8x32wv9feuPzW17/+4O69e3fupXEy3N9v+T7DxLasdjuwLaZEVhS5lKXjWu1W17E7xqA0TXcPdssy7/bbWomtrXuXNtd930MIcdsOo+T6zdezrPx468GVN77cXtuYZSYsMGuvT1K9P839dnfnYMhtG3NaCJHJXBqQyGiFOLIAMBhkMGCDFOiqhxJCAYxBn7RkDQiDwdqcZu3RR+32yQ08jlrgs2axRwYD0nBmRwSk1vWmZhZ+NMft9bzWAI4+y3/+t//WWW47UGsDhNrlGKMAcHVEyBwfT98AoSbzBMbTXnSdhjVPRZgbCFPrAxtsEFQ9EwAA9HEPVELato0QKYoCG2xZFkZElgorggxeW1uzLGtnZydJkiiKP/7441Yr2FzfQAgRQqJ4JoQIgmB7+0GZxUvLvXa7G8fhwcHh6urq9s5OEASHh6Pr168nWTqZTAghW1tbWZZ985vfZIwKLYq0MBh1grYyZjgcjcfjg+Go3+8TwvI8b3f7169fp5QdHBwaTShnRV4CMoHf0lpLKb2gZZSmnNm2jRCKwmQ2mxljLJv12q1+v6e13tvbK7M8CAKEULUH/Ttf+8oPfvCDX/qlb47H4/39/ddee+1P/uyHV6/fWFpZ1loPuoN79+5tXrrk+/6/+b1/ff3qNUJx4DqDfndn+wHGaH9/H4nI0rPXr6wsdbzhw/vT/fvrvWC12yrjyWR0cOnSuhDKsr04E2GUrW1cNqqkunhw+8PpdNoKgm67xTgpk2w6m6wtr+R5WpTZyspKtRPy4eHh4XSyevlyp99jjG1vb4+Hh7Ztv/vuu6/fvJEkiW3bX377Sz/7yU/ffvutOInu3btHMB20l7rdPmF0Nps9fLhVFJnnWmk8tTi5fOWSMeby21/50Z/8cBxl3/nVX8+QjduDRNFEQFyqRJBM0wJxDTQtS4mQ0lqBqfbkqKK7CbAqFNwgjQw26DP6Iz69w8x17XvU/s9qfLh44xjMi/08lTNPZWEMQgj953/7WQPBFsWiHmxeBOz8X9S0OdYVAHM2KVvUTL9WOQYAgGioHkNjU1VPA4CWijGr8t1EGiHAANgoELG4dvkqAMRxDGAODg62t7cZY2vrKwAwnU5brRbGMBqNACBL424ncC0+nk0PDg5u3rwZRRHC1Ybh7N133x0sL7mu++Mf/dT3/W9961sGlOXa29vbrVYLAH7203eFECtr62mS95eXRqMJpXRpsFJKsb9/4DjO1SvXt7Z2LG5XewgfHh5ijDu9PiFkNpshhIBgABClUkq5rtsOvHbgZ2kynU6VUr1er9PphGG4s7Ozuro6Ho/7/e5sNrNte3l52RgEGBWiZJYVx8lsFvXb/ddff/3hgwfr6+tEw8e3P7AYNbpcX1su8/T3f+/7v/ztr9x+70/+7V/9JZuYZDq8ubFsQbl99zYSaeDZNqOO47333nuZUFev3Tg4nMbh9J2331QiE1meZVmZpVpIi/GW78uyHAwGWw/u5Xk+WFqK4/j23TudXlco1Rv0q2557doVz/N+93d/t9/vv/7GzR/+8Ic3btzodDoffvgL3/cvX768t7PPgAZBOwjaGtTOzs5oeECJAlViEEHLw5QubWz6vdU/e/d9SZxf/ot/PafBw1H8YP8wKzXYHjA3KnWUFYQ7EowxSIGq2gkGQxACjWoYalA1068T6bqovcHPiefzujnL8utRtbQX2wsInU0e/C+GeTP9s148wJgqpQgQTqhGIEppjCaIrq+vt9vtarG3LIswDC3LWl5eTpI4CALGSFFkGOOyLCmlKysrRovRdCKl7Ha7o9EEAL789ps//OEP9/b2Mcaj0ejBgwftXvedd95ZXl3d3d29f2/rwYMHVYIgTJnDrW6nvzSgw/Fkfe2S4zhSKkTI9Ws3GWNKmRs3bgwPDqvF4e3dnXa77bfa+/v7URQ5jtPtdrvdLndsQggl3Ob0wdZdTkmn00IIlWW5t7dj2/bNm9ejKEEIaQ2W5XBuVfOAKpVQGIbddndzfRMBAcBawXQ6Pdje/crbb2VJhEDdu3c7mo1/67d+Kxzt/v/Z+88gS7IsTQy7wrV8Wke80JFaVWZVtajuajVqB7s7OytAAgsQZoQRpNFg5F+CRprR8ING0IwGMxJYAOQul4YZLBY7s7s9Pbq7q6u6ZJZIFREZERlaPC38uVb3Xv54WTXVVZU9lT1Z3VXd+Zmb58sX/q7783f93nvO+c53pjLXMWZxEBweHlayai5juONIlWTXnkAGTNM0ES+LkiRwcjEfJyGPkO/7juPoiox5IYniKIoApdM8iSRJpiUQ8plsSqgsimmc8DyPERYFATably9daLVahqY//+xz+/u7iiSSJI2CsHVyaqgGZAgAijEUBdk0Td+bJJGvaVr79EDV5GZzbnN3f0HNNucWTgaTIIgS1QgSGkZpkFKOoxAzQkhCUggBYAhCwAE0jfriaf0t+gULYj3FY+GRiWCf9TD6xC2AT934k2ENPdoCeLyV++OugB4vyWDqoIXTlxDCaUACAgAwx03VVzhOQBAAkCKEJFGqVquj/pBSKknSyckxhLBQKERR5Pt+tVpljPR6PVmWDcNgjHE83+/2KU3jOM5kMvv7h3Nzc3t7e++++y5C+Nr1ZyzLStP0y1/5iq7rd+/enUwmJycn+XyeMUgpuHD+0ng8brU6mqbVazNBELquhzGPMJckxHX9JElkSYMQZrNZWZaL5ZIoigAg13WXl5fDMPR9fzgcpoxyHKfImiIJ5XI5jjwI8FRW2rIsz/MopYxBwzDCMMzn847jjsfWNBJw4dIFnM1aY0eRDc9zT05a1XIlTdMz5y9kMoapq3u726P+4OqVi77v/+AHP1isaiMY1koFiReGwzZKvLKpMMbCMMxms67rLs7PpRR2ev1KqRgG3mQ0Fjjc7/fjMCoX8qokD3r9IAh81/U8r1wpQggZABBC0zSH1jiO4zCOc7lcp9NptU++DmGlUun3+ycnJ3PPPqt029PpkzF2+/btSxcuNMp1xmCapmEcUJryPO+7CREwz/OBH/G5nNwZrG1uXXzmS+frC+3R2B7GDuWwrHIJiQhIvSBFnCQpKZ26sz/ov/RhzAzCx3hk4MNv8+m76E9p6W/eyM8BX5Rx8lF4WInhMz3HZw34oRzFD79+iikQe7hNARmCDE2luKbiXIwxjHlJkFVZcRxnNBqOx6M0TSRJkmWZstR2rEqlghAKw3Cq1WMYRhB47c4ppTSfzycJ2ds7yOXzYRR973t/nKbkuS897/t+qVh58Zvfxhi//fbbDx7stlodQZBWVs4sr5wBEJ+etrvdPsR8tT4rSbIgSBBxDCAIMccJmBcQFg6PjyiAYZyMrEkYxsPhuNvtqqpq2/aU7E8I4RHWZEVXZUWRLGtkWSPHnURxQGjCAJmqFkMI2+22LCu9Xj8MYtfx+71hHMe3bt1ihI7H47W1tSRJHMcdjsfFYmlxcbFSqZ0ct0RBfvbZZ3O53Ob6hizycRhUS2UEQBwFzZm6psiu6zYaDYHDerlYyGWiwPMmIx4ylkZHB/v9bi9JElEUIYTj8bjT6XieJwiC67qlUokx5nneTKOhqWqvN62h5kFGfNe2RgPPdjbXN0b9wWy9Efru/huvZU3T1HUEmCwKpq5N4ys8jyFkvutBBlRVjuNwMhnPzy86vne0sTXTnJNkPaZQypYE2ejZvhORBHApFMKEBgklDHG8yOhPLKQQAICyaUlaAOmn3Z7iC4hPdgF94Wa2jzT46PY/XxbA4+ZDPP59mx5PAYAf2ALvn4KDAJKUTgdcURQ5TvA8j+f53d1dz/Oq1SpCyA/cSqUShqFljaIowhgHQTCZTPr9vmFqsiyPx+NKpRIEAQBge3tbUZRnnnmGUup5nm5mbdu+f//+yclJNptXVfVLz3/l4ODg+GQXY75Wqz//3NxoYr377i1BEBr12VqtkaY0DEPAIMIcSb3FxWWe59vttm3bsixDCBFCuVyO5/mpSuh0DiOEBEEwsYaURFPOSRj6YRhTSgEGSZLs7OzFcSzLCqW0Xpu5efPm0tJSu93uD3thEF27fiPwI1EU6/W674VBEGxtbJ5ZXYKANupVZzzYXLtXyGaq2XPB+MgaD0ESCSD2ecCDGIRR+7Q1WysPD/ZFUZxYliTKjVrl9KRdL5WiNDJNUxZFkRcAI2mciDyvqmq9XhdFkQEiCAJjTNd1QimlNDMzq2hqv9vLZrPzzbmdvQfHRwfPf+lLqqzcW197/tnncrlcFARBFGbNDM/zjKYYC5LAuRyUJInHjCQpRQRy2DCzdzfuP5MtzswtilrGsb0IcFjS/BR7YRwnlEAOcBxDOKHkA7YJBAAxygADDzX6+cfrbU/osf6iLOO+cOPkJ+ILHAP4IADwqYPAny/8PPMhPhzQZinjEQYApikBAGIOQYjThGIAwjC0bTuKIgaIIAqUSbIsb23dny72GSODQY8xhjE2DMNzHMuyzEyuUCweHh45jnv56hXN0NfubZTLZdd1j46OCAWzzfl8Pm8Ymf3DI1lRL126wiiwHHt7d8/3fQiwIMq264mSquv6aGzt7R1ACCvlWr5YtiwrkyssLK0YpkYpDVzP9/1pEJimyTQaYZpmLpMRpaIsccNhbzQah2GoqrqmaYP+6P79+4zBSqUyHA5XV84mCfH9kOMEQsjMzMxoNOIxh1WuPxioqjbXbIoi32u1X3npRzeuXV678w5LAlUUDvd3ZC69tFJzx6fFnFkv5XgaS5hwadg7PYSMjEYjVVYEjpclMQkDRqJ8LhtEIWVMFMVKpQIBZXEKGeMxZ1Zro9GIAairWrvd1nW9Ui47rpvJGpZt8xibukGSaDgYIAb293YyupExTNeeiLKcy2Q6vR6PsSJJaZqkaSpIPAcBj2BI0ySN8vmsNZkUSsVJlLZ7o/Nz50Qj27KC3tiJoRoylDKcIgQQhlgggDHCEMIQAgQggBQxABh73HDlU3xB8YUPAn+h8Yuaq6befwhhmjAGIISYURilEUvS/f19jHG9Xp8quYuiuLe3M51lMYZBECRJUqvVprL+47FVq1W3t7cxxnEcz841oyh6++23z6yegxwOgsAwjEw2n8/np4pvHE5VRdu8v3V4eKiZGUKIphovvPD123fvNOozlIK33n7Htu2V5TOzs7MUgmnOcD6f1zSt2+kHoSdyvGVZU/EJguC0LEwQBBBC7CHPHRmGns/n4zgGAMmyvLCQmZ2dZQzGcYwxZ5rmq6++vrq6uru7u7g4f3h8UKlUdnd3DSOj60ar1a5XG7Iord+798yVC6Hv2KPBd7751Tde+aHKw3LOvL92S6DR2tvHmCSrC7OmImg8XZhteJ63fP6CP+hFUTTs9cfjsSCI6xsbFECMcalQLOYLNI2jIMQQIgCL+Xy1Wt3c2pheOUKo3+/Pzs6mcXKwt9eo1WUZ7u3sSrxw4/q1dqczHAwkXvBdT1GU0A8USZKqtXa7DSgLAp/nuTiJMMau6yZJksvlKCUA4ZWz55wUC4oWJCwBXEhh3/GYpGNFkRmMCY0JnWrvI4QgBAgyxBAAjAHIKAQM/Mz86af4AoH7m69DpwPEtAoEeL/yw08p7PC4+CkD5RNZ9T8y6Pq41/Mkgrcf/+Anykt8mvbhw3Uc/GA/DQYwABCASZrGcawpZs7MU8pG/cGD7S1dlWvZiiiK4/F4d3c3jkNZlk3TBIAmSWIYBuZgkkaO69i2bepGHCeyrLiuW6qUKaX2xDWzeT1jEkIIYbwg6bpJCOt2O+PxWFL07d29Xq+nqiolADCUKxTHE6tSrg6H4zv37tZrM1974UUCoOu6p6eni4uLRiY7nthhHKmyomumoSlLS0u2bQ2Hw/545Pu+LIkQsMD3wtDneOT7QbFYsSwriiLGWLvd5jhuPJ4MBoNnn32u22uHod9unyqKks1mB6N+t9t13X2OEy5fuTY7O0Np+ubrr6Vx+Hf/zm//f/7r/3LYO+FIePXCyps/PkUpu3p2ZdA9yqq4lDEqOaNgqoYq8hyMrPHbP/7xwtxsvjmX7OxVq9VSpWJkMxBxZjYji1Kv083kMuv31s6dOQMoE3l+/d49VZUVRQnDcGqcWZZ1cLCn62roe71BnxF6+dKFSqlcrddf+eEPRVnKVasIQFWRBkc9kqaAEdezFUUBgJIktqO4kMsqipKm6cgaLZcrommmMYRGXlayp2/dSbHKyThgIA4jhHmOE0QOxAlJkgRDxABggBIAIKDTFMVpSPexxMseF78oF8ovin76OWwfQgj/7/+n/+yJnPvDp3+YNP656yiP51v/ReUBfORTP/ME8JOg4OEEgGjKBEEEDDEGVclQFNXzgkG3E4UBj+E0OOk4TpI8LMLFcYjn+WnoGEA6dfF7nmfqxrQAIM/zYRwNh0NOkGZmZgghURTFCeF5Pk1pr9dLkqRYLI+siev6hmGoqjoaWo1GY6Y59/bbbxfyZcThem0mCAI3CC3Lsm372rVru/t7UwqQ7/u+63Acp6uyKIqUpoQQDmEGKElSURR5np+mVk1rFM/NzfGcuLe3RwixbRsA9Du/8zv9fn8ysYMgOD09VVX19PQU8xhCiCAmhKWEfesb366Uy//y93/v3/37v+NZvcgeTHqnCk6unF+tFDPrt2/WK5lR/2SmWq2VC93j/cizZ+tV01Aje8JDiHgMMAZxGvg+REjStGkcYu3uPQ4hSeBJkmiKOn/5ytHtWwghUeQJIYIscRzX6XVde8IYW1lZevmll6IkuXr5Yq5YyJQrk1438v3BeKSIkiBL1XJxMB5hANM0ni6zjGzOD4LRaIQ5OJmMG42GZVtAkObPXYVabkyESDBOrchlXMtJIoApARhjLIgY42mZXwS5h86fhxMAmCrAPSoT9YviZf38TQCfafOPr/31pPIAPvHEX5Re8vnEE8xsQB/q7ZAhAMD0yUcM8LyIEAqCwLZt3w95DlFKbNuyLAshZJqmIAhxHE65N4oqMcCmRoUkSRzHRVGkKArHcePx2Brbsqwa2UwQBNbEyeVymKadTi+II57n9YyJeR5jPJWArlarjZnmaDQ6Pj7OZDKu75mm6Xne4cmxphkrKyv9fr/f77/w1a+1uh1KyfzioiQIrdbJcNCLosgwNJKkmqpwHBe4niBygiDYgNZqtTRNd3d3Az9CqtBszhuG0e/3IYStViuKouFwIElSNps5ODgQRa4/HKyurqaUmUZmPLQOj3aHvdZzN6426+X/5t/83rWzCyvNsikBDccwHK80y81GcZc4hsRhEqVhYKiKochWv29qKjQM9/i41WrNNptyreaenN67ezdJaZIkYRDMzc4CSgq5XOvkdLS3ByHM5XKOM0nTVEIIAGBoehKFjWpt0Os5k2DlzFxzZtZ2nXA4SMIwn8shhJI4TOIw8HxFlHiMoghFUeSFLokjwEgUB/3TfqVSkhQpw+W9hGBewNk859KeGwcpYKIMIIUAQkQBpJASCAEGDCLIGAXTMu1/teiZLpWecnt+mfEwD+CJjNQf5+F8Li2Ax3PRfE5cQH9tC3/NXz/0LwQQAMDzYhjEhBCEWBTFcZwGfsQYC8MoiQLXdRljsizLsgwhSxI4ze7FGDPGkiSZuvtEUZy6+KZx4zAMc8UCxnhvb48yKAhCkpAgCBRdmwoeDAfDfL6QzebjOJYkiTI4HA4hxMvLy0EYEcL2Dg+KxSLG/NraWqFQ4AR+ffN+qVTCWNrb28MQFgqFem1mMOyJvDCY2L7nIoRIEpmmCSH0fb/d7fO80Gg0LcuilFWrlX6/Py1VPxj0KKVnz652Op1W+2hxqdnpdK5evew4ztr6xvz8Yilf2tt94Nv2tUvn//f/6f/6heeu/vv/6Hciq9s93BRYwKfh4lJ94857jXIxOztDh32ahCmik/Gw0zodYCQLYrlUWjl3zhoOh+sbCKFsJp8r5DudTqVUnozHg15XkSQO4du3b1+/djVJkjiODcNIotgN/Gw2q8mKrimv/nj90qXVc+fOBUGAALRte2pvmYbBmDoej23b5nk+YMRxnEzWEDjeD1zGWMYwT0+PGaMYY0nCmXI+TIkQhLnawuBk1G+fiBkZCzxHGSGQMUZZygiBDFAGMUIfdJOPPMY/Q3/7/OBxr/NX0AIAT4QF9Ik6+L8E4vi/WPzNjYD31/4fW8dRhgAEGCGEIGUkTmiaAgAwxl4cEkKmg7tt20kSUUqLpfz0nSAICEmn0R2EsCzLJ8etKIoEQUKmEIZhGMYMoDiOjo+PGcKZTKZUrCRx0usOXNctlsuCxCuq2ul2Dw+Pc7ncTHPu8OiIpHR5eZkANhgM/CAyTVM3tYODozBOuv0eApAxlsuYpmmaulapVOzhkBASRyGlFDKiKAqgRFGUMCbW2Db0QFMNhNBoNLYsq1KpxHGYzWZ1Xe/22u1Oa36+mclkKE1H48FwZK2srMzPL0qCSNIEs+rBznajVuid7v/+P//vzjVLqdu/dnZBgMk7L/1ZGIYSi44e3N/cWPccu5jP5rM5TZXPXL4MTBMw4J+c+H5gZvOaYZAk6fZ7siwDADzPE0VRkiRkgOvXr/uuE4dRJmMYMzPjw0MMoCzLJ657enpaKRXOX7gAEHImVqFQ4BAcjUa8pqZRCADIZ7Ke79i27bouAJSoEkLQcR0AQH1mtjwsAsZoSnhFFg0dAjGIqW97XpRATrH9AAkiBPQDwcJplheCDx0+76/6EZhygOBja9c8kSywp/h5AkL4xCyAjyvgP7UA/prjPwU+zTTw110//NA7EAAQxzHGvCjKPCenEWEMkpQRwkQMp+T6aSat7/sQMlmWp6Vapryg6ap/OrsfH52GYUgISZIEYAQhBBAjhCilPM/HhIzHY8CQLMuqqk6F+AEAnU6n1WqpqlooFNI09TxvaXH51q1bZi6fyWQKRZHn+ePjY1lVy1Xzwc6eJPLPPvtsvVo5PT09ODhQNTkO41wuxyjxPIckSRzHnudJirqyuJJScHx8LIqyJClpGl+6dDkIfJ7Ho9EoSaOXXvrB6urq9evP3Lx5s1Aq9Aa95tzMwvySLKscwqHvVXLmXDlzuL1mtw/3t9YvzZr9zvG/WXuNS3zbssIYGIYEaJrNZq9evDCZjB9sbwqCMBmNOI5bX7/PEPj7v/sPtbk5Z/9wNBoFkX/m7NnO8YmqqjLP2dZk/d7at178hjMeT3m0IE6iKNJ1ned5SqllWcvLy712GyGk6/p4PIYQapomF4udnZ0wDOfOnTNlwbIs3/crlVIQBEka+X4IMSJJXKlUbNvyfb+czwEGhHpVwOZb93YGMV+uLxx1B3EcM0ghxAhQhDgIAQaQIUwpBeyDpN8Pes0j04CfVJ7NZ42nFsCnwZOJAXyiJMNTC+BviCcYCfjw5xljgiAIgpQmJAiCKIqm4UTXdQVRUFU1SRLXtRECkiRrmjYNFU69FlPPXhzHURSN7YmmaXGQTiYTRdFkWZ0yizDmM5lcmMTTocowDM3QAQC+H4xGo929B7lc7vKVK61W62j3uFwuBnFYrlUajZnRaDQcDadSE6PRqNfrLy4u1+qVOIpv374dhmEaR+3OacHMZjIGSZM45hVJ8l1nMBgYJrOtKJMvMAY9zwMAYAwHg8H9+xv5fFZRpXv37ly7dvXixYtHxwfZnNnudv7O3/k7x6en7777bpqmtUo1TRJMonJGO3tmqXTt7MHazR/8xZ8KqaVzZKGau3xm7uCkDRGWRSmfzws8ZpQ0G43Z2dl+f9DpdCq1+re+9S251nj5X/+bzfvbX/7K85IkTCzLsixJkgQEoyhaWVnBjUYhiac30BuNpsmA3W7XNE0ShWmcTMaWLMuGpiVRnKbpTLMJKIUAAEYAj0HEeMyJvJA1M1EctjqWpukAwXa73Ww2eR4HYZwkiSAIQM8AwSSM2a6nQsxLcuxNIGQIIIwAhAyAaQnoKVmMAUYBQA9DAQAB9khSw1P80uD9IPDfUEcbYgApI4ABAhiCiEHIwalI8xNR635Mne5P3gPw6KDWo1b0j7xtf8P7/iH89UKyfzOJlfe/8vva65BBDiMBC5DCwPVty47jlDGGIRi7k6pe1nXdsqw4jqdL/iiKVE1O03Q6DRBC0jRxHNdxnGazORxP3Ikty3K5UHR8bzKZKKrKYyGOY5Hnz5w5o0rqcDzutjuyqqiqtrOzE8dxs9kkhIxGI47jpnGFIAju3LnTbDYNwxiPx4VCAY4sI5NXFWU8HA37vTiOi/lcpVTEkEWBrxua7zq6qlbLpcDzOp2Oppqqnjk6OlFFwfMcK3AhAt1u2zA0XREoSb794ouGYezv7zue22g0zq6cm0zswWCQy2Trtdrxwf5cvT5bKQyO91RETne2ZRTPr8595yuX+dSFxOUYPHtmZXdnfzKZpIHnT2KJw5zAdzodxli1Wj1z/hyA9I//+//f4eHJl770/MWvfBn4/rjXPnPxYuy4vu8HYXz++a+ONrdy5QodD23HDcKgWMyP7cmDB1ury4sM8cNRb3ll5fT0pNU+mVtaskcjAKndbiuKoijStKolQFBWFYi5bK02GPQatUpK6cbGhnDpUlFVjlut/tiuL2RAygCgpWpzf3JwetpGkoIQN2X9o/e52oRCACjGPIUAMUDhB76gp+oOTxxPRijpiYN7SAKGP/ueshQAChF6//sxBgijFMBpTwIf2UMEH+8sgH5iOwg+Vjs/hdb2iPcfacA8ikaGH/H+o354CgD7+PZhPu37Xx8AAPCjsnIecZ0UUlVVPdvxvMDUMxzHe7aPGJqdnbEtJw7CwHHt0dA0TYEX9g72BJHzfTcM/anAcpqm02ECAuzYk/39fYRQsVgcjceO7c02G2EYnh4fChxfLReTKAo911AVRVcjP1JUpVQqhVEki4KhKVlTd7ygdXJaLlayuVzrtJP1k2K+pGjqaDTyXNfUddPMBEGgKMqZ1WXX9wAAg04XRjRJo4yhAxX4rstj6Lp2tVzpd3scAqEfHLgHhq6bqokQjByHo6mpKOVcudM6FkRu9cYFz/NG48GZ1XMHR8eDkxMGOQmK771xS9a1bLFQr8yai8re9tZ8uSokkXNyPD7YHXqDmby0OlddamQkFpB0Yg1aztgSeWPS7Waz2ZgQRKGsyuOJE8ZRvli+e3dtMOgjhArZzELz+WZjJmodi6aJGNtev7eyesGxg5nGArB9QTDSgMqNRX9nK180EAcPD/czGUNRRGdkxZFLY4/nQBIno+7p2LKNSknVFUKIPXF1CiRFYxBzgpQQwtl2qZgPfc/I5eqNKglcLClGoeQS5E1CtaIBTvPiEQCi5wYwBbquUkAppSkhlFIIOcxjjDElDADG0JTjRaeEbggB+yu/0KfEZyt3/LPmwXwUfzVQfaT9J3TeRwACxqbJFR/kS4H3uZif/IlHXOcjT/CYHpfpVcD/x//l//BYH/ub40n52tBjzqiPy2t+/Apin6yd8oj26Yf2n+p6EHssfx0FGCVJhAGvKBqgYDyaSFhsNGa77b4kSZ5lR1HEc1y73R4PBpl8RpQFCshwOBQEYW5uLgzDwWCgqqplWd1ul+d5WZYdxxEEQdd13/f7vQ7HcdMKXGEYx3GMOY7jOM8LNE3Ll4oQwtZpR5ZlVdeCIPLDqFyuBmFICLEsu1gsDkbD0WhUqzVKpZIoK1MlasYYJ/CAQt8OPcdbXl5KSSwrSjZnbm9vCoJQyOeq1eq43xsNhnEQKrJczBf6na6mabqu65oEKAkCh5IIcwhjmDUzb958u5AvBmEaRKTXHxlGrtKox4ACSCFJZ8olq9sWWZqTuatnmjqOiwYGCgDRAHT2rP5B5FqQMs9OypX60eHJ4uqZ/mh0dHoSpWR+YaHd7upmtl6tpnGSNcw0TcejEQPg3sa6mck9c/WZ/f1jQ8/6fuha7oWrV/3JRCnmdm7fWnrm8tH6rSQNFi9d7O1sjNonqsyLoqzrepQQ3/d1w9Q0LYqSlBKeE8VsBiRJGAaeG2RMfTxoR6GraZpZKnmuDTgeKyoTNZfycmFGq847TFrb7+6cDgKCmSBJiji1AD5I1YTv4xPrajy+C/fzNgE83nk/4wkAAEY+HBz9DCaAx7ucKZ5KQfzSIgkjXsCSqKRpGvqhpmk5PTuN0EZRFAQBQihNE9ueEMAqlQri4PbO1pTieXBwkMvlyuXywcHB4eFhtVoFAHieNxVlm8YnOY6rVCrTCi0IcaZp8oIEIcSCODs7Oxpa4/HYD4Pm/Nx4PO71epeuXKUUTGwbABDH8WQyiaJI0zRFUVzXHU/safouhDBJEpqyUqHoSfLu7q4o8dlcjrJ0dn4uTdNhv3f79u3Zxkx2Oj76wfbOg7OrZwbdXnO20e+2Op3WmdXFjJlrtU7iKG4dHa4sLe7tHRwdt+YXVmYa1UajuXd0XK5VeZ6PAoclsSzimXxB41Ka+BQk44HLpQ6MLRBPRF4yCiWEOVAWQQrOnL8YxVEul6vNzx3sH2SzWYx5TdNEntt9sP3y7sHZs2cFnu90u1euXMlm871e7+joqFGlEHCNRsOfTEiajo+PojgEGeNgb5+BROQ5UYDlchkB6jiO53mEQUIIz3FThmtKSaleAFEERFFI0wCGWFHsiUNobJhZgLCaK4yHI5xSPaOKqok0PaXU9nxCqSSrlGCKcZIkHIcQQhhjCCF9HxzHwS9yXY0vCj5CjXmyXPmfGU+GBfRYeGLsoMf1qT2uBfC41/N4LKCfJF18qut5rCvCggABAISQKIrTNC0XTFXRu92uLKv7+/sYQInj2q1TjHGj0fACf+JYAIBSqRTH8dHRURzHuq4fHR0Vi8VKpdLtdkej0TRC6/t+sVis1+uqqk4mkzRNc7mMoiiEAozxB9lhk8lkpjmLMXYcxzCMJElOT9sAQkJIsVhst9tGxpymgNm2HUSxruu5XE4UxSiJQz/CHCwW82EcZLMm4nCr1VJdtdfrSQL/zI3rSRQbuuHaluXYC4uLtusoivTe2zeD0K3XKnEUbN8/sZ2RoasQ0EGnnTV1WZiP01hWpDvvvv3t3/iN026Pg0AUpdOj/YsrC5ViBgTW66+9xKUOl9giC0wRlEyxkFM5XUWYC1zPdUJBlm7fufP8V74y7HQC1+tTOrGcMBP2uz1BEC5fvuz7/vbW1gsvvGAY5vb29tHh8be+9R177I6GYwCpH7iFXL7btefnmyBJdF0XJby1tfWtb72YOKNO61iWZcuyIObz+bxlWRVZjuM4TVMgCEF/IvMCACBNUwAgQFgUFElWAWEgnxH9AAgigxipOtBNQLAfupQCThSEFBPMp6HD3seHO9ujSByP09l+FnzWLMHHZvE9ofM+Eh+osn/IAvhp7Twui+nxruYhnloAv7TQdb3T6fA4yWRyVKJhGCLGSZI06A/SNGUAWmEYp4luGoSle9u7YRxcuXJpKuSwsrJycnKys7NTKpWuXLlydHQ0DQx0u13DMGZnZwVBkESRMSYIUq1mGKZp27bjeLquJyl9951biMOVWtU0s0dHJ7KszszM3LpzlxBWLJUkSdJ1fVqc3fM81/UlScoVioqiMMaiKMI8VyoVBu2+azuN2Rnfd8M4MAzttNPO5/MXLlw4PjgEkD148KCQy1+4ePnw8DAJ/IKpQUSvXb2cz2Zuv/d2HHm1SqnX687Pz7uue3R0vLS0srN3kETBlYurm/fumNnCoNsFSRD7dr993Nq5Tdxh73jrxeeumGJW4xmMvcSzrKEdO54syxMrWDh3fnttbWFhUTTNf/Evv3vj2YuZjEEpHQ56pmk2m83JeGyYGoKw2+3e39xEiPv6Cy9Ayrrd9sLCkmM5iqIADDmMlKwJWie5jNFcnC/ms/Z4POqeBq4v8JKq6IIgyoIUx4nnujzmEEKAEN/zZNNEELE0AWmaMXOcyPGyRlmCMKeYWcCLEaF8FCOE4zidOJ4X0IRyCYEAUowxQvAD/880n+PjTonplPAL7ru/pPjwvf3INPCLwlML4JfVAgCTyUTTDEmQIUSAAczxEEIAkO97hULh9Oj49PSkVCxyHBoOhxjDhYW5MAwty+J5nud5juPy+fzKysrp6anrulODIJvNTtlBkiRRQtI05TiO53nbtkejEYSYl8TYDfr9/tLKsiAInU6H47i5ubnd3V0AULPZYABM9S/r9bplTxzHUVV1Wu6RMWZZluu6iMOMUF5AvICOTw4CPySM6hlzYWFhYWHh5OTEC4MHW5uzs7Oqrm3tPMjlciFLHHv8O3/3tzfW1l9+6fvnz630Oq3bt977+gtf1Q31jddenmk0I98+uzh/2u482LhbKFYerN1TVZVH6Wy1ELmjak7Nz2aWfv3ZSedQYBFOA8QwJypRmlpjr9e15heXSBSunD0DZhq3//RP6vXc8vLyeDxuNpv1en1v9+DmzZv5bFYQhF6vV6/XwzC8dOlSksSvvPLK4sKyJPDS3CzzPMBomsYs8CAEljUK1p0zly7c/PEr5aw5NzfX7w+KxSLGeDwel+u1ycNSzIg4ThzHgFIgCBhjEMdmLk9YCiBCWAAxBaoOsEC8KAkiDSJCSRAEcYoAx1OCIIAcx0H4UD6dUjodjD6csPnxfP7H6m+Pi185C+ARD/sv1gJ4Kvf6S4soiDOGqUiy57iMsSmjfzAY8DwfhkEQ+BBCQqnre4jDjdmZfD7f7XaTJMEYt1otURRXVlaiKHrw4AFCaFpda25uLpvNOo4DIQzCkFAKIJzY9mAwEkW5UKpMM4wXlhZlWQ2CKIgi3TQnjnPSai0tLU0rGk6LeU2DDaqqSpKUpuloNOr1eq7rUkqDIOh2O6LI12qVJInyhVwmaw4G/TAM767de7C7o+ra3/v7/6CQL560ThOSTibjXC6zuDj/z/7pf3fr3Zu1anF7Y/34YG9htu5NRn/2ve9++4WvPnPxLEtCd9KLvXG1YLjjLou9gqZkVSWYWP3WgTXqDLpHDzbv7e7ev3P73Xfffmtra8u2bYx5xMkkBQxwWw92gWb03rvz/e9vX7x4kVLa6XR4Dt96520M2eWL57NmxrWdYrFomiYE9O6dO9/7o39bLZeXLpx7sL3p99uQAyz2dVWEGDGSJHE8Ho4AA5qsGBlTzudFWYWYD+PUCyLAEIIcbxg4mx0NhmmcAEIAzws8H8cpluQwJn4QAVUHYQwgAgBhXqAMAMxRCqIkgZjjRZkTeMhhiH4C007ygRv6IyvTp0bAZ4EP7u3n5ybD//I//z/+vE/5lAUEwGfPAgKKJDPGnInL80KlXIvjtH3S9X0fULa3t6fJSrGUHw6HQeDlcjlZlre3N7PZrKIo02Cspmme5x0fH5dKpWlu0VT3f1qQCyHUarWm0p6u61IKmgvzAi9tb28zCGq1WrvdVVVVlOVut3twcHD9+o1sNn98fJwSwhgrl6uDwQDzHCHEtl2O4xJCp+cVRRFxmKZp3jT6vY6i6hQwnhcRx/UGA1VVFxYWNjc3u+3OfHO2Xq/HYUCSFJOotXu/WauUiwVr1Pcd+8zKQj6XPdrbXVqYPzw8nMrbbW9vZ/M53w1a7V4a86IoVyt5HiXL8yWFT3WZeuNOZI9gEuA0ljlkyqqmqAovIwTswCsvzTPb+ZM/+2NVk69evYow1svl17///eXl5eL589176zRl+Xw+ipLbt28DQNM0PXPmXCaTuf3uHVXVMMbz8/NH+wfzC3M8j2++9QZC4NnnnwWKNNzfsycTRZFM3UgpiYKQMMoI5Xk+Nz8PZHnn1dcRQnML8yiX805PAcRqPt9pdTgRF86u0uEQ6RrgRQp5l/HG8vluz7m5sZuKOazl7YhSACGLMXpYhmhqxk072wdGwFMW0BM57yPx+WQBfXFdQI/6xR5tUj2Z0z6qzsHjPi/w0dn2jz7+E8/LMMYAAEIIxpjn+TRNgyAAkkqShFJWKpVomh4fHGIsYowd1wYASKo0GI2CMKw16mmaDq2hKIqCIExTtKY1YXZ2dmZnZzOZjOM4mUxmPB5zHDczMzMYDA4PDw0jgxAXEzq/tGyN7V53cHx8nFKyvLwqirKkKF4Q9AZDAMCv//pvSJK0s7Pn+75hmgihra0tAEChVJw+BqZpjqzJYDDQdX1mZgZxeDwcOs5kNBohzJvZTBjGzsQGDJlG9rUfv54k0dzM7NmzZxFgHmJh6A9Ph6VirpQzR/3O4vzcpXNn79x6Z+32rZWFpj3uN0p513VGnZPV+RnH9yx3xGLXt1MqKrgg37l7c38drSzVj3bvnV+ZK2bUxWZT43HqB71W+8HmDgexqqqFagkfnbz5xmszM43L168CjgOGPt7aWlyYLy4vgW63kMv3egNBEB482G02m7NLi1t3bkWBz+XynjOJw/DrL774wx/8ZSGXF1Xx4MEDDJhp6ICS9tb29vbm9evXHccJoliS5aOT3au/9ms7b7yxtLICEAZja6Y5+9JLL+WLObOQS5IoU64CQRJFMYwjMLKQKIGEAEXyXd8o5tPJRJbVfD5/NAwJdGPKcYLIGCOEEvJwGPqwEfDxDvYLJKg8piv1M5d3ftx2Hn396OOH/ZTGH3c8/9novE+DwF94fMDr+IDcDQAQeUHg+G67U6vVMeKPDo84TuB5YcrIFEWRUhqGoaYrgsBNJuM4jjOZDGNsMBjMzs4CALa2tsrlsqZplmWZptlqtZIkuXTp0mQyefDgQb1en5lpbmxs5EtFhNDe3l4cx0sry9lsdnd3/+joSJTlIAhqtfrCwsLe3l63283lChzHfVDPXdO0MAx7vd6NG88NBoP9/f1SqfTNb37z6Ojo5R+/oqtqrZS/fOVKq9VxHM91vJikCwtLBwcHX/3qVzVZSkni2pMo9KPAxRAtzM+Mj3fHo/6F82c7pyd/8r3tfEaXOIgZRQDcX7sNEVtZWdnf2YnShIQexyJ/Mlq98sywe3Lj8nlN4VvH24vzC649SV1r++4dicOh7cEU5LNmIZ9fWF4ZO+Mf/vBHCwtzy6tngCCDyD98++1CIZetV3duvrl07YZzfJzNmnt7e8fHxzduPOOPRpubm5cuXeFNY2lpIU1Ta9yv1yqKoqzdene23siaqiSJ1mjUbp82m02O47DAc5KcUCIosndyvHTuLIsTaNuA4wghqqoGQWDGsaZpAGOQJLKsEkZ910c8kkwT8DwAIE1TjucxwIQQMBVuIgx+UB7oc+B2eIrPD55OAF94TF26H5RHnjK7MY88z8MAZfSM67pBEIii3O/3gyDgRUFRlCgOE5IKomjZk3a3oymyoBtBEIiiCADo9XpTuX/f933fVxQln88ritJqtdbW1gzDWFxcvLu+QQDz3OBg/2hhaZFSGsfp9vbOyLJGo9H8/EKjMcOLwv7hwWA4npmd81w3DENBFEulku+Hg8FAF4wvf/nLnU7vxz/+calSXVlZuXnzpuu6zz77LALAmYx3d3fn5hb6wxHHcaVSZW97j+f5vQc7CDAE6c72ZqmYu3h+9ejgsHc4ySt8rVH+0Q//kqbJTLVSKRXmrl1++Yffh4zUygVdkd9948cCh13fy+cykGJprnpyuH3h3Mq9O+9BFv3O3/7NwB2hNMvSMKcZEsfN1Ko8RPbYIkn6YGdHUOVytXb9G988ub/x2o9fefEbX6tXa/1B92BnlxOFP/xn/+zcufNnzl344Q/f/N3f/VvZUuFga/voILx2BQBJqNcqnucN+t35Zv34+NiZjOXFBV6RAYTj0aBaqYiS5EexKCljayKKgusFxyetM1/7mre7CyFTSyXseZVqNYwjQFIuYwJCQZpIus4g9YOABIRTFA4DDEGaxpzAYQoJTREGEEHGCEKIkCepLvUUn0P8DPkcX2AX0GNH+Z8Maeix1RAfxQJ6bBfQIw6eSnhO/T9Tly4AgFJgWZNGvR5F0WhoGUZmusoul8v1en1aNFGWRcrSyWSCMTQy5jQAW6vVDg8PXdddXV0NgsDzvJmZGdd1Pc/DGHc6HQBAs9l0XbfX6y0sLEiicnh4mFISRREAiFKapuk3vvENxkAURUEYJkmi6/qrr7568cIF0zRdz+t2u/X6zPz8/GA0XF9fPzlpVSoVRdNOTk40TatUKhQw17Z93+d58aTVLhXLikyGg7Fpmq7j+K538cK5tbu3nr12pVopvPXaqwKPcoYqorR9epLPZuZmG89fu9Y+Pvrv//k/4xA4u7yIaPLOzVuVUh4AWi2Ze3t7jcZcEENE43/5B3965WzlH//P/oMkDnxriLGgySpSM7HvxAl1PCcM/GqpLCkyRfDa9WfuvnVz0O9cfeaabU8m1iifz/Ll4v3791eWFubmmm++/upzz53PzswA1+l326oKFEkGvhvHYRQFSRQIuoYxqtXKg0G/Oj9LAz+KoubKyuGDB9WZptCodW/eFHkFS2KuWAA8p+VzVr8LJJFxqFAujUYDFsfQMLxhT5INLMsyoIQQJ3Rd28lkA0EQgjQFHCdSHgGIAWWIAUAhmo4Lf+Uc+Kk9+a//62eHXxxL58ngSbH4Hv/wnyWf46kF8IUHQihJEkopxngaDIjjOI1JRjcMzWy1OoxSQtJep8tjjsfclIfDcZwsS77v8zw/Pz8PIRw6wVT0HwBQq9V0XZ9MJrIsB0GQz+dPT09PTk4opaVSSZKkMAzPnj3bOu1kciCTy04mjud5jdlZSunFeiNJ0lanrShKEpPBYJDJZObn5xVFOT09DcJwZmaG47j19fXD4yMIYa1WO3fuXJyS3d1dy7KCIEgpQQDKsioIguf6lmXHUSoIUsYw0yQpZMw/+e53n71+RcDoz7773VqlWK0UdrY26qXM2eUFTZLv3r71/T/+oyQImvXK7/7O777z1hsPjvfPnlmGiEg8d3h0cOns8siaDHujXLb4jS8tffsb37RGo7V7d7787A3fnljWsN9pXzy7atsjQ1VWV5fv3r0LIRQV+c69ddsaP/fclxgJ7t29Va2Uhr0+I9Q0zWloJIqiZ2+cu//22xlD7/V6Z1er+XwW+P5kPI6iUNPU1HNmGjXHmXTbvWpSicNAV5VgNLRtu6nIQDMwJ5ycnhZLJTObBdYYqErSJYASApisKrwnEEY5xmzXkRUTIAwkSQMZCojruMpkIuQKMGWApJCTJElAYUApwQg81HdjT42AX2b8DPkcTy2AJ9f+L8gCIIRMSR3Tol1T2U5K2ez87Ggw9n1fkqTdnX3XdZeWVjzP6/f7U6F/AJjjOLquqqrSarWMbCaN4uPj48XFRUVR7ty5AyHM5XK2bcuyXK1We71et9udchw7nc544kEIJ5OJIAgzMzMY44SQIAh8359Sbm7fvi0K8jPPPDOtOnl0dFSr1QCER0dHW1sPisXi4uKi7/szM7MY4/duvj0cDr/yla9EUbR3sL+ysuI5bvu01WzOe24AAclkMv1ur5DL725t5jPZUb+32Tp65vKl8+eXN9buvPjVL7n20BoPbz/YNQ3t6tUrKwvzq/PN7//5n9A4unzpPE1jgeP2drZr9UoYOIrMXzizuH7/wW/9xm/ceu/tB1s7v/2bv3V60g1dx3Mmly5cvfnmq7omAhL94Iff/8Y3Xojj2Jo4ZkYvlqs7OztJ5IiiGLgexlCRxcVnX7j/+psZs3Dt2rXT09OzV6/2DvajKFpYWADZLHBtxijPY9M0RuOBoekAgHq9enp4KIpi4caN01dfxRgDCIA15kThwd7+hcuXAtcDEIoaw5wACJEkCQCQyec4UQSiME2aA5QCxoAqGVS3Ay9wHSFX4BAGfgCypmkYrXFAaIoxDwhFH+pBn2Ya+LytoH9R7Typ837WFsBHMo3/2uuZ4mkewBceaZoCADiOmxZjSdMUY6xpGgBgKtrjuu5kMtE0jef5qaz/lCmEEJJV1fbcwXg0fYdSapomx3Gnp6eTyURRFABALpcbjUaTyYRSWiwWG43GlB7a6/WWVpZzuVwQBK7rJknium6z2cxms61WazyaXDh/6dnnn2MQbG5vHR4eLi0tjUajg4MDCOHUE1Wv10ul0p07d374wx82Go2vf/3rJycnw+FwZWXF9/3BYGBkc61up1KvlUql4+MT08zYYxsDWKtU2yen/85v/a2F+bk//rf/plYqaqrUbZ3+4R/+ES/g2UZdFvnT46P/8X/4/TgMrl25HHjO3vb2g+2tZ65edu1x+/QoCr37G/eWF5v3798bj4cLCwtvvPHmm2++Va02rly+/srLrw0Go42N3fmFhf/lf/wfHxwdYp47d+7c4cHxYDCIkyQIgqlCBs/zjQsX1l55RVc1jke3bt0aj8cAgLt371ZKZU1RAM8BhCVJMgyDw9hzXNd2DF3VGtVury1wHNA0BEClUgGiDAjFHKcbhpgrIJ4Tc1nAcbwoAMqwohBKNUMHCAIIzHyeUgrSFIQRSFIgyYokQwBYFHA8CjwHIGAYGoSAJDGHIWXpBx3mqRHwS4mfLZ/jqQvoCeJDcuo/scefpPUPPjEJ4NF4WKzjQ0XeH36cUsJxHM8LEMIwDCmlsiybhtludwkhGHMnJyeyLOdyuU6nBQCQRQFC6Ll2JlvLZGvr6+uRH1y6dOnlH7wkicq1a9cePHiwtrZ26dKlarXqOM7R0dHy8rLruv1+f2XlTKvbu/XOuxcuX6rWGpZjp2l65vw53/H9MByPx+vr657nZ7PZOCEcxx0cHLRarZWVlUqperC3z2GhXm1ESUwIEWUpCIL33nuvUqksLa0QQvZ3diGEGTMz6vZPO918oSDJcq1e3z/csy2nlC9M7JE16lYqhTt3bn77xa/t7mzeX7vz4te/nEThv/3LP/Xt8a9/+2s8woeHh641JlF0bmlhbqb26muviDyqN6qqJN1+7xahsSSIk8GIx5w9tjqdztL80sba/cCP/jf/yX9yf33jpXt3apUyZcn161cqtdmXX3sDIlHTs//D7/+Lb7745VIpH0eegAuh7xNC5q9e7WxuipIiy/L+wfHy0mp1du7lP/9z08xWioWEMJAyQBkWeElRAtdJKckXC9A0QZKommHUZ9jdNdePq2ebNPAgzw363XKpkFgWIQxwAnMmgEEax0hWfN/XNC0OfQljIArUDQFLSRRiyAFFU1SdYByFiaThJAhlAExJwoxSQjDiCKUQTNWI389BnxKDIAMMfrD/SRfy0+nhlx/cp+ebPrn1wqN4u49pjjzicthPzn4fcGMfN3EMPm4ixsNMjI/r+3+C6P9Pue0/xWXEHqaz/US9VgwhAyRNY4QQZABDhCEHGfAcl6UsoRFLiamrUeBlTX0ymTi2o2f0rKFDRm1rsrSwWCjm337jTUEQSsV8p92mhFy5cqVYLBLCXNcvlCvtXn8ymaycPUdS5rh+uVqv1hquH47Gk2F/wMuKJIidXnd+fuHevXtzzYVCoTAejzudjucFSwvLzZm57e0dgVdd11XyOvN9URc6nc54PNZMrdqoIgQODg4NXctl8912j6SklC8U67WJ6xx3TgZW31C1mHkTu1ufKXjjUTGv3b39VqmQ+dKXbmQyxrDbwZibm5lTRZ3HsJTLD7rdzfW17Z3dfq9TzBrPX792tL/z1ltvLczPmnrx5OQony+Kghb4yZeuPt/ttHRZqpdLf/Cvfn88HF6/do0xUqmuiLL4xtu35ueblUrln/6TfzpfFxVMb735Ki9gXkDzs83CbOP43j3bts9euHj3vbtGNpvJ5DZur2fM/Hg85kUtU54BBPt2mKk277395mjQn5lthCmTOT4aWKqWAUYGBuns7BIIEiTh7sGeQEkURqnvZzUDBCGJiRuEGPNKwRTFsTNxsxkjdT1O07HEA5BAWQBmxhuMeMVI00SSVJBSQzNAr6/kKkuzs29t7EGB8KJI0wQBBt5fQ+CHtFAKGKKQAoAAZBQCgN7PKKKfnDr5uC7QzxpPKpEN/WyZVJ+AJ9POY18O/ORV/08ft59aAE8c9FPvHw8PpxdIAXi/kDdkAEyru2NKQBRFkKEpj9OyJqIoHp4eTmOw7xfe8nRdF0V+OBxKsuC27Xw+rynKxr01hFBzps7z/GhkUUqzuVwQBMPhGEKYMY0gCOq1mTCILXtiGEajMftgd58xZmYzhDysK3np0qXXX39D0zRK6dHRUTabNQxjYWHJ9/3vfe97Z86c03VT0zIbG2sXL1+ggDj9XrvX/da3vuH7/t7h3lR9qN1qTSxHFuRSvRqnieXYg057cWHesyfWqLe6sri7vRG79uL8zEylIgp42O28/uorqqz82re+zaK41z4eTayNtbvZjLm8vCwg9uvf/oZrDX/v934vCYO//du/QaKo129dv3YjipJBZ5gE/sbdW71+F2OcNaX52erFc4u2PclkMhcvnREEUVLEXm/wL/7Fn0gI/KPf/d3Tg62sqYdhQJO0Wi2Ho5FlWTNz8/3esNpoZDP5w8PTbrc7MztfLJQlUQ0cd+2Nuzd+7Tve6VGcpuVqrdPt5fJ5GXGEAUXTAeBAuRJu74pIBzQxVQWkhCTp7Xff/dKv/zrgRRwlAhaiKFHiWFYUjgHAcTTwAUk5ATNGgjRV44giDDFGBBBCMEQgjgjlMGCaKuuqGgGQJnS6npku/BGbKs1QwACYVop/uPynH3JWf3KBo6f4ZcIv4QTwcV/YQ27sL1h378ljupSbyquRJE3iWOAlWVaTJLVsiwccz/NTMeEwDHVdHwzsKaVHURSIWJIkAIDBYGBZ1pkzZzRFOzo6AgAVCoXgoSqcqOt6q9Uql8uaauzu7mbzOYSQ4zi2bZdKpalyg+/7c3NzL7/8ciaTlSTJNM1yuby7u+u6LsY8QqjZbFqWBRivyNrVZ665vjMaDW7fvv1bf+s3GED9/rDV6lw6f0kWJc/xTNNMo9RxnN3jQ0EVF5tzuqRoPD+idGdzK2cYuXpV4tDJ8TEP2VyjXrnxbK/XO9jf8y2LJTEhyfPPP18rF01d1WWx2279+EffL1eK169cGfTaw25nfm725PCo3TlVZS2TybTbfU3lbty4IUo4a2bOfelZEATDTmdj4+7GxgZJ2d6eo0rg//yf/acotLr9QbFYkGXJdV1C2MbW9vz8fGZ2/gd/+Ie16ows6dNkadu2Pc+7dLHiOI6u68CypoGN/d3dJEkyxRJAOE3TdrudK1ZBuYwQAqYORt0gCHK53Mh2+v0+iCLAi1Dkp3d4WgyAT1IgCAAAwBjgBZYSkqRpFPMIcwhRjtKUYIxJnMQ0lAHIGmYmY3RdQmgCOTS1RtHULGXgwzHh99PE8PvTwBcJPwP//SmmeAwW0Gd9W594+x92Af0M7X/OUskfrtmm++kibXrcNPBLKeWwIAgSAIAQwigcTyZpmhqGIYoixz2c6YMgCMPQNM1259Q0TUJIt9udmZmRJGl3d7dSqRDCDg4OUkIWFxclSWm1WmmaTiPJ0/ohjuOkKa1UKpqmJSQdDodzc3Nra2tJktRqtanC8+HhYZqmV65c6feH02b7/WG5OOt4HgXMC4Pdg8Nvfec7oqTcu3dPVZRaraYoShhEkqjIsjzqjw73DzKmoRiKLimnh0ciRqKAeAjOrSzTONzf3SpmMxKHbt96t5DNYAS//xc/+PL1y0vzTU1TeA7bo36tlK/Xyv/v//a/mZ+tffnZ6zub63EUNWcbo0EPQqhIkiDCTveQUPLccxefe+4SpcTznXde+tPW8Umz2ex3j3IZlefF1285/97XVykNQ9+/cvlanITDYb/b7amqKolKtlIf7u0Lgjg/v5imlBIQx8nw6OjMmTNQkpDnmKbZbrXy+TxjZDAYzM3NgmwWuO5USG51NeDimFIK4jhwnMFgkK01aJI2Z2fDiS0lFBi6yHMxhwCJAWNh6En5jCBJgFJAEkCpiBGCTBR4SBmG0yUBpCkhgACSiJKsqXLPmWCO/2AJxBBkDFAA4PteV/p+x5segAAEAD1KjfLzNrx+orfnZ7jIz9nXemz8bL/LLycL6MMc2E/Jh/38Y0oaheyjzkEOYZoSCKGiKALHh37oOwECIAiCTqcDIVRVtVgsDgYDAECj0RBFcTKZ+L4fhqHrurqu5/P5fr//gSonpTSbzbqu2263JUman58fDAbdblfX9cPDQ8ZYpVIxTXOqHd1sNo+Pjx3HefHFFyVJopROi4itrq4yxjqdjiiK/X4/m80iDrfb7SiKOp3OzMzM3NzcO++8WyhXcvnimdVzE8s+OTlxHOf09DSMfIFDtXIpq6rDdqdomogmHGVfuXHjYHvbHg6eu3KFA+Bg54GE8f17d7bW7/7v/rf/q2euXtnauu86tiTwgiBs3d/40z/+3q9/51vnVlf/5Ht/hBE8f2bVMIxMJpPG8cULZyCIdJ3/23/769948fmjw63W6W4S2d/77uuGIdVqhZWVuevPXPK90ZUF8Jv/8O9yqnhycnLz3Xf+4vs/LJQqnCAdHB9nszm713/zjZszjXkpm+12u4IgQAj7vXE2kwEib1nWzZs38/m8msutra1xHJfLFYDjAN9njM3NzXGCAGRxPB5aR0eu65pmFmCeEFIul0VRGI76gCYcj2RJAAwkvj8cDgHHAVUBANAgZGkiShLieMjxJE0xgBxEgBAEKEaQhT5kVBI5CFKB5xikDFKAGIOUPnwxLbcNwEfZI1+wYeGX8nn/+eCX2QL4SOOPy8P9nFkAH7z/V/vpKw5zACAEOVGUSUJ8L3Rdl6UsSRJRFKelV9I0TZJE19VpO5ZlzczMTD0507ReAIAoihsbGwsLS/Pz82+/847neWfOnBNF0fM8CKFt24IgZLPZUqnkeX44LVMFgOd5vV7vy1/+chRF/X5/Khu3sLAwJf7zvDg/P89xXJKQra0HC8vLW1ubzfm5crn4P/3LP/gH/+4/2tzc8P3A9b1ut0tTAjnW6bYK2UJzpuE7VkbXGuUCz8G8JjASd04O7fFgvnbm1rtvxoGvyBwPwde++ny5XEwT70c/+OGF8+d0VZmMh4amIpoOPHs8GrSPjuv1uizLiiwOe24UBIsLczfffjOb037rt75TqNVHp8dR7EZRMOgnZ85IX/7ys8NeHwMSefbmmv1bv3Xebx9trq0f7x3cuW0XckC9dEXe3U/TtFprvvbjH1uWm8sVgpHV7w01TccYZzJqPp8FktTtdgSBFxRxZ/1esVgc9ru9Xs80dUppHMeLZ85Eri8yRkiSpFFC0trKEkgSRVGSJIH5fNzpphOb43kOIQAYoclkMqnTFCAEAEnDAAs84AQAGIAgjSNRxgAykMYYQg6CKPCxFCqiAAFBIIUQ0infBwCIIJ2Ggt/vbH+lFDQlBEH4RbEAPsBjBT8/6eNP9Gp+7nhqAfwVPggDfEoy7BcOCAAEAGQQMkgIwxhjhNI4mQ7KaUpt2yaEFAqFaRhgMplks1mEUK/X831fVdWpEL+u6wCAMAw1TXvw4EG1Wp2bm+t2u6enp41GY2Zm5vDwcFpCQJZlxtj8/DwhpNPpRFEEAMhkMtvb21evXg3DsN/vd7tdVVWr1WoURRsbG4uLi8899xyEUJblOI5LpdKDBw9yubwgCDs7O//zf/zv7+3thWEYBMHh4RHP85lMRlXVSrGoq4oi8eWcrnBUE2H/9CByxiR097bWzy0393c3MEvKBbNayjTqpXxW6Zzu/fkff/fM2eVCoTAtam9Z1vbWfVnkB93uubOrxXyWpcndu3cFjmvONtrtdqNaWV6YB4S+9dIPbr71xsLcfC6TPT7cv3HtmtCoDfpdWRKs8XBxAZw/d+bwYM/3/Xq9/mu/vvrb/86LoD84ODq+dOUqEMS9g6Pm/Jyi6hDgxcVFQRCCILh27Qq3vBwdHwFIv/Tl5/qdTrfbXVxezmazURRN/WmiKAIIkyQKd7Yr1VI+n8cYAwpASrPZvCyIIAw5jOzxGBBCkggAKkkyIQSEIYgiQBmjBKQpYATEMWCEpulDclkSAUghoLHnQUo0iUc0iUJvutynkELEHtLJEKQQvL8hhvC0ZyGAIfvCjAw/G//9Kab4wvzMT/Go0FwYhoxCwFAYRklMBEHCmA+CiOO4KXm/UCjouj5VduM4Lo7jfD6/u7ubpmmz2fwgkKvr+pkzZ+7cuXPv3r3f/u3frtVqP/jBDyRJajQa4/E4n88Xi0XHcfb393O5XCaT0XV9Z2fnhRdeCMPw9PQ0TdNGo7G8vGxZ1vr6+tLSEsZ4bW1NEIQwDLv9Xq/XKZfLqqa5rnv16tWjoxPLsgQs1Ot1RmixWBREnqXp0uJ8Nmc49qiSNeLAOniwXi1neBgPO4fzs+WT473VxebqcjOXVRBMPXewvb0WBfZv/Oa3nrl67a233kjCqN0+feVHPxJFsVarFQqF9957zxqNwzCslouiKO7v76uS+NxzX6rVGq+99vrEcs6ePR+G4ebmJoLc4tVr4/WNw8NDWZT6/f7Fc+c6p600ii+cO58tFKMoCqIQBNG58xc5Sf03/+O/QhB/9atf73Q6b7/9tiAIpmnkctn5+XlwsH/z7Tfz+TzP85ZlraysdNvt2dnZWq0WhnG3280Ui5HjaNns9va2Wi4jUeCw0D84BowZhlEol+2TU4kXfM9hJInjEDAGVBljCKKIhB4ADENA0wTEAQgjQCgjKQAUUAJSAhgFjCSxz0GmSDzHSBK4EFDw4Qd+GiH72Dj5dOj8lQKCHwN6BD5+5OcW0+/24frXP3MjH8cTv9pHnXf63w/uPwYQA4YBxAAiANH7F6JIMkZoWuI1DuJRfxS4gSyroiC3Wi1VVdM0nUwmlmVNR/MgCIbDYalUwhj3+30I4czMzNbW1tLSkuu6rVbr3Llzrutubm7Gcfy+bJw8vTDHcaYkItd1CSEXLly4d+9ep9PJ5/OVSiWXy926davb7X7ta1+bxqUlSTo4ONjd3QUALC0tqapCSapp2unp6dbGfWs4ajQalVIZMTDo93RVMXR198HWXKN++cLZne17aTBpVHOajHiUdFtHiMUztcLE6mUyCmNRv3vi+ZNczqhUC8Nh/403XtM0zTCM7e3ta9eu/dqv/Zpt2y+//HKtVpubm0uSxPd9y7LCMMzn88fHx73ukMPShYvXIBRvvbf2yiv9ubkl4Kd/+K++d/niFXtsB24gi8p4aC3MLXpe4HkeL4kxSQklupk5OTy8fdd+5sYN0JhZX99YWlpijLVarbn52dbJ8asvvzQ7O2sY2v3765Sm0wLIgR/l83lJ1zOZXOx5oqIAXc3mMgdr92gUZbNZjHHo+XwuDxCAkAkCp0gCoKk1HoIoBJ4z22y44wGW5Z0HD1onR3zGAL7n2hZgRBKEXrsNIACCQMIIpLHEcYPOiYLhjUvnYtcmcSzymJE0DgOMQJpEU9cfA4gBNH1eIAEgZdPtcZ+LXyA+/KT8tRf5qO/FHoHHbedxj39S7XzKe/URPLUAPqf41L8oIoRRAihlSUzCMA6CKArjNE48x1leXpZlud1ux3GsKAql9PDwMJPJCILgui7HcWEYchz3Z3/2Z81mUxTFu3fv6ro+LUI7Vf9HCA2HQ8Mwoigaj8elUknX9cFgQCm1LKvT6ZimWSwWdV0nhOzv73ued+PGjU6nMzc3Nx0QGWPlcvnMyupss3F8fCiKYj6buXfnbhB4165eJWn8xquvWePRytIiAnQy7q8uL21trt9596YiouvXLpw/s0jjcDjoPnP1Yq2atybDJAn29nY6ndbh0f7CXPOrL3x5Z3/v/v37cZqcP3/xzbdvNhqzy6urP/rRj/7wD18uFovVarU36M/MzARR8uDBAwDA2HZ0zdze2pudWaw1l//0T76/v3f89/7utWe/9etbdzcuXbyoacZk4miaFoax53ndVhdCWCyV4iTpDwbYNO/fv7+5vf0P/sGNZrP5L/6L/+LFF79ePXv2u3/0R6LER1HQ77dlWWwuLdy6dWs0Gq2urpqmeXBwMB6PR0PLHg7DMBQUBQAAKNV1fUphRAhHUWzbDmAMcJyey4mKpOvq0dFB6HkAUMBxsiwDAJIgYIzEcQjiEPBY5DFIYsYIjxENApDGkBEOQRExnlFMU10SmrUKDUNImaoosiQBygSO1zTtA3rYUzzZgfWLgqcTwOcR8Ccdmj/xJ0Dh+74gyBBkgOM4jDEHEQKAUkoIYZQyBizLUlXVcZypXhvHcRzHTTmdURQVi0XGmCAI+/v7HMfVarWpE2N5eXnqDwmCwDAMjuOGwyGEUFXVOI7b7fZoNJJl+WEl9L09hFCtVrMs6+TkRBTFr3/9667rMsaCILAsayoCSgjJZDI/+uFLs41aMZfd3twANL1y+XI+k22fnB4dHvyt3/wNRMlkOJAFIfIdRJPLl85euXTu/sa9H730A0qibFYXRNTtdiuVSqPR6PV6g8HoH/+H/1EmW/z//vPfA5AvlCsrK2f+4i/+olKpXLt27a233trdO2jM6itnz3K8WK7WD45PJpNJJpeLE5IkSbvXL1VmKtX5/+t//n87f/GZCxevxTEFQToajjXNYBQyBmu1hm3bvXbHska11WXHnTDEzFx2eHTkBR5h5NyFC7dv3/a8KAiC/Vu3arWyPR4lUTCxxxyPgCQMBr1KpQQkYWNjY3o3Dg4O+v1+FEVAVZMwBEFgGJrnOb7vAl5MUjqZTAClgFBgZgDCvChJopDNmQCC1HXSNCEkRRjWajVJFkESAwx4HpPIB4DKskxIAuIQJCmghAMMpSkLfV3gVmZmQRKnno8TyjGYhgECQOQFkryvEcTgNCzw/vYrh1/NCeATWEC/qO/8WZ/3sdX4HtXOzyuf4CPTwPvc/w/5iAAEAHAcxygklDEKEeIQxJSAKI4URRkMBtNFuqqq4/FYFPlcLjetGAMhFEXRsizXdZ999saU33n27NmdnT3P8yRJajabBwcHYRguLy8Ph0PAEACAJHGtVlNV/fDo6OTkpFarCYKwtrYGAGg2m2lKjo6OwiDO5XJHR0eKotTr9cPDQ4zxwcFBsZhv1Kqbm5vdbvsbX/9mrVZ57bXX7q3d/V/8B/+4fXq8u7XZqFdca8wh6flnrx0f7kR2HAZBoVDgOE7AgijKiZiqitZpnTpu/MJXv5mk8JVX31LU7MrqxayRffft25KsnDl3fm1j0/F8TdOajWpjpnmws13IGoPBIGvo+VzGGg0AxL3+6Bsvfue//if/7YWL586fv/hP/sl/9R/9h//eeDA8PD5ZPfPNfrdzdHRUr1fL5SKHAOZgOh6GoU8plSThzbdvXrx40bbtg4ODm+9uffsb14ej/tHh4XPP3Xj7rTcwLtbrVd/39u/dvvHsM3PNhfb+fpqm2WwW8PxUrxtjDETRDzydA8jUPd9xHEct1iHEaUoBZcz3oamz0IMcLuSyWOABh2LHFyQFAEApVTWZLxVIHGKMAacwxiCjkiQDiAEDEFCQxAxwiDEa+JyolrJmOZsdOEGYuoIsYQABJQjQJEkEQWKf0LswYx9jHP/N+vNnhCf1PD6pr/VZjw9P9v7/Kk71Xwh8ohHwwasPZwOwlCRhNNVjoCkBjCVJEgZxpVKZTCZTDwwhZDweU0oRQjzPT/Wcp/HJxcXFqbrndDSP41jTtGazSQgZDofLy8sYPxSzzGQymqYhhKbVYDKZzLlz5zqdTr/fX1xczGQySZKEYViv1wVB0DStVCrt7u5yHJfNZnu9zqWLFzbW16Iw+Pa3vqnI4isv/2hijb/5wtcVQVy/c7uQzYI0MVWFpdGtd25ORkNrNAEMlUtVRrFu5iGSoxjcvbcVhGBx6cJw5P35n/+YMfnq1a8IQmb/sLNxf/s73/l1zw/2D49M09QM08zmXnvjrdNO50/+7M9nZpv5UrnVamWzWQoA5oTvfu+Pn3v+K19/8Zv/z//Xf/XVr36tWCx+97vfvXr1KiEkjHzDUABMBREREPvBZG9/uzZT40Xu9t1bEIP67Iwoiq32abEoIoRmZmbOnz/reU6lUoSI1hsVRZWOjg4XnnsWIra3t3fx4sVMJrO1tlatVg09I4oiiGPf9ymlwDCmJF2AEM/ziqIASoMgAEmShBFISRQEgBGAoaLKXD4rSYJt2+12W9AVL3B93wMix0kCAIARwlgKOAR5DAihYQSThEURiCIFopVmUxOEJAgwY4ooiZhjhCL2E/1qygh6Oiz86uCpBfD47fwcZ+wPTwPoYxkA038pAYTQJEniOE2SlFGIMc9x3LRIwNTFPJWCkGXZ8zxKKYSwWq0OBoNp4HFvb29ubi4Mw8PDw9nZWcuyJpNJq9Wq1WqGYaxv3p+fn2cUjsdjnufH4zGl4OLFi/l8/sHuDkLoO9/5TpqmOzs7tVo9n887tsfzfKPRmEwmjuOUSqVut1utVg8O9mRZXF5e1FXt7t27nU5noTnXqFdffeVHly5eAGlydLC7vNDc3FhHIP2173z7YOdBt9Pp90eiKBKSbm9vi1g0zXw+X4iiaH1jq9GY0zRt96Cb0TPbO8cvfv3bYZyOJ06hWGp32zeeuSry+MGDB1lDuXz1Sm8wsq3hpXNnw8BbX7t//tLFlOKZueYf/MG/vn7jubn5+T/+sz+9+sy1iTuZ2AOeA7Pzs2kc2M7YdkaKKIWRKghcrV559dXdL31p5fT0OCapJMs8z+u62u62xv3+lWeuQJY67rjbbZumLioy8Lxutzuxx9vb25lMxtR13/ez2WwUB3Fv4DhONmtylCZJxBgDSQIhNI0sSBJCCKAJAIzRhDFC0hRTCjAGgiBKUpikfpqyJElJDEkKIAQcz6IwigIIsaiogBcAQzRJIMMwTUAUAiSVMrmCOY7DhMYJJ+EkJSkjEFAMIP2rPvWBHTBNGHjC/fmzwJN7Hh/v+z5uMfonVbz+qQXwq4KPGQH0E5mg04GeEZBE8TS/F2NsGEa/3+c4TlGU6cA9OzsLISSETCuCGYZh2zbP88PhUFVVXdc1TWu3291udzweB0EwOztbKpU2Nzcrlcp0bhgMBqIoFovFTCYjiuL6+rrneVevXtU07eDgQJIkhNA777wzHA6nFed7vZ5pmlEUhWFYLVdUWbxy6UISBW+89mOBQ8/deIbD8PXXXy8V8q49OTk6LBfzo0G/Ws7/rd/6zfbJ6elpe3X1Yr0+H4b0/v1dhKSz568srZzf2Tve3jm8ePE5AJThMGg0VuKEr9YWFpZW/TAYjUZBEMw05zAvrm3cv3Dp8rnzF3vdgev6jcbMvXvrRyfHN55/bm/vYGVl5c2bbyWEXL169Y23Xjcyumnqu7s7ksRFkd9qHydpIAjo3PlV1ZQcz/ICD3HQMIEoio7jcBzyfT+O40ajsbW1tbm5BfK5KA54nvc9B0A6Ozc3abd93zcM4969gyAIajPNMIx5nocQjkaj6W8BgiBNU4QBi6M0TVVVjaaWQUogAFEQqoaBEAAkYUkCggAgZGYy2XwuigJVVXlRSD2X+B6DACGEMWSOAxgAELA4pnGUxhGNI5rEIE0blWq1UKIpScKIpWQqHAT+SmP8VzcAAN4nDX56FtAvB35Ff+zPCx4KtP+0TjYd/dFHKdvvP6uMC4IwjtMpzXEymbieTWk6paNIkoAx9DxH0xTT1Cf2OE7CYilvmNrdu3d1Xdvb25NlqVar3b17V9FUQZStiVOtNQRBkiSl1xsYRkaW1PFoomnazMzMNFwpy/xkPMzmzOvXr5Mkffnllw1Nr1Sqd2/fgQDPNBpBEHRaXQhx6AcHBwcXzp0Pw1BRtKODw52dPY5DuYxJ00RXxa88/4znTk4OdnMZrZA1MWSLCwvb9zf39vb0TJFh4da9jeHELZZqL37zW+VqZf3+xng8vnbtWqvb6vf7MzMzaUwYY5qs9Ycjx/ba7a6um6urq6+/+goCTOBwv9cRBKFYLu3t7TGIDD23vrF949nnt7a2XNu5cePGm2/fzOeLGTP3r//tHy2vnGWIFyWVAaQZuSAKdV3nOCFrZnRNO9o70lXQabdnGw0M4cHBwdzc3NAa12q1S1cubb3+uh/Geia7sLI6njhREEzLrs3MzFy4MAMhOz06mJmtKqqkqjKlqSzLosgDmiCERJGnaURoyPEsCF1KU0BJSsjEcwHEKWEAYgghSBJACOAQxhhAXswUBEke2441cQgDgqxwmm7ZLiAUMJgkSRKHLPJA5OI0gKEzWzDmylkNMZxGIgKygBVReqgs+xS/kkAQsY9sANJP3B4VJX8U0GNu8CER4dNuCILH2h46zj/19pBs/7HtUcdjCD5xQ4B94oYhwB/e/9UGpxsCADEEKYQUMgohhITRlDAGEOYEhEVKYBgkEPAcFpKY2LZNklCVBQjiXueYE5FiyGEaGDldMeTdw52hNcqXCtlsZjgcYIw2NzeuXbliGtpbb75+8eLF+9t7p4PR2YuXCpVqwpBl+wxixAnD3rDTahUKBcrSJA5VRRB42OkeQUqi0L/55pvzzTlNVv/iz/6yUZ29evnasDcEFOYz+VwmywiZqTdkkR/0eq4TYE7mEF8pVYv57HjQzWXUw70Na9h65sr5fFZrnxzoshQ6XhqniqIDTjjuDUv1mdrcXHW+4QTuO3feWbt/e2aujLjEcwfNZjGNrOHgCDFfFODezoPNze0XXnhhYW5+c+O+wOHrz1zd2d7EAPAccu0Jg5gXpaOTtqJle92xIEgri0tvv/XW2p215aUz7763funys5Xqoq6Xf/jSHUXON+qL9drC6fHAVDOQ4tDyFSxWsoWFWvNodz/xw2evXW21TizLOnfh0ub2g/7Aai6sdPvWeBJqRp7jRUESNUOvz9Qdd8LxKFcyIQfC0OMFlMubssynaQpc9+KVy/l87vDwviSlUEh2du9jAVLPk0tFzcwmKcWiChgGkgYABAjFtpMkCcVyEFGk5YvV2TAmo7FDAAc4Rc+V0jBmSawauqYKIPFAMAJBHzknYXu7nsXPnW+aIokmA8xSxAjCYCrzBzHCGAJAGSPw0flAj1opo2lCwafeIGRTo5YxwhiZvv7gzY9viH222zTD5uPbo67/cY/nIPrEDVL2iRuGn7whQB9rg4xMX3z44x+8+dQC+AXiIxUC/pqF2AekNMYYpYBSNq3fwRi0bddxHI7jNE1DCCRJREjCCxwhSbVarVRKk8kkioJCoYAxdBxHVeVOp/PNb34zDMOtra1rV6+/996ties8/6WveEE0GFmaqvf6A8/zKWXD4XB1dTVN0/F4uLg4L0rC8ckRz2FewG+/+UajUUMA7O7u5jPZyWQSh2GSJOVikePReDhcXV1dnG++9NJL8/PNaZg6m82GoX/nzu3nn7/ebR+//torly+uSjLXaR1rmrqwsBCnyWAwmDieqKi1xuze8eFp+8R2nJvvvr29c/9rX/typVrc3Lhz4/plnkuH/RaGMQfTrY07HADPPXtdleQkCrc37l25cGFr/e6F82dkSSBJHCdhvVouFArFUmXQH7W6ncgPBEGYTCaN2bl33rldKTdKpcbE9l9+5aaiSo3Gwptvvuc68dmzF0ZDx9SzzsStVurjoeW57vnz53VNa7ValWLJNM21tbvN+UXEcSPLWlxedf2QQoRVLQxDCGEYhouLCxwPUxL7gT0cdYPAY4yYGR1hkCaJ53lB6CWpbxgSTYNczoAYIB7TKAGI4yQ1JYwRBiQJSNK0cokia0q+IEoqSFJAQalUqdVqWFIAoYTRlFHAEOARJ/Aix0hox6OWCCKBuiCwdRE2y7mCqdDI850xJCkA9IMgE6RTv8dTs+BXAk8ngC8MpuM/ggwwNl2yTb3/cRz7vh9FCYSQAhBECaVA101ZUvwggghTBjvtLmOwXmuIojwYjY9OW6VKNV8qTxzHzORGlhXG8dL8AoIs9P3Q933fl2VZFMWjo6NsIa/qehAE2Ww2m83u7u52Op1KpTKZjDP5TKVe2dha6w47X/nal+cWZ0/aJ6Vq6aR90h10z15YHVr9t9+7+eyXbtzbuGdN+ptb6543kRXhK199bm399p2123//H/4uAcz13UwhX6xW9k8O17fvy4a2cmY5jaODve3Y9/MZs3t64k2spblm1tRGvXazXrEGXXdiyTzyJiNIw8moo8p8RpNpEu7vbp87s6xpPAREkTgI0jQOQJqqigwoUWTec8YcBAlN1u5vBFEsKfLEcQhgmXyh1ekcn3RyxdL97QeHxydeELVbfU3LYE4qFMsAcwyAfKHguu7e/r7r2WHk+64926hZo0Eah4am+K6tKRJLE0AJAJTD8OhwP5fPaJoiC7zvuJPJJAg9P3AlXSMkBYAhBBVFSdNUUlXf96eZeoDnCSGCIEAE4jgOw3BaAj6JooSkHM8DShHGURRFUcCLAhA4EIcsTRAEkFKaxiBJAGNTHbk0jkASsjRlng1oMlurzNSKEgdBGoE0RpRMLdEPCo7+fCK98Jdds+vzgI/c24/893HUQB9XTfOxjn58fOasoceNzj+22ugntfFXe/ATryGllAAAEEIQTku9siRJkoTEcYwQmsqQBUFAaWpqppE1XN+hNPL9EEIIIZYljVIwGk5arU4QhKsr5/b3jjhByuQKb772+vnzF8uV2km7ZaiGbdskpfl8vtNuQwgrlarrOhhjUZJu3767eX/r/IVzCKEoCouVyr21W0kSLS0tDEd9RqFp6uPx8PBwf35+fn19LZfLQcSOTw41XXYn7uqZBUUSCU2i2Lu7dlcz9EKpdHSwd//+RqVYAgh22u3qzEw+m2u1u3FMOYzmZmciP8hmzJlaMWtogTfxJtbZpfm3Xn09YxqKqhmqRJOoUS079uhg34eUYESvXb24uX57cX6m3+2kacTxIKNroed6nsdxgmGqs82G7/sbm9uCJCqaPhxb7mnLcf3W6fHFyxdNQ+21jhnko5jEAllYOtPptCBOTlstCpFsGg82N09PT+cXmpmMkc2a7733Tj5vBkHw3nvvnD93VuCR6/jD9mk2Z8YRPjo6UBSpUMhxigIgzeZMnufiKAIciqJIlkVJkqAqC4IAAIqiCEFOlGUAAESMwwKAU48/BVEEEJxqfgAAnPFYN02ex0lCQBwlvh+nQM1meIhSStIkpCTmOA7yiBd4HnOx5wkaDuIQkESuNuqlXJCkkhuP/Wjaxab+X/BwRMYAkEf020fw6B/3iYefQIz5KQ/do/7wi2XRfHbnfVKX+ZGCKB/571ML4AsDQhIAKMYIYwwhpJQmSRJFUUxSiHmEOUIZwpxmmKKiEMIsyxZ4haQwjqiZKUAknJx2u71REKZnzl70g2Ri+7qROzg8rTXmiqVau902NR0hlKZpLpdzXbfT7a+eOeMHAeY5nucPDg7u3r2byWSWlpa63S7P8yLHQcoW5uZmavXQ8wGlHIJ3b98ydS3wXNe2JYEr5rLuxCrlc6ViVtckUcK6Lv/5n//Z6urylWuX1+9vdIcDNwxTAE67XU6Ri/X6Sa9n2c7CwgJNyaVLl3ge9/tdVZHmZhuH+wezjZmDvf18LqsIfBIGpUI+8r1KsTAc9NvtU9ezz6wsrq/dRQgoigQRZYBompIvZMPIxxxMksjMmRSyo1Y7YQBhXjPMk1abF8T3bq9li6ViuU4ozORKo7EdJ2x2Yak/mhwenRLKIIdlRQn9UJSlhJKEEEXXDg72SuViGPi+Z2dMbWKNRsOuaSjt1kkShWkaS5IQhr6iyiAJDUOvVioZQ0cIAA5CRgBNBQ6BMCwWi2kcI4yjJAYYgziGlFKWAgxkVZYkiaUpSBJBEARZooABQAHPI0kUeQ5AxijBIAUYAcA4jESMGE2TOGRpDBAAHKaJBzBFaTDunUT9DodZo5htVgoajyTEIE1pGjNKAAAAI/aYBbF/Nnyw9v/I66d4svgp9/mLJPH2K47pj4cQhhAyBgkhaUoJYYzCNCVpmnKckMnkspkCA2gwtDw3ZBTZE6/fGyUxJSkADFfrswvzy0YmL0iqrBp+mDhe2FxcjlM2DSf0er18rsBxnG27S0tLlIIkSdI0HY8nk8lkcXFxaWkpTVNJkrKZzOHhYbVcMU0zTZJms0lTcufOHUWSc7kcSdIXX3yx1+kyxlZXVk6OjwlJTg4PEKC2ZZVKpdnZWQQ5VTOGw/GZs+dzpXJEqKQYJ63OUav7pRe+dnh0dO7cOdu2Dw6OFhaWRuPJ93/4I13XCWGSJAmCMNUfPdjd830/SZJcLhPGkarK/dFwa3u7Wq26ge+HAaUUC2KYJgQCVTdjRpKUrm9tdQbDQqV08eq1zmAoqhrkhZn55uLScrc3QJzU7Q1zhcr84sppq9dq9x0vyBVK47GVLxUTSpIkESRekoWtrfvpw4kZPnvjGUUWrVFv5dIFkoQpiSa2labx/MKcpquUpqPRUFVlksYpiSFiACFVlXmBU1U59N1MtRLGkSzLGMPEd1MSh2GIGANRBBib+nUYYwAjCGGappqmAZqCNJ1yEAQeCxwHAheQCCAKBCQISOAAZBTEEfBdEUMAUhFRFvv2oMMmI42DWYUrZjRD5gVAAIkhIwj9NWvVJ9ifP3FIelLtP8UH+Ck/4lML4AsDHgscxowxQkiSJGlCKYAMIEJoHKcUcKKsIk5w/dD1Q8JgvlhlkA9jCpAgq2ahVGvOLzfnluoz854f60ZOlDTPj+fml6OYxgnJF0vjkUUYEBV1bDuyqjdm58b2hADWbrdt285ms+dWz6iy3G21i7l8EkabG5u2ZWGISJycHp/ceufd0A9XFpdFXrxw9vx4OFIltZgvbdzbEDnetSbzc7OmbrRPWytLK74bjIeWNZrMNOYL+UqvOwZQUFQDQK5QrIwnru15Y3tyb32jMTsXhNF44mh6hgLc6Q51IxdGqajqFOKD01NRURnCqmHmSmUkiA/2Dyqzs3YYnnS6/fGEIZ4TpdN+H8tqCnGQ0pAyx4/K9cb88src8lJ3OCrXG8OJOzO3uHNw7ATRlHl56fJVjpdv3VmrVhvNuSXLnhweHWuGPhyPwjjO5XKNRmNaKSH0g/Pnzkwm41xGP7u6fO+N12rzTcPQ0jQWOGyo70sye24YeH7gJkkkCzxgFEkCgIxX5SgOgaIEQSCKYiaTGQ2GHIfjKACqFIWe7zpJHGFRgJLEGEuShAIGESJhCNIEUBZ7dhy6kCWxbwOWgjQGaQooBRACjAAlSehBxIBrA5AWNAkmnjfqUM/CSThTzOY1ScYQM4LAw6U/+ey5ofCpjv/PCx/c24/f5KcTwBcEDHEcDwHHGEwTkKaEEAYYQginKWUUCoIkinIQxJ1e3/ejTCa/sLCsaWYuV1xZOXvmzPmV1XPlSj2M0jBKFdUYjW3ACZJmZIvlMKUJAYGfSKrWnF0cDMdxlGqGfnx8XC5VLcseDAaqKiuiZE/GURCkURz5wVuvvfn89RsXz18KHHc0GNujMY/5Zq1h6oYmylEQDjv9aqWytb4525hJo1gTZUjoyy/96MK58zzmhv0hI8xzAoGTPC+MomS20YxCEvhJqVj57h/9sWFmzVxu+8GObmbCmIqSOr+wopkFWTffu7NRrDbml8689tY7lfpsoVw1c4WTTm/pzBnLD41CsTG3uLV/uLV3yJAARZlXzYHt86puJ2lAEK+a5ZmmE0RhSt+9cxfyIuCEbC6fyec73b7jBetbWwvLK34Q/+vv/pE18XQjoyiq63srZ1bK5fLu7oNsNosF3O12a7WqLEoQMcdxMId81+t2uwiDxJlkDVMQBEkSXNeN4oAxhjk4Ho9lWVQUZVqKB0AWBgFgxHVdQEkQRxBC3jRt2waynKYxUDVAWRIFjBGg68AwIMYUMEEQSJoSQoAgAA65ruu6DmUJAhRAAtKYBQ4JXcASwCHAIcQoACR1xoAmoqmrPEjcSepOQOgZhpqVBQlDDjAI6HR0oPQpC+hXAp8gBvvISfgJ5cQ9qUn+SbXzkajIz9zs40tNfPINTdN0KmvOGIMATiN+jDHAONdxBEEiKZhYHs/JHMf1ur0wjHXNQJhLUpLNFeaXFnks+L6vqNq8kZnShCa2O5rYnudNXEcRpSRN/Sh2R2Oe5zk+UFQ9jiJnPC6WimEUcYLI86IgiaaZHQ770zIyhUJBlTh7MnKtcT6X6bZOn712jUfc7bfekWU5jmkul+MZfPHLXz09bfuBO46CWq3mjiYCQyilAsTNeu373//LM2fONiu1P//zv1xcXLRsO0jDyI9su7+6uHJ4ctxp96rV6snR6cryciZf+Jf/0x9cvXp14nmd/uDqlSt31req5ZIgs1wJx4R7463bkJMLlRkvAZHrNeZXhmOPAF6Q+KHtYkmfWcxMxiMka06YlupNy0swVvIVmRNE3/U0Izex3alYXhglxUJubf0+4vnG7MzRwX4Up7wqx0lqZs2jo6Ot7fVz55c5jguCAAAQBAHHcZ7nFYu5cX+QpmkURSmJFF4UBE5RpX6/DxGnaVqchIQm5VI18HyMIUKAJinGOGEkaZ8KHC9pOgC0XC6DXE4UJCBJQBSjOACAGLoaHx+KqiKaWuR71v5uplQCc7NSEPkH+3EY8TwvJDEQxFy9CoIw9P0kIWKaCsUiDClIk8moz4uyMjuDSQwY4TgIfBcwJgs8JpSFLub4tN/J6SYSlL3OsO9EAKUQi5RQhOC0i37iUv1Td+dH9/6ffO4+8ubfHJ+1MfHZj2OPdyv+2uv58L394OCnFsBDfH5sT1EUMcYIIYzxNFMfQshxQpqyUrHOc4pt+5Ko61omiVkcpzwnAYCCIGl3Bvc3t7e2HownlqoZoigTwihBsqKZmYKiGdl8ea65oJt5SVbNTKE+26zWm4KiRgTElBUq9cHQerB/GMYEi/J4YncGgzhNKGPnz5/3XbvXaU+Gg7yuu6NRKWMYktQ5Oi7nMpgSUxY3bt/+6nM33vrxq/fv3E489/zySlZTEt+jke+Nx5VcbnttvZLPzdcbb7/5pinLNIl372/VyyUBIIUT9rYewChdqNfd4ZAGwZXz59+9+db8/LyuKWtra4IgTix7MLJULQN5iUKMeEkxslomH6S0P7RSiHcPj7vDsRtGhXK1N5rUZueyhQoBWDVz/YnDK2ZIwCSIAgJ4xRA0fX5pOU6YKGmipACAsrlCpzeo1+t7+4elUsnIZF9++eXV1dWvfOUra/c3po6XcrF0eHgYxykAIGfmwjAsFIrHpyeVco1SOugPS5VyGIaUAIz4MAynVdimytuj0UiSpCRJeJ7HHMdxHM/zlFIahiCOEUKgN0gpAWkCEMrlcl6/L0pSmkQAAQARBxElie/YYDQESazoOifwkiQBxIE4AmEIABB5nkMAYwgYAxhhTTUNk9IUjC0Sx4CmgOcBI4E1ZIErqIoo4tAaJL6TBg6JPJjGkCWAEg6CaccDn6fn4ik+CzwtBwHAp1nd/HwxLe3L8zwEcKrgj7GYxCkGUuS7oZfKinR83F67tz4YjBoz88VisdForJ6/oOt6Lpcpl8v5fH48GHe7Xdt2AGBRFDu+lySppEgpCfwwTlMiyiJhzAvCOEo4zPfHE9sJKeU4Xo5SMHZ8TRFMXVdlyff9Ya/XKOd10wQkpqGvZc04cDAJU98pmdnDw+OcJrPQ758eLCws5DSRo9HOzs6g35EkcdK3DQkd7W4Xi3mQhK2D3UKuOOl1i6buj0anp6eCJGmaJvN40GtJHFer1Tbv3Ul89+yz11955ZUkjs+sruw+2FmaX9zb26OEVEvF4Xgiylomlw9CXzVzJydHjeZcrVLauH9vZNmiKMVxOhkPytV6lAJekKIkxZwYJKGmGBMnyGdzcUIBwpeuXN3d3a3VZ/b3D3O5XL5QSqMIQthqn16+fFFTld3dB5IkyCIncDxGiBGqSHIchrZtG4bB8zwAQDP0o4MRQhyDHCdIgiQNBv16tYLNjLu7l88U/MAdDofzK6ue7UEIAWMQIB7zCY2jKOIxx0ki8T1BEBilECHTNMbDoVooKICBOAI8wxyaFtdEvZ6kGUDgRVnBPA8oDaMEklTkBYghz2OSRDjwACWA04AoUs8NXFdWldALJMMAqioxP/Q9kUKkm7osxjQGJMUUcoAgRtm0ciRCjNDP23PxFE8cj6UG+mTyAD5vLqCPN/iztfz4LqCPH//Q/ToV7MQYQ4CTJJnabppsnp70Tk/blDKEKM8pV688V65Wb9y4ARgSZMkwNUppv987OjrZ2NgkcToYDCzLikmapmkQhhBCQZYYYwlJIYQ0BIQQx/fSNEWIs4cT08zIegZyYkpiRdUlmQ+CIKPJB7uby3Mz5bwZu5P24WmlmAudse/7WU1I/QkVORrY58+evfP2a81aYXGmjDA+2dvcWrvLc0gqFVLPOd13JUzyhrK3dU9gqSoAa9SfqTdu3brjB0G1Vq7MlAeDQe9k79y5cxKKN2698dxXvjpoH3VP9r/2ta/ldfWUw8Wsubm2Vijk+r0eY0xXc8VicWyNWq2WZhrlYr7X68RhZMVBNqN1Oh1dFur1+snRUbFYPjg4qFZqhGFNMw4ODgrZ3Ob97Wwmg7EoCJKiqK1299rlS71er1qtChhYw06pVHnnjdea9cry4vz21kalVF5bv6PJiizLGGNn4l6/fm13d395acVxvChKcrlCrz+UFEMQONt25ptzwLY5jkuShOfEKIoAhFPR1jSNOYwFUeQ4nhBCCOEoxZIoayrECGAMIeR4BGgKivn46EQAAMiyxnN+EPtBkDCgajqvqDRJ0pRCjAEAURJjBKYqsAAxQAGIAoAFjuMoYADzGBMSBBgAqBuy59rORAGQq80IDAMeKYiXREGMqA8YZYQB8AFB5FPGaR+79z92ns2TaedJ4TM/788lv+GpBfAQn5/FDsdx02SfaaUXjDEhhKQ0jYhjx8VCLZ8vUgZkWZ2Znc3ni67rtnqd0WhEaUpY6vmu53k0JRIvEkIQzyFGRVGUZJkQEpN04ti6YciyHKVJmMQQI0aAHwTZYkWT1Ylre1EqCIJh8pTE3eFp7Asz9cbqyuK4fdxrH3OQ5VTldNwTYMoYVVWp395ZmK1Ohscc8CuFRvtou1ytTIbHMp9IIp+GY02CjmNVi+ZcI7++vq7wKKsJoUM6x7uJP1qcnZUVIbT7naPtvMKhyNq6c//sXDmv4B+89OMbF1Yb+czp7nazXLj33ts5XZIQ6p2eXr9+HWFgjYYTa9Rrt/7e7/7dzY31l3/wl/Nzs7Pzzf3dbVFAxVr5YOeBqiiB6wBKFFlybS90nUa1NhoO05QmKX33nVurZ5a7nf7sbHMymQx6ra9+6frJ4Z4iCTvb9+vVYjZnPHiwWamUaBoHrkcFQVNlQ9NL+YLI8/1O9/z586enx/lC0XEcw8w5rqOqar5Y3djcFDhucXERACCKEgbYG4yCIEiiOEkSyjGe5yHmOMTFcRwEoSxKGPHT8pBxHGcymWAwkLMmxyEAIcAYCJKCBeq5/3/2/qxZjitLDwXXHn12j/mMOANAgABBMpOZlVmjVFcllW6b2nRNsqt+bdN916/S05X1ILWsu9WmUpXq1piVQ2UlSRAEMR3gjDGHz759T/3gICsHMpVIgZWkisvC3OKcE2f7Do/wtfda61vfZ6zVWuPAEY0AazzPA6WqLNVKUz/A1gJCEATQNkZJ13UbpRvRuEmvWq/tOg36GKI4ZtxIa5cL1J+A1RxTlxJGCdLWaoPwC/bxL8598ZV9HvZVBPDpY/4Sg7/CCKDLwAohrEGdR1DKUESvH9+8fv01x/HOzs8BcF3pHzz90WhroqShhLdgdSutgSAIOOeb1cZhDDNKKVVaG2PyqtxkKeNcWZOVRVbkWms38CM/8RXChgkFrTScM2VMI+oocPeuXXOx2RlGTx89NnXmEDzsja4ungcuQ2Aa0cimGcSU4mZ2/uTOrZtVtdSyaQrclIskANclSjdRFEmh4gA/efhuErqU0unp4ygIzhfTrUFwbTuZTqcGCQcLnwKH0jbrpL99/uSD7b4fcrO+OpVS+wStr84nWzvTs5Pf+Ye/yxjL8/ze/fen08t/8A/+AbH64vSkF7imFRSMrsvXX3/LytbKdhCP33333es3bjIEZboGJb/xa7/xp3/658fH199///04jDw3SM3ad73NehGGIQAAWMZIGPlfu/P6n/7XP+wlwe7O5L13fzQaDmVTU4RlI3zff/78+bVrh8vlGgBvb+/fu/cHX/vmtx7+yZ9sb28fHl3/g//0QS8JnSQpFgsCyHMD2erd3X0llbXWGKOkYWC7ar8QwpYlYNw0jadaQpDr8svTM2/Zw2EIYF+UBBnxPE9bjCkHBAhTzDA4LhCJWW3bFgDm8zne0NHeNQCiVMujmGNd1YIzwR3XUmOFQBaAOxjppq4dViDEDMUEAUUYWYOs7jqEPvW++CoC+Ds6799JBPBVEfhv7Quy2dFaI4Q6Sn0ppeu6SZLEcW882tnZPpQtevrk9Px8ulis8rzw/eDp05PNJgOMOOcYY4OgFiLPcwBomqbjI+Occ87jON7d3e31esaYoiiUUpxzx3Ecx/HDoKxl02pEnK6fwAJOkuTmzZuj0Wi5XJ6dPuOUbo3HnOKmLEDVyDQMGtWsx30vXZxtjwKfW1mvDvcGTTFnqPG5danuBYxaEToWdLWYPmdYMiw3q0stiyTi46Gv6hTrCpty3HNj3wZcbw3d9dUzVa2+/vr1bH6ezc89Yk6f3N8d9crNwnfI3qR//vzp1fnzMl0Rq3fGwz/7P/64XC8P93ZAitnZ8xuH146v7VrZvH3nVrZaqKYaxgHRsinTva3x4uo8CdwwDKuqGo1GhJAoisqy3t/f55T98Ad/nYRRP+lNRuMPH9xvZfPNX/vGs6ePm7JwGR2PRqJpVstlU9dlUQd+dDVbIMLysibMMcooA8zxWmniOB4OR9VqXddNWVa7u7ucsbDXF0IgRAiiSkrZtggRzl3GHKVUp9gDWRZFUdu2vu/LdA1GgbGgdcft0wEEtNYgjRv4PIgAMCBww9ALAqOtsuby8lKWJRDStK1VqkMTiFYBIoxzAKSrCvIclHZ9t6nKthFWa4IsJp8wBHwKYuSrIOB/PPtqAfhp+zv9lndU2y8Mvzg/EEY9SlywnDGv35vsbB9sb+2v1ul0vnjvvffeff+9q6urhw8fPnjwAAB830MIlXmxWCyKomCYJFEUx/FoNEKU1HVdN01d11lZGYuSuD8YjIIg6veHr924devm7SQeVmU7m65833ccByGEEOnHvb2d3TiO26Y5O312evL05s0b/V6oZb1Zz/b3J5v1QrZ1VWTjYTKfnnFmr+2Pss2UQot0na+nW8No3A84Vg6xqtpEPtNN9u137rblenn1/LXjbdlsdJsPEtfI4vrhVrq8UiK78/p1sE2+XkxGvZ1xH3S9tzUkINpyvVleulzHIf69f/CtP/j//fur04/mV08nA+83v/XWX/35H5589P7No12s6+1h5HE0HoSXZyfpanF2evL40UfbW2MwBoFB1tx94/b3vvPnu9vjIl8N+vGjj+5FPpWiGA+Co2tb588fgq6ePHz/8uLE4fjZ00d7ezvvvvtu27Z33nxruVwTyqezWSulBRgMBo9PnirVaq2fPXt6/ejg/PTZaNAbDHsnJ0983+/1emdnZ90CPN7fl0ptZoumabqoTmvdti1CiHleGIQO4ygOW9GIPIU4aJoqmQy1NaYsoW1ASzAWrAULVipRVloq8HzwfdAalIUghDBSRu9eOySUU0rBda1WTVWCEgSDNx4VdTObL4wxpPsvUQEYYiTVkoFyMHAw1CrQLRgNFllAHUMQth1V3AsJye5PPykZ/FXfwJfSKP6Z0Mqaz5Iu+/TP+OU95quRRrMfNyv+gvh9/Fmw2h9DIXfj/vz5fHbfwEvN32ijOKMYYyl1K5S1iBKHUt4qnWcNQqQXbw0GY4TQg/tnT548d1gi21NOWW/Q7/V6rus6DuOcAnKurq7atgnjiHECAFK2ZVnGcRJHPUYdAxYhxKVuWrHZZNPZYv/wgBJzdjrVWktjqqoimOl6NRgMDvf3lG5bUQWh2xTV8vJ5L4iGx4dS5JmqfaJ6fT9fz41tEOJBEGlte72elmoxu2SMDXcGq8XFwd64bYQS9SiJpJQGY44hGCTrq+eO1UkvIKoKHBs63LaZ77OTk48mk57neZdX50KIwWgYR3F/NJ7PlqLJB/2AUjJsXSXX1w+v/fAHf6xFwRkzuE0Cz7QrLZav35gkganTdmdnWNc1wZozsrO7pbWO4zhJkv39/e985zvHRwf33v+bps7DgBktIh8FjivruRGL4Xj7o3f//M7xZHfAZasXl5eq59y9fXO5XFZF+Y/+0T+6vLyKRsN1VRrGBpOtNFuH/WSTb964e/s7f/5nW9sTa0hVSmvU7PJEiqIRFeW0aZumbTBG9awBgF4v0lY1rej14izLkl6vbWurhNba87z8yVOklOO7kOXxaNRkmRv5wL1mnRKlWc8FZUEqphFGNF8tfdHw7W3wnOJ8FqoA4ghRIlpx7dq158+fHwauS8CIEnnMpVRsst54kk6nRVEkcQRSiOXK8VxOqSo3FtFBPNaY19ONqCvrU00cCxSBAqOJfUFXbgBh6mj88c2EDFiLwODPXgA+6z4iL08e90rsv3lf/5R1jTifNtDLrXmft7jYS0tOGgsv1wj2hbQvcwbQtK1ACGNMfd/HmBkNSgFCZNAfhmHcCj2brpqmxYi9fvPNwO+VZS2EIIRYq8syz3MFAGmaMsa2tsdRFDVNU9e1AeRQPpsuyrIs6wohhAiz1ipjAaDXGzRlczmdXV5eWoQdx+kNRvv7+xRh13Gurq4YQ69dP55Nz589fjoZhgjJzXLNTD1JHKvb+WJGbXt8/WizWod+jLBt28ZxnF4/ko1YLqYUE0YRYtgobaUk1jqcMkqbMo08B/lYCCGbllPiug7jtKrqXhLGUShk21T1aDK+PL/CGD9/+sQN/CQK6rZuC41xG7gBIXLU913XLGfLG9cPXeY+efbk+v7uzs7WcjHFWKXpfGtr6/VbN7773e9eXk6//vWv37hxw/f99957b3d3d7lc3rt3cvv2LWvU1eXp+dnTd95+oyrXW+P47NlH2+N+LxxOz5/vbY3716/N57PDawdtU+/t7L733nvH129gTP/wD//gX/7Lf/nuj/7m2rW9xWJhQCNk4yQa9JLVejEZDVukh4OEM8wIlGVJKS2Kwne9oigch2HWB4CyLKsq4JwDMnmeY4z7wyE4jiPERspqk3JOqRdb0Ovl0nMDxhwArDYppRyoAwgRgF6/Z7RKH34UxUF46xZkmVwu2WgCVaGU6thDnZ1dWM7z2TTsTzA3YMFxmAEFugVGHM+BpgHqUMqAAGAIKE48LpXNVUu9ngYEWoOFF3LxL/ROAFmwCH+y6/853v8r+8Jat4Z/ygLwWSveF7A7/FeVnXwl56WUGqOtBWutUgohAEsRkCQJZSvX6w1nbhzHQWBbIZXspGjrNM2VUmHoD4fD4XA7juO6rsuybES1XC6rquqKikVRGGMJIV1ihzkextgAAoA0K7TWw+Fwe3vb9YO6rqumNcacX00Hg16cJFKJZ6dnjJrBeJRtZrFHtna2dbW+uHxKZLU9jB0KabpyHKcsS0ZxFAUEULZe12WFCWKMMcZAG2tt27aO47iuC2DrUgWejxAqVQmAOhB91dRC1FEUhb538fjc9wJGKAZbV0VTl3ESWg2iLilm25OR7waEoFyKwHNML6YYWlH3k2gyHoqmKvLcWs05397eBmQvLs8R4CDwlFJ1XZ48e/Jbv/VbHz2cF2V2fPxb1trlctFPot3d7bOTJ7HvBJ6zPR7VZVaVuTFDx/FF3Yi2dlzmu/yvn54cHV+fzWZ37tyZz+eMsTAM3/vRj772tbsIoX6/7zjO1dXVcNgnjHbArV6vX5ZlEASbzQYApJSUYqA0TVPXdV3fS9MUAOKop7Uu8zzwvK6rYL1ex3EY9fuMOot8pSSMdxMj5Hqz8f3QDxlYCxibusLjoS+aq4uLsZQsipjjQNMAQq7rhkG8nM+He3tgh2K5wlWFLGWMuQ6VGkNRgu9CGEDdGkswRYAQaMUISTy3FrKqBAJtEHshQ2ExIASIYIw0AIB58b3v+KMtRvAZeYOv7Ittn4ICetlQ4leO6vkF3fErRyn8zHlf6gzo40ZfrKRpWwWgA9+No37TtF1dlhJXCCma2hjg3APAURS5rksI4ZxijKuqyfN8s9lorTEBAOCcB0HQEcZRbQkh2poOVliWZVaUbdsqbZfL5WqTep432d6JoghTLoS4devW06dP67pOetF8epVtluNhsndwGHDYTJ8V69RzgzDyrG3rShDCjNFdu7IxpsiLxXLOCB2O+oxQ+LibwSBDKQVAUjSu40gp27a12sRxrxfFbdtWRckZ44w1VV1m+Y2j603dREGw2mxGwwEyZrVaVnm+v79/bXdXa71er8Gq1Tzd399v29ZofXxwsFotsizrRNIPDg48z7t3717TNN/6tW9rrZfLedO0SRLVdbler3d3dzfpiiK8vztxHdZUpevxsshfu35QleV6tbpx4wZDSNTNweF+mqaj0Shdrw8O9j788MMk6X/ta2/90R/90d037sznc631YDBo6ro3GGol60pVVdPrxXlWpJtsZ2uLMRZFYdM0Sqk4jqUUoJTjOJzzrtRPKWVJAmlalFmQF4jSOI7X63Vdi0hK6nlhGBoDQLkuWyklIQSsFXXDXGedZkOXs/29SJR/88MfHhwcbN2+DXUNoiWMDbe2Pvrgg+HVHIa9QX+U143M1hQBj0NGcJ1nHsXgh7pspdHMNUQpLWrMUODgiMO6FLJtDP1YjJTg7otuAAOy2CLT9YtZAASoO37O/uFV2Zc5Z/AqrZvPl74P4MscBGBjFABQSinlCGgnwkWp2wpTFrWUhbXI94LJZHs82nn3R/cBcIcQrWvRNFWapkVRTCajMAzDMKzrerVeCCG6jWQcx1LKFwuAMoQQwriU0vWC/f19A11miDPGaiHTNL3/0YO7d+8uplcPHz48Pjy48/prq+U03WysR6QyiDKCDGFALFhjrNGg5fZkS+n22bOnTVmNxv0oCBtRcY8rpbTWBONuhcAW1Uq5rivqCoyNgjAOI7BWSckJjePE87yHDx9OxsNeHC/alhFCMYoDP03TpiwC1xn1ew4laVm0dRUH/ma5YBgNJ+Oqqqo8yzdrzhhQtru1HXruejGXTb01GvaTeLPZEASB54yHfYohcB2PsycPP9re3r5+fHhx9uz87OS168cltkqK6dnZZNTrRfH52WnguUkU1EUJ/d5yOb9x887/8Sd/cXh8/f333z88PDTGPHr06NatW3meL+bzw8NrbVP3h0me56PRqKoqL/CLqnI9j3MniuKyrvb391eLZZGXe7dvn374YXF+OZlMWOCDaPI8j+N4k6W9yTjZ2mmEaKVsstzt9/vjSZEW0DRVUzOHO74PRkvdOsRhjJyfPNnTKjo8OC6qy9lVEHjh9etglBUCDUZuEM6vpmOCcNKLaDmbzRSnPAnAoWqtQEgICHF9qSwgorXUorYWPOrEzCQcTZtC8YARDJR2jsJYq63BCAOyLxALANgAIOjExOwXy8V9Zf9t+5QI4LNSPZ+VGvqVRwDwi7njzwOn/JPnfbkIgHNellLr1nWo47ha2apqqlJsNsV4tLO/fzgYTAimaZqfPj9/7937y0VGCOtQgI7jhGE4mUx2dna0lgDQbQ+jKGKMua6rlNpkhZSyamohRFE1RVHUotVaB2EchmGU9IQQ5+fnVVVVTbter3d39x89eoSM3t7eDBNDFwABAABJREFUZsw5P7+synUc8IuLi6O9EU+82fOHy2wzTjxGaLop97dGdV1v0pWU0vd9z/MYY8ZyjLGoaoyQ7/tgP/7OGMsps5x3wsUIkTIvtNa9JOGEa6mW8/Vv/vatOs8cRmZXaeS52GhO7Pa4PxgMRv2orrK62Hgc5/n67u3XAIBh09b5fD7f3d1tlUEoGI1G0+l0tVq99dZb0+n02bOnjDlRFDmOU1VVGAb713bTNMUEHE7Wy1mRpy5nebrxOSuznHPuOe5mtS6ydGc8urq6TJKoKIogCBC2x8dHT548qcviW9/6VlNXUuowDJfL9cXFxc7OFmfOYDBaLxdN0wDA1tbOs6cnQRAopRhjRZF3+/08z8PjwziOF7PZarVqmmo4HnPOwWIpJVgLcRwEUVFkRV65YQKOT2lTFEXTNJ7nA0VWWEIIMOJ7jpL1/PzZ2H1t9M7b+gc/ePjhg5sA4e6uriqq1P61a4vFYn4xHW9t4V7sr2dI1dDWwBzHcVoluVTg+UxoIBi0sdASQ7BFEVYDDy8KgTQHRK0lFiODANTH310L8HESuUsBWWQQ+vROmC/mzvfvz3l/fkbnJWoAX1j7kgYBL7T9LLYWNU3TCoMRc13/a2+/MxptEeycnV08O3leljVYbC1WBqIkHgwGnudxTh3HoQxbaznneZ4DGMYYrXmaps/PnkynUyEEQog5PAiCKIqSJAFMCCFK28vLy4uraVmWeVkNBoObN2+GYbhYrKy1BOzp2bO/evqd7cnw4NrWYrHYGQ6LonCQGAwGFVaz2aVLYNwfMsZOnz2rimwyGYVBUJaZEu1w2Fei1Vp7rut5nqiElhIwpZT6vk+75lJjjVFWaQxAMSHInp+f7e2OKUFlVUqtqiKfjA8ogTgMOedJkmCEqqIwSvX7/dnV1bDfr+t6MZulm43DWBQESinieKKpVst5mqZJHLaifnbyZDze4owYLV2HgdWe42jfD8MQEzh9fsIZ7g372WbtJiEC47tu0zRIq62trU6k9/rx8UcffXhwba+VcrI1/uD+h4SQDz96cPeNO3Evmc7njss836+qCnu+1howqZvWc1xrrbVWSq2UMsYwxtfrje97tWj01SwZTRBC5+fnWZYNrx36oUnTNaVU1Q11XUppFCVVVYHUgAgAblvV9WC1Zam1ppSDBTByMBqWaVpPrzxKtvZ3i6J4/PDBHc654+g0JUnSU3qxWqZpmvhuHPqiKqBIoT/kQVCUtS1LJ3YtBWsAkMYGiG6QllyrmPGQYyDIYjBaSUsBI4xJt9sHAGJ/Er5sv2RO4yvr7CVQQJ83jOm/075sCzsu8opS6nmeMTbPSq3t7s7k6Oi1Im8uLi6mV8v5bOU43tZkR0o9nc5u3rzp+2HHLSOEwBhzHjgeS9N0s9m0bSulWK/XdV1zzre2tsbjMQAgghFCZS0Wi8VysazrmnH37OzM9YPbt29T7pRluVgs7t27Z62N/EAI4fnOP/yHv1Nk69VysT3q1XXVDx3StsvlGslmd3ffxdCUm/l8jhBKksTzvI64ghLSwduNMV2MooQSQmBGGGNBEFgli6Jo25bzF5Jeoqr9fn92Ofuf/+ffP7u8iPzg7PLCITiJQqtbgwxFSKtGSiOaAhtwON4Zj6ZXZ0mYaNUkgc9ctpxe3b77Rl41F1dTbAEhtJjOLIJeFFOKKYJ1nt268dp0MS+y1fberlV6Nps5nOhWFFnaTyLH4U2Zbzab3cmwKIq93Z2Li4u2bQFgOp2Ox+Plcr0pxO/+7u/+7//7/7vXK37tm99gjBVFkSR7N27cVKptpKrKOgpjjCmlPEsLx3GUUgjZDuK52WwGgwFjRZ7nPUp93++qC123HmPMalKWZUyIMSYII6WUMRYJgRBGCHPOjTFpmlJKo4iBbpEFXVfBYABtWz8/9bYmN956++m99589eXrzG+/Us0Xo+zwIAtE0TZMUBfguFJs6S70wAsfRWdGUFfVjY5C2ChnDOcfKGiOI1i7BEXcNwo2xyhhtNQAFggnGoCUGgz5B/liwLyCd6KtugC+dvYwo/N9Ja/IvPs6vaj6vKkLqmIG11k0jEEJJ0sOYTq/ms9nSdXyM6e7uLgJ2fn6Z5/l4tP3GG29897vfr6pqe3ubUmqMEULM5/O6ruumzPPcGDMcDre2tgghZVl2iaDFanlycjKdLwGAux7nnDvO17/+9Vbps7Ozs4vLoihqIZumefPOG1uTkZQyTdM8TTlnURTVTRkQGA2GT+4945hYi8u8UNha2XqUIWt9PyCErFYrxnAvSeq6rqtqazJRop1fTRnhnuPe/+DD3/jNX3e491f3/vLu3btSSoyhaZqyLI+Pj6fT6WQyaJoKtJpNLy/Pzt75+tekaDDScS9aLdb9QZSJXIr68NrRoycPh/0R45QSFHjO5fnV63duQYyUaERdrxYzislkNBj0k8vpFcHACJJtE4f+9OpCW7O9NQajlGxdh/LQacoijPw4CqYX51ujEQUEAGVZCiHyPN/d3b24vPTDwCIom3r/2mElmsPDYZZlj588uX379v1773fUCFJK3/PG21ur+QIj8v69D958624QxqKtGWOiEa7r10JcXFwMh8OyLNabNRjb6w2klCcnJ3t7e7P5ejIcMU7rqvKHo/XlNI5j7AVNtmma1vP9q6uro7t3Z0+fUsa0MRSDUi1jDLQCz2FSnj98EEfJ8e/81smf/2Uxuwp7A1lmstXJcJhYOzt7Pom4UZL7LhgDYKIoajTabDaD4YQighBCyIKVSCloWwmm3+uL1ghpMaLYcRHj1iCjBUUIgUVgMViwxHTJT4SN1fZVaYZ8mr2q+/dlN7KfuSH+jNd/ln/4Oeft/tQdP+kuelUb8c9EdUoN/wMUgb+8Nh5vpWnaNFUYxJTypmmXyyVn9XA4KgtBCV0u10XevPPOO7duvX55Mf23//bfRlFy+/bt7e3tjuMhy7LNZhOGobV+FEW9Xo9zWlVVlmVa6/v37wshtDWe5924ccMY07Sybdtef/gnf/InT58939/fHwxHUsqsqELPR2Dm8ykYQyl1HO65NOCIIo/q5uryfH937/zkAdHG8922zreGw6cPP0iisG1bzmme57du3UAAVul+r2eM2Ww2TdMkUa+qqrfeeuvw2sF//I//IRn0HcdZLpc3bhx/8MEH4/G4Q0kyxmbT6Wg0ev/8/PBgX2sdBD5lMLuabm1tqVY+efIojmOErBTteDxM01Sp1mF8b28nCkIhhFLq9Pnz0WC42Wxeu35DCDG9vIrjGGMUhmHH5t+IyhqEATCxDqcELOc8CYOyLPf29paz+f729uXZaZL00zQbjCaIkNVqsbWzN53PoySOoqgS4vj4+NGjR5zzxXLpBf7V1dXNG8dBEK1XaduqLkTr9Xrz+ZxTMhz1lVKTyWQ+nTmO12kDIISbpqmKkjG2u7v77Nmz+/fvu67LrvnlZsWYs7ma9cfjxdXVKOm7rm8tqqoaYyo3mziO8yIjFOdp6jkcAMAYaCVCqBfFBqD+6OHRzZvPHj3yuMfGo+zJE0op39/vZStrhEVYaUukBMYwRS7j1CUIAVgFFlkAZCwyhiLwMTKU9KmHCGyEqVpttAKMrDGYALGAwSJrLCAAbBE2X1WAv2z2PwgK6Mtri8ViOBxxzjfrbLMpPNdPkiFnvpLm/Py8qeXdu2/duP761dX0//5/+38ul+udnb3Do+PhcLjepKv1soOiT7Z34jh0XRdhm6bpxdV0tVrVda21FkKMx+MgCquq2mRF27ZCqrqu//Mf/GGv13vnnXfCMFys1lLKyWSyv7vNEEjZ+kHgB65SbVXWkef4DodWLeab4faQIIhDH4x0KCvLsuMzoJiIpomC0BqDLHS5oE5HXmvdQV23JpMPPvjg7Cz/tV/fSoucOny+WrZa9YaDy9lUtI3n99pWMEYJwaPRAAATghaLOSGEMfb48WPP87a3ty8vL3d2dhhj1lpKKQCEYdidRRsjpeCMhoE/6PfOz8+NVgQjxgglCKDbsDKtrbXaItAYENikF3W3QddphQnNsvLG8fFsfhWEUVWXGixgBJhQ5tStqOs6isMwibIs45wbrafz2WAwmGyNqqbWWlNMW206JbVgPLIGiUZypr3A9zwv26TrNO0nSderIWQbbt3Y1/bs7DsY4ypNg/GWTFPf96usiKIEyhoQoZQrlSdJ0jRNNB7PF7MoigAMYGIRAsZBayV1EERAyWI28+I4SaKyyqMV9OIQUwx5ysdjKFIPEW0BtAGsNGCLNSWkFSUhjGAGCAOygAAQwtZS1UZehIgjTJvXWhqNGcWAATSA+bFsDzaALQIA/Su7l77k1n0f/o5rmS8WgM/vZF8EdNBPjPOKesk/ez4vN77juEKIPCvbVvV6vfFoW2u7mG8uL2avvXY7Cnta2Xv3PvjRj340ny2vHR1fv359NJ4AACFke3s7CAJKKULIWn1+fj6bzSzoMAwHg0GapmmadkiYp0+fSiktIlVVzZerNE1///d/fzgcCqmePn0KAG+88UZ/OGYEeQSfPn9itOA0SIKYUdRW5enJyaQfMoJPn52M+3GIYTM/68fB44cfHuxO8iLrxdFqvbh+dPzs+ZPxYNiJllRVZcyLRrDJZFIUxR//8Q+2d/2maVar1Ztvvvn973/3tes34jh+7733GGNSyt5wNJtdDYf9qqriON6kq6apBoNBF+vs7e15nlcUxXg8Xi6XCKEgCNbrddM0eZ4Ph0MA2N3aXmfZeDxerVZ5ng8GPSFqx4mzLKMUU0q5Q40GqYxU2oImhMZxnK43vuednZ1tT7YuzmdNq5jjcMcry1pbEyf91Trd2tra5FkxmyVJr+vtWkxnBwcHq2Xqed7l5WUURWEYrtfrppWUUs9xPC+glDZN00U8u3vbTdMkSSKE2Gw2SZJwzk9PT5MoppPJ1tZWVRXvvXfv13//HzPG6lpkWbZ9dAOapiwKSikhzPd9IWoAo7VUqg2jqKmFsib0Q0BQ1zUhhCbxcDjMV6vQD6qqWixmo8EYcQJ1BRQDdxEiuJXKAgWw1mrVUkrbquGcExcDpWAxSAkGWaurzRoh33FdhzJOkEaEEEYxRtYgDLjb/Xdfe4QsYAz6J8iB/tv3y8vZlx1N9HNe/7NZnZ+HZnyl1/Or2v2vzDjnWZZZa4+Ojsbj8dXV1enzc0rZb/zGb7mu27bt06dP/9N/+k/Lxfpb3/r1N+++PRgMOt5g3/cH/SFnTlEUy+XyyZOT2WxGCBmPtlzXraqKEHJ0dLRarU5OTmazGWOs88u+77/zzjuvv/76fD7/67/+6zzP9/f39/b2XNdFFj56cD/wnLt3Xt8a9zfr5fTiHIze2Z60ouEUWy3jMBB1yQjWbesQ7Hle1/MFAB2/sda662reLFdStBSTdL1xGL+6unI8GI5HRVlaAEKp63vjrUmaZwYsokRZgwis0w1zeF5moq2Lotjb2xNCZFk2mUy6asdwONxsNlmWMcYIIW3b1nVtjOGct21LCLFKu4wW6cZlFLQJPV+3QrdCtY1RLTIag0FGE7CcYDfwAYAxp23Vcrnu9QbnV1NMGGBKubNcbSh3Rav8KC7qChFcNTV3OQBIKd3AdxyHUr6/f9BRqwZBZAwAYEp50yrmOut0Y8C6vmcRbNbZarlBCE0mE6l1VhSMcaX0k5OnAPa1u2/s7u9tsmz65HFe1g8fP+4Px1YISJKyqanDuesWddVq1ValH4VpkTetQISWVa3qBigDQou6gapCCEVxkm9STmgchcvZ1BY5eG65WOhKADAN1FgEnFFKKAZgiGJLwIJRoFpoW1AWADHMZFnKvDBCOJS4rkcpt4DtJzIxHwcBFpkuAjBfLP/8ZbIfz/j/nOz/52FfRQAvP84rigCaphmPtvr9oTFwcX65XqeT8e7x8fFsuqqrtiiq1WqTJEkvGWxvb9+6/cZ8se44nDHGi8WiqiqlJUKoruvXXrsVhv75+fn5+UUHDN1sNu/96G/29/dvvn6rruuLq5nv+73BcDgc/rt/9+8QQoPReG9vjznufD6vhfQY3tnZauv8yeOHnLNBkviek68Xz5892Rn1kLHX9vekqBfz6e6ov15MDw8PyyINgqCuyyAIzs7OxuMxaCOaRrdSa+05bq/Xy9NivV6fn58fHe1prZnr9Hq98/Pzg4ODxWp5fnrmug4lhHNa17Xv+0q1vu8LITzP69oLLi4ugiAIgiBNU9/3fd8vy7ITA+iaaaMoopSmabpcbYbDcV3XURR5nvfkyaM7d+5cTS88z7NWG6OEUMYYqVoA4A5zXV7UVb/X/+jBAy+I6qY1YKnjdnmsupW+H55fnH7j177xJ3/yx3fu3CmpaJrG97yuDl/Ulef7nueNx+NOFN5a20sSxpgQwlrdfVWurq48z0vTtNfr1XXd6/W2t7fTNPU8b39//+rqcnNy0tvZGQwGd+7ckVKeTE84d7U2xhhSFIRQEicRIVdXF4RaAJjs7p48+ijLssn+IasbqRXlrNfrpWmabzYIoXB7JxK1EIJqGoR+VeRMtL7jSgOEu2DAaAkIgVWtqD2KXY8DYNDSNFJrixEjjke5EzSqbOu2rlkYBJ5XN20tWwQaYYTAIvQxLyhCgBAgQPbTGwG+aH7gZe2lSdY+w/6bRd1fcMCXPe/PLxp/FQH8yqzX6wVBsFwu79+/37bt1772zvXr1xeLxWw2a9v20cMnV1dX//Sf/tN/82/+ze3bt6+urp4+fXoxnVmM/Ci0GCFK3MBHlOxe2xdK3v/owYNHDwlzjm/cDKLk5ORkPB4nSVLX9cXFhVJqa2tLKfWXf/mX165de+utt65fv26MWSwWUspOR9DldJAkcRBgC1m6PnnyeD6bJlHMCPZdx2F0vZgTgLaplGhEXQGAlNJonUSxlLJTI5BSZlnW7/cJIZ2/K8sSY8w5R5T4QUQYzatSSDlfLqumcjyXcc5dp5Et97i1ljGmjAwi/+LiijGHEFbXwnE8zt2maX0/JIRZi9I059xFiCBEiqLqKNWiKGiapm1bIWrOeVmWWmv4hJfCaqVfFCe6snAH9Kwr0e8P1+s08CNKqRAyjBKEiQEUhPFys65boaxhjK3Xa21NlMRdxMMYq+vadX2EyGKx6Brx8jzvqiBRFCmlyrJECPV6vSiKtDV5WVRVo7Vt2jaIIqX0vXsfzJ8/70BHSZJ0n9R0Om2apshK13WhbYHzKIowxowx+Dj1Bwa8IGKOBxYBwcpoKaXneXq9pMMhp6ypSq+XuA7L0jXiHGEGjo8J0xbAgJSyrmspGsAWMABCAMZokEZbbcFAL4mQ1qIsEIDjOAQzA9Za++NYzw4NahGYV8XV+ffPPoH9fOqPn591rSpfLQCv0H4+CBr95BFVVZWmaZeZSZK+tXa9Ti+nc8fxHjx6vL23/3/93/634xs337//4Y/eu/fkyclkZzvp91zXF0KsVishRAcG9X3/8vI8TdMulfTw4YPHjx8Px+PjG9fLuprP527gd0wDZVnu7O6ORiPMaJc+6hoIwjA8ODgAwEEQJHHocFwW67Nnj8p0cbi/hY0exMlyNs/TojcczhYrzJ0HDx/FcZymKefc84LJZJKlOQAghPKqHA6HWZHfu/dYW4UpOTg66Lbq1qjNah3H4dnZWeB5169f7/f7CNu2ba21VVVZTNIiV9IYDWDxbLrY2722v3ewWm4wxlEUXV5eCiFE2zZN43peK2WW56v1WrTtzs5WR1y5Wq3W63R3d//8/BwsrqpKCKm1xogQTLsklZSyKCqCWZrmjDFMSCUa5nBEcNnUg8EAY1xV1cHx0fvv3ZtMtuui7pa0uqyODg6zLIuDEGMshKjrGiGbpiljhFI8n08ZI4QiAFBK7e7uU0qH41EHdiKEXE6vGCOEEM93e70EwCJkOefL5bLIq6OjoyzLlJJnz56FccAJWV1cQNsEvRgAjLZQNRhTx/U3yyUhhFIKZZVuNmVeIITIaLxars1yxXq9JEnEZkPiaHSwv5pdNaIC2WqltFRgLcOUE8aYA60EY4BS7LqOyzBGUtVtXfDABaNUI5ECh3qMMIIwpdQiAMAWKAAFS7DFCBQG2RUAusDgq+MX/PhJsYb+LEv+K1t8PiPyeOnQ6XNO3bzSkOqn1V0++RdrAJBFgBEGjGjn9TAyxpgojPvDcV6K5WLjuOHzZ+d33/z6ndtvRFF/Op3OFysLdmt/1yKstD55/sxa2+vFSZIYo7Uxl5fnURSNB0Nj1XK5tFqOBr3+qL9eLxfrBWOsN0hEI1ujCOVKqTRN11l6eXHFXe/G9ZtxHBPCPO4FyfDs2cPJuNfW2fz8KTbN22/ckdWGIw1KFlm5XK7qKgs958MnH/1P//C32zonCFuDTk9PEUKDQa+pCkzYaLz16MlJq+T+wXi5XllrPc9L+mFZ5RgMxVBk6WjQpxhrqZqqpoQTQhRWdVMq3fpBgCzMV+sgiiejcVEUZVnGvb4xqiiKIIylFI1sDehVtvJjv2karXRv1FtnaRCFaZFzzg92rz958iRJ+nVd9+Nos9lEUVAWgmAIvbCqyyRM8qJZzpae4zuOp41MkijPUylqTzAnYIv1Ku4nQeMNe0OMsZJ2NOghiy5Oz5GBfpxYY8oi6ye9DmDa68VbW+PFat4bJHm1Ob5+nK43m9XKC+Ioih88eri/s1vXpWjbpB8roxzsUE72D3eVbUdbo7qugyjEGIu6cV3ucto29eXzJ8NRn1Ld1jluqMvcuhaOgeFop21bz+ME2Txdc8qS/qAt63yV9UfleLQlZWPSjLrccbipmkY23OMcG8g3nDt8ayu/uIwGozCg6bpMtrcBAIQAIMAZNa1ShvvuZnqSRDt17a9nGSej2Ess1oSqOitbY63hFGNGuMZgrJC6pdQBwBiBAfiJI4Cxr+CIwFoLCOAXPpoXzNU/eSQIGwQY4KeOBCGDAFv4qSOCn/7Ni98bMADY/vSRAHrxrn/yiIy1qGPS/okjGIswwhYQxhhAW4staG0owp86zs+esTt+1vifOh8AAPwVDBQAXl2O74VAxM8EVS/G6VKl9m+HpZRmWbazs9dLhrPFRinAhD148NHR4WuHB0eU+w8fP53P52EYel5QN81iOfO8oD8YIITA6jzPtVZKKd/3AUBJUVWVtTqOY4RQVVUffvjhwdHBaDTebDbrdAMAVdmen58T7gDA/sHh1tZWHPWqqqrrOiNQZxsh5OPHj11mMNJf+9obkefkTana5r/85z8b9/u7u7ucQV6sfu03fjOvymI2Rcb0ej0AyIs0z/PVfKF0C2DH47HvTZqmMUYFQYCMXa0XyAIhmFNKCOGcd3mSLo9fFEWXiXJchxJOKQ2CCBt0eXkVBEEcJx2F8mAwWK1WQLCDMXM8jEFprY2xyFDqOK6PMUYEv3bz9dnVTCsjW2U7wRLACBHfZwS/uOUxxsjiKIgBoKoqrbW2pmmqNFtPJqPFaskYJYQURaG17ThWVdtulpvDw+OiyALPL4oi8MKmaTo+VCXaTuqLO1QplefZZrPZ3782n8+lbA+uHZ1fnCZhgBDKskzK9kYcdC3T/UGySVe9rd16scaYUmqstchqLYlWbV2WnudpqYSWXuDTMNZ1LUTruVFdl5RSigkhBBw3juMyL2bPnk22tpjjFHkeJlG5XgRxbGTtBYFspIUGIYAGe44LWhsDnDumEjiKgCFZ5cRITDAxRlSZUgSUICh0OKeEaoQZoYQhzTnSGLUAlhiDAAxGkmD7yVYSf3GO9tOO6NN/b8H+7GqBPnWEF69/2fFfzTivZD6f2FcpoBe5sJ+1lx8I/4z3twC28/yY/O0RYQsABmC8vVU29YNHD/O8VFJXVRMG8d27bwHAbDaz1m5t7QwGI0IZQjiOY855hxd23U4qIOCcdxyiAKCU6qjWMMar1WpnZ0dKdX5+3jUJX1xcdIDFKIrG4/He3l4URd32nBD05NkJc514MMSUWYQPjo5vvn7b8dyiKO7fvzfoJcNRv0P3c0oZxVWZU4e7vocIblqx2WzW6zXGOI7jb3/7267rTqfTLhturS2buktYfWJdd2J3nbsKapfLCsOw+6vjOB3kqWmaH8vjA8a4bVutNSK4lbpjWhaN7OQVs6zY2d6bzWaI4K2d7Xffff/4+LjIy7Ztu3R/d5W01nUttNZBEHTc/R0Q2xjTcbctl8ter0cIWaxX0uhO4aAVqiO0QAilaYoQ4q6DCO7yMBps3QoAcF3XWrtcrpjDLQLXdRFCcRwDAOecEJIkSffGq6oyYLd29+eLBWjNmNOdqBNqZowZY6qqllJ1IsBt2wKlxAsIoQBAOCNB4AWBMQaaxnGcfr/v+b5UQktJKQUpOefQcQd9jNQCa6GuaRQYLQHA872yygFb4ER0RRGMEIK6LuPYZ5wgZAEMI9h3OYBZr5eUYUIRxrgb0BiDUEds/pX9MvarqgF09ikooM/73F80SonP57w/8b8I2R8bz3zy1+VyqRXa3d3zvd77791Xmvze7/0e5541uD9MwjBON9nJyfM0zxhjk8m2lFKIuis/Ukq1VgihziEqpQgh1kLbtnme53mutdw/uFYUxYMHD9KsoJT3er2trS3CnTzPXZcHQXDy9Pl8Ph+NRq+99tpqNgXVcsdbzBa3buyfn5+LPD05eYIB3bp1y7T1vEyLLD843Lm4OHUojAYDWdfduYqi8DxnMhnHSXjv3j1CyGAwCIKgaaou9729u29lC/DCyXaz7XhnO9EYz/PiOCaECCGEELJttVBJkmRZVtf1aDISQsxms8Fg0OYbaxEmqCNApZRIKbW26/Xytddee/7szHGc/f1r3/3ud+/evbNer9M0dVzeMe5RQghBlNKyLMF2XRS288tN03DOJ5MJQqgRzXhrYpTOsqwjWBVCAEaj4US2ejqd7+3slmW+s70rpSSEuRjLVluLjAFKuDWorMudnZ3Hjx+/cfsOIXi5mo/HYwLWGDMej40xy8VatHWv1wuvJRjTIt14TogRwVhhTCkG5nAhmNZ6s9ns7O0qC2maczekvYRz3jR13dZ+6ANnuG3bopBSOo7j9qImTfM8H2yN8/U6Oj6oLi/8MMzWmee6gACQEVI5wdjUJWCMPVdsVpFqATChGAMCq41VCFnuOUqDknVlcse0vf5WCZuzq43HQmwsAfI5oVZenb2a1O7nTUXzUyigX5py7Ze7zl+lgF4h++mPj/PjBWEEyIAFhK01BpD5+CPGGOPJzjYAfvjoydbO7t03vh4GvaqRz07OHz36qyzNgyje3todDkee5603myiKBoNB27Z5tlmv11K2xhhGcdM0RrUA0LZtRx0cBMFwODy/uHj//feNMW+8+Vav15tNF9Pp1PGD/f19Y+F73/urtlW/9Vu/5bnBX/7FXxjZug4NPeSGvrX2/PxcVQXn/PqNGxdnp4FDe0lkNR0N+4vpc86Z+tgYY71+n1AEBC/X67Zt9/b2gsBbrVZ1VYRh2AFyPNY5XDAvxKOMtd26iJOkFwSBMaauG621UlqKlhMKCBlrtdZdskhZI43u9uCYEq1TSmkYxspYRPB4Mjk7P++goh9++CEAHB4ef/e73+WcDpPYoUyIEiEURKHj8fl8iRFpWqGUCoJAa53nOed8OOrXVU0ICsNwOp0CQBAEzHWy9QYDGfaG6/V6ejX/1q/9+g//5geEsKqsFdeu5zDGwGKprbKAMcWIdoR9tah7vd5qvRgMBlm2MQgCrbe2tj788H5VFdbaUZqPx1taWwQYEDJgtdYEYcbYJ2GQVhYhghBqmiasHbAYMCnLmq3TJAqo4yht6ro2WhqrfN8XogFjpJQAmFEHKEcIEUKsAaulUtLR2hiDkAajKMWyKjCmjsMwoVqIVkrHc7LVlfG3Ce2poszy1YDsD/u9KPSapmIIY+sSzAxgQAosAvRVLuGXt5/qA4C/Q+bNryKAV/h+0ac8R8Zag15I5yFApkt7gMXa2PF4qxVqejXtDybvfP2bCNEf/OCHj58+36wLRt0bN27u7O4rZWazRVVVk+1xWZZVVSiljJaMMcao1hqBEUL8+Bvxfd+PwsVi0QlaDYdDhNBHH33EqHP37t2ibh48eNBKdXx8HMe91Wq1XDwGhBBlYRwR1N7Yfi1dnmOMlWqvHexn6zXnOAz85fzyjTuvFelaa+lwTynZgSk9zwNgUomiKObz6dfffqssy+fPn9d1ncRhx6tclqVixGG8I4fovvFdbsfzvC5P0lUjKKWEEMIooWy1WnVUo9PpNAzD0WiUpmmSRMpoZG1di24RNRosRo7nPHr06Fvf/PbFxcV8Pv8n/+Sf/M3f/E0cx3VdcuYgsAi9SFNw7lprCSVSyu5yZZvVZrPZnow9z1vNF71e3DRNURRxHHdzM8aUZbW/s3tycnJ0dH212kzG26en50LItlUIIWOguxpKGoyp5wWLxeLOnTtPnjxGCHVyPQCAMZat5gfbo8Vis6F11Zw8eXJ0dNTUrTGAELIGKWOwwRhT7noYbBAEaZ5RygejiUVok6aUcsfh4/HYGCUayR2KGQ0CTzSoaWp/OEjYsEhTPwqbqyt3MADReGEAxlowUmtABorUYsDIgmwcxxFCINQGUQTc0XWhdOszL81z15f9JFhbWKeri/NTnlDfd4u0IJi9xF3xJYkAXvmO/r9n/F/ior3sfDr7KgJ4dUVgAPiYLR3g45owGGsNACAE3XmsNR0oyHHC9SZrhX7ra1+//frd99/76C++8wPOvP29gzu3+/vXjnrJ6OLi4qOPHlqAw6NjxmlZ5nmeGWOi0I+iCMDWda2kcF1XWK217moAHcR7MV8FQRQEUZqmyuidnR2He6enp1lZDQaDOOlRSheL2enpqTGws73XNI1FSBsjlNxsVtAWyEiwMtss3nnrrWyxcDi2Wjw7eUwoIAQYY8SoqrSQrRRNI6ooCDHGf/Peu67rjvq93d1dbWRRlgihra2t9XJuwII11loEiGCCCCZAXd9rlWxaIbUCjLQ1YFGXk+mYhdq2rVsR4KgrD7RSG2MwolUtWqmTXk8ISQg7PT1/++2vPzk50Vq/cfetTZrXovHDAAALIYzVnFNGcFVVjuMYDcQlShnmcMdzm1lrAIIoFG1rMaKUzufzoihu3DiWUsqy7MoSz8/OKXf2Dw/Onj3f29t5/vx5nIRaKtvhUzBBiGittbWUUaOUxUAIWSwW/X5ijPFczxjTahXU9WAwYIzNZrPpbLG3f2ARKKMRwQaBtdaARQh9Ug5ZbdIgcnkcybIyBqxFRVVrLTEyQKhUAgNyfc913SxPQbbgMEKI63mbzcY1RoiWENxl842xjuNUReEnPUDEaMUY0VYpraxVCDGDjNZSShGGfqMbBDqOwnUqr6bnjuBSCkopQZ1ADFhrjQVLMMHIfqUK/Mvaj+f9uyLf310E8Hdzmi+yvaIFAP/YjsP85JPuDAYhbK0FwNYaDWgY9wjxJpNd0cj/+P/6/y4W6yQeOjz8jd/4HYTZ9Gr+lx/8pVL68PAw6Q3atimrIoqiKAqklEqKsiyVklJKsLo7gVIKY9S1xZ5fXVqDOhDRcDg0YDHGdV1nWRb3B1EULZfL5XIZRdHu7m7TtI2o4rhX5OskdGezK8dhZVHtjgYEma9/7c1ys3708P4//z//nx48eHe9Wb7zzltZulGt6iA9lNK2sZ9oAERxOBwOKYLlctnKptMons5nvTDodv0d6r+rc1JKO2J9pZTruh1lhRCCEbper68fHlVVtVwuo17EGEvTNIyitm0RQpQzY4yUUinTccPFcZzneb/fn8/nURRdXV0JIdbrte96UmpjVJIkDKM0XQNAF4V0HWpdubWrq6fp2nEcwtl8MWvbNoqii4uLVgjHcbZ3dv/wD/7rv/gX//zp06dxHJ+eno9GI4QQMM25I6WghGGMrUXGGADc6/Xu3bt3dO3g6dOnabq+du0aYyzLMiFEURRJGBFCPM9br9dtK621YDGjGGFqEQFAFiGLwCIwxhgA5nCwUAvpeC4l/Or08v79e9eu7V/b3yXIGqUZI8iaPE8pxb72vV4CSgVB0OSZNrZp6iQKMDIAiDpOXm18zwHCUVUii14AmZRiRnbVXdHWvWS0mKZtM+PDXhiyjVZNpRQozggDihW22hqDLLIIIUSwVV9uMrhfbgf9ZTeMfsY+66U/+8pfzj7v8V/VeV/RPMH3fYSQMRZjjBBR0riOv7e7vzXZJ8R590f3vvtXP0SEv/PNX//mN7/9xhtv1o249/79H/3ovboRo/GW4/p5ni+Xy84VdpKHVVW1bauUstbWdd09n81mvV5vvV4/efLE87wsy/b3D6xFk8l2npXpJq+q6s0336zruiiK4XDw+uu3hsMh55xSXJYl40QblWdrUZfLxezG8dGN42tNmZXp6uz5k93t8enzJ0qJ48MD0dQYDEKoqqqqqjDGhNHhaFQ1ddxLjq9fP3n27MOHH3HPDYKgq+JGUWQ0VGUDFiMgRV6BxZ4bZGlRFrWSJvCjIq+qsuklA2tQURRHR0eI4VW2Rgx3dG9plgMgrc06TR8+fDQeT1w/EFJ5QWgRVtbE/V7VNEEUpWl6eXlZlDUgMtneCuMIIVSW5dV8FiaxBuuFweVs6vhedw0xJYeHh+fn523bdswWnucdHB0+f/7cdd2d3V0AePDgwTe/9U6XbbMYBXEEAFdXV34YCNn2+/3nz59LrbQ1rZLzxWI4HI5Go1arwXg0X60bqUTb7u3vJ0mfEFI2NWBKMBsNJ++9ey9MBhhjqRVjzAv8VqmiKLQ1judXTXv42s2mEbar8xvEXe/g8NhxvPv3T7tWPtd1GeeXl5f7BwdFUSyXcysFDIfM91erdZrmURQbYzAhjuNoKfv9PmgNxiDXLYqCUhpvb1trwRre77VaCSHqqgp8F5CtiqwXxwcHB1EUaSmQhY/BP+hFJxqAUuqzboDPQtm9MvTdS9pL3r+ffWO/ovExxj8+4E/98vObZ2d/jyKAV5rq+Tn203FAVVVaG4wxAEaAGCOEcK3I+/ceNLVGwPb3D8dbe64T1JXOi/KHf3Nv0J/cvPV6HMdCyDzP27YlBDnc8TynA7FgZIUQZVlUVRVFUZqm8/n8+vXrFxcXy+VyOBw+Oz3f3z9gjL322mvL5fLDDz+8fv363t7evXv3DMJJkgBA1xR2cnKCMX7jjTeePX3S7/mqrimxB8eHVbF899mDQeDMphdx5CehX5VZXRVh5DJG8rRCFnd0Pd3mvSxzBFDX9QcffGCMiaIIAIwx3R6fMVaJ0lpbFIXrunt7e0qp6XSqlOr1eh17aDeruq6ttaPJuGpqBNYYgzFWSiGMfd8nhJR11XWHeZ7XeSKtbdu2XeijtWaMlWXJOd/ejimlrVAIoQ5v2rZKCIkR5Q73ff+TcARjXIum1SrkPsa4u/06RXsAkFK2UhKKh8PhkydPDg6vLRYLz3Paukmz9fPneDIZbTabNNus1su33rqLcZim6y6AQAhRSvv9fqcN2Q1uDFCKOuQrQmi9Xp88PTl67fXNfN42je86zHHbttXaEEKEbIVotLWIO6Q1FgEKQ4eE3/r2tx89fPCjHz3Y2em/dv3AgppMRkW28TxHgzXGECPB87oUmWhbBNpBDFFMEDYabC2Ih8F1kiRZrVYRAHddKzWCtt/vp3lmlUbWUoQBoGmaFpC0Lef8szo8DfppjPlX9sW3v0e1+1/VjgNj4jiOwwMEzBhkNGlqs14VojG9/tbrd968dnCzKsVHD57M5ss47v2D3/nd22/cieNYCJFXuTTSC73hZBzHse/7HRt+R4TZbcDDMKyqKkmSMAyfP3++s7PTEcuEYehw78P7H/35n/3l//K//Iujo+t/+qd//tprt65fv44x3mw2Dx8+fPbs5PXXb33zm994+uQxBm2V2Br1D/e2KJJaVpyatio4sci0WtSMIN/hRZquN8sgCADAAHhB0CqFMc7zvBEiK/KLiwvOue/7UkrA2PE8ZUxZlkopzKgGiyjxo7Bs6uVm7QZ+3QogGDPa/bWRLWbU87y2bcuyxIQwzuumsdb6vq+t0crKVkttAVPOXUo5QsRaRCmtylprC4DrVjLXGwxG1trT87P5YqGtoYxxxxGyLYpis9l4nqe1brXSYD/RGHADX2mNCLYIWYQAIyHbqqqEEHEcP3t+4gZuUZXK6N39vfOrS8o5AGxvbxsw2qr1umaMxXFc1cU63TiuCwg5rjscDquqKhvRasMdBxNCCKuqhnt+mPR6w9FsNgOtrbWtUk3XT+B7iJCybjBlRlsADIwpo8tagGhB2cHO3u037mxtD7Ise/r06SZNnSgM4og6HADquoayBIAgijjnZVkbA0YDYAyMAUDTNLptgXDoD7WFrCjBcZUybSWcuI8t0dJYDQQRgqgUbZ7nQghOnU+5s77iAfrS2ucoCfmy9qrG/6xxXtXvP+u0P7OUvOgAxxhRysHSVmglAQE2lkihJ+M9QG5dKbDCc6P9/Z7rhVGYlHWz2WzKonIcJ0piz/MQQsboVrdN0+R52gH+AADAcs47ndjJaHD//v3RaFRVled5O7u7H374EWXO6enpP/tn/2w+n//whz/81//6X3/wwQcGQccQ1+v1fvu3f3uxWHzve98ri+xrb7w+7Hm9gNTZVZEtHWK8KMhXs8T3dStbUSLECAalW2NMr9eTQiEgAGCt7byDtZZQFMdxp97Vtm0Y+p2SbV3X/SimlHYgztlstl6vOef9fv/8/LzX62GMO7lgx3Ecx8mzkhDcCuM4TlcHppRSzpqm6T6aLrBQqutCspxzhKDzdFLKTg5TCFEUldayrgUlRClNCOmgq1prxwkAlLX2x8fshDY72jWEkDGmaRoMyFrrBcFsNnvzzTdPTp7s7u7O51OMARDa3p74vocJ+L6vpdJaJkmEEMrzbDIZd80K/X7/7Oys4yDiBBNCrLXdIsQ5Hw0nZVFfXl4GQRCGUZalUqJ+L7babDarKIqU0RYBcBcw1VpI2SLVtqKOwuR3/uHv/vF//YPZLLt2sFvlqT9ImG6NJUrLpqpc6gBzGFdN01DKNACxAIxjo22rtLLEImB0OBxu1hlIaa1tW8UJI4RYi8ACtphhShGx2hpsMYXPgjsj9OlsoC9rr87PfL74/c/bPm9/2NnfoxTQq8P7v5wJIbVCAEYrhJHj8IAx11iOkev5vSAIXNd3vcBx/Faosqwvry4xIkEcJUnieW6n7aWN7EQW67pSSlGCOOeUEozx1eV5kiTT6fTy8vLNN9/4oz/6o9/5nd/53g9+2DTt1nZ069atZ8+eFVX5jW984+zsLM9zzPDV1eXO7tZgMPiLv/yzi4uLKIrGw77D8P72ZHbx8OLk4XbimKa5ujrfGiRKVEkQVpWeza5c1xkO+xbbpqkAoEu2WGuXmzV1OAIUhqHve47nyrYB/MKBKqUcxyGENU3bSR28EDAYj+taIEQAcF0LpYzWVkpNKWqa2nMZpqgjGW3btkvICCGk0QZBt+tvhES4wRgzzlvZhKG/TjOLYHuys16v5/OlaNvrRwdt2yol1+u16zqUYdf3CCFZWlHGOv1koSQ33BizWq2QsR0GnzHWNqhTGvB9X7T19ZvX03TtOCwIvD/+P/7rN99556OPHvhRcDG7EEK4Lvf9SVakST/mLtNaG6ssaKXbMIo83+/6oouiYswRQohWiUYaDY7jBkHYJccoIcaYSgjOqes43PWkNm3bylYDY77vE0JZmOgql61mGDHP2dnZCZy5MSbLMm1klCQIoVZqAAClwGGO54G1nFGphDWALAaGOecAGIQCWeDRli90XdSUUkw1tML1Ay2NtchahDF1XT8AZGyuVEPwT+z5LfpKCP5LbF+CCOBlszR/Nyvnz778M+aJGXWsRdYQgimjgeP4Dg8I8113MN7ai6OobVVR1Vla1LXI8+L46Lq11mKEEDRNk+WbqqqUUkYqAOiEwAgGpVRdV0KIIAiKojg7Ozs+Pv7+979/8+bNp0+fPn369H/9X/8v3/3eD6SUd+7c8esAY1yWZVmWySB58803n50+/8M//ENjTBiGu7u7v/b1t1bnJ5enT4rNLPZd0E1TpgwbUIJilKcrIQQjmHHCGCMEWWsrWTDMm6ZhjCmloiihCCdJopTsSCm01kVRCCE6gE2ZlR0/c8fG3Ov1XNftdNKVUl3GvIP6uK5LOdPWdLl4Y0ynDQkAWusujU4p6vyplB1wxRFCBIHXoeg4510E0CGLOuCQUhpjopRkjBkjPc/zPM8aI4RgjAHBoFBd1YHrcc46CCZjrFt4wjhaL5a+7zZN5fnObH41GPQQgt29bcrwfLH0HTeOQ4SQaOss31hrpBIdFXZd14EfdQ0NTdMo0fZ6va7a7Hkv6hBe4GNEq6YlyDLGjVLrdZpEcX+QrNdrKaUyGrRVSmNKgNGOWoN53np29fqdO/lm/PDBB4fX9o0xYBRAV3MCJSUxgDB3PA+sIYYBYDAAmFDuGoNN00itnTByPa/Ic0oRo44WyuFe1VYYU9AYNHK413c929pV0bAf62j/qfvlSx0BfN41ws/bj/1y8/+qBvC51wA45whhjKnvx2GYuE7ouWEcDa7tH2plzi9nq3XOqBdFPcf1CKWr1Wq1Wm026zzP66as67Iosg6e6LputzPtyGGapinL0nGcy8vLOI6NMdPp9Pr16/fv33/zzTfbVr3//r133vnGYDBECFVVdX5+fvv27SRJ3nvvvaurq5s3b7799tt37949Pj4WTUUxOn/+FFTb78VlkTICB9d2rJEY2dVi3jb1aNAPPb9tWyFExwskZEspVUp1HD4dtQ4AdOwUWuuyrgAj1/e01nVdI4wbIUTbJr2e5/uNEBbAWIsJsQAIY0BIG4MJ6d5glypRSmFKMCVdCqVLCnVLQhcfaG2EkJTwuhYdXU+WZVlaeJ7X6/WKohJCUMYoZ91i0IlWdmUMQIhQ2hHqEUIcx/nkLXTZmw6r6jgOQnY+n3PPbZVarVZvvfXWJktH4/F6vdZa9/v9fr8vhAjDsEMKSSmLouiK5N20u3jIYsRcJ00zQqjjuYTRrqDd9f12a6fneR1ZXlU21iCMKCEMpOwWVNBaNFIpBQhxzmEwiPp93/eD0PN9V0oppewq29ba7sMChKxSGGNECGgN2mJMAaBtJcFMTOfAHC8MlFLWghBt20prEcEMISKlthb5fuj7YXdxfqbYaz6T+/cr+2LbVwvAq/rifnIP/PiA2ABupKoaJTUwJ/DDnh8mYTwYDEetVpiSJImiOKiq4uLivK7ryWTSkRlQjIssm15c5ps08oNbN17jnHeJ9boq6rq21ni+0+/Fy+W8baqdnZ2/+LM//Y1v//p3v/NXk9H4t3/zN//9v/9//MZv/HocR9/7wfcIIcmg//rrr7977/333ntvPB5f29uXomEEb0/GGOzF2dns8mzYS4g1s4tzRmg/6SGEwsjfbFbMocPh0CIom9p1feZ652dTi2irtRcEnXauMYAZ7cS8ukx60zRad2RzbDpflE3thRGizFoUBJHWtqqa0WhSFJXnBZ4XNE1blw2nTuCFUmoElFHXWlBKI6BgSStU06ou+WM0WMCEEItw07ZFVXPPr5qWOV7gJ+tNlmVZJyXWMY8SQozSbStaoRihYRh3kKSiKIzWCBElWq2t43gIIa1sXTdN0wC8AAKBsR3bmhA1Qsh1nU7IYb1en5ycNE1XuvDyPB8NJ5xz1/UAEW1Nr9fjnAOA67qYEPsx5dzV1WWeZ0pJrVVZl4QQoSRjDnd9wIi73mAwQgSfn5932CHGOjxSiwGB5/ieo2VdrhdB4MNiDsbcfvNthHkjNMJcI4oI467POMcYI1BAiNTGYgKEgbFWK2OMBdBW08ifL6ZAgISRlK2WUsq2KspuCcEYtJZGGUq5w0OKI2MdjahByCJjkQKwyGJk0VcQoC+jfcoC8HMApS/1wMi+1OOzx0Ev9fiscQj+9AcC81KPH5uwQWDA6u7BGcHIGKMAgFJKCUfEQZhh7DpuECbD4WRnvLsf9ie1NqeXV0LXmBlp6un8fLmZIWIoQ2VV+J5XlaUUMttkYNB4uK0lVEXdi5MsTZWUvTjByIimsKYVdV4Vmzfvvv43P/ze/u62US2n+De/9e3/z3/4DwcH+7fu3Pjhj/769u1bYRI+P3v28MnjpNe7c/cNhNB8Pn37zTdG/ejdH36vydfp9BJE3XM4VkY37SAZMu5dXE5Pnp1u7e8GvbBWDeGsPxiVRTO93PT620E0JG4wW2eIOX4UhnHUNE0YxwBACGmllspwx1Pa1k0bhHGY9MuqxoQaQAYQc9w8L5pGxGGspZ5dzUaDkZE6cP0qL7UwFLl5Jqpae37Pc+M8a7JCBH7PaOS4gRcEaV4oY5tWYsowZXUj/aDnuNF0vioqEfd6iGCtdZqu4zisq4piUlcVJcR33LqsyqIwWqtWxX5UpgXnLrKYAqfURZY61EMGl3mBLGaEzmaz0WhUFBnFuKmqIAhXqzUjDAMJ/IgSfvL0zBqys3OtKJq60sPBVhCEaV4ulms/iJpWMIdjhhCB+XJGGPZCr25rINDIxvHZOltt7WxXdV019XhrS8h2tlhMJpMoicsqB2Rk20BTu5yePnsCsytnGDf52mUWdC3bGhC1BrWaEqenkU9Y6AY9sFBkGSeIek61nvPRUAAAxRC4layVkSxggEyTLvd2JqBbqAvfoUrW1rSYWIQsILNJ54yCw3ieNqAjZaKiIcCCxupK117ouB4HiRi4L7ub/Cw383lH6i87/me9/mXtYxXlX/RhrX6px8uO37mvv0dF4M/J0Md921VV+L7v+o6UUrbKIGwNSG2Kquz3JuPJjh8kZ+fTi/PpZLJ99+5dZc1sdlXXwvfCiDlVVXvU29kZv//uI2tt0zSu63LKMOBhf2CsWq/X4/G4ber1ZoWQdVxWF6VS7aDfWyzmi+ns1q1bLnfqsjp58vTo6MhJwvPzU8rwYNh7/4MP1+v18dGNJEkWy1lVFYfXruV5Or+afvOdd04ePQwDd+JGZTZrG9FPBkqa84vnbVMfHhyuNxmjjHtMGd0UpWwtZyGmxGK8WKZxFA564Xqz9lxna2unKDJGkDHmk++9MWCx0cYqaTBhAIi7HgCuqoYz1+GeMYYQFvkRASKEtLbmlLnc87xASl2LRjTKGtxqYwxYAEIIRlQh0NoighljFgAQKqsGYW61qpvW87wkiVTbXlxdTgb91WqFkTXGUow4Y5vNxnGcPM+ttcNkUJZlGIZFUVBC0jQbDvqWGKPBGAkWCMFdy3Ene5mu0igOAKCrSDPGh8PRer1mASeERGFyeXkJAH7gUocTS9MiF0IgYzsSpDzPXdcFAIQsxkAI4pwaS8DSqqqEbNerRZHlo0GvPxyuNhkhxOGe53mbzebs2RNCiOuwpi6b1XRrMiiLNAhjythmsQjjJNraqdYbA8gaCxYB5R53ACGwmmGsitz1PUDIytb3/VbKKtsQwjglWrYUASCMrGYEUUyEkBYxay3BAEYrJRHHzAl7vW1lpDStJQjA5lWOLVDiuo5Xixq+Kgh/2ezvUQroldsn1ZXuSZea72qPXTuS7/u+FyZxLwiCx48f/+f//J/X6/Xv/d7vfeMb33j27NmzZ8+68maWZRjj4+Nj13V/+MN7q9XKGNMVCaMoNEb7vm+MaYUI/aBLDXNCjVRFUXStmB9++GGvl+zt7b7//vuEkCiJN5tNmqb7u3vD4fBP//RPz87O7t55I47js7OzthEdjjPPc8ZYl7HxPG+TpR0Ks5NFJNyJkp6xYCyizGHUaZURUiNKCCFK6cVi0e/3KaVFXrmu37UCdJnubpOBbAeNRdaAMQAADucd6YK1Nk1TwhmipKprqRT3XGVf+FlEcBCFhFFMCerYI7Sy1nbNWUqpjjBHStk1mlFCtFJa67LM67ruisAA0FWbgyDoKtWYEuY6buA3TdvhcDDGQkmhZMcmpKSRRiutu8qzlNICEEY7362U6feHjVTM8TCiCEirJGG0Kxu4gSeUpJQ2okLYSikwoq7rFUVZ101XBmC0g7eSsixr0bRKdm9BSWOt1VpzylaL5cOHDwEgjuOmaajDASPG3bppTp4901oPBgNCSJqmFgFCqCtpvPgqWutyRhAYY6wxQAhxXUAItMaMVkUOjII1WrbIccCaIsswsphToyWAAQzWWsaY5zroY4EETIgGq41kjPV6vaOjo93d3SAIoiiK49ha27aqy/j9am7Cr+y/z16CDfRla+G/BJ/dy/7DZ5z3s8Z5Nfhf9GN8rZ9s/xFCrus2TSNkSwl3XG4REkK2UntB797795Pe+J//83++s7v/8KNnm022tbUzW87yvOTMnUy2XeZeXV0t5pu6rsMw6OqcQRBggE6cVinl+25VFVK1YeiDUVmWNU3l+4PZ9CrLsrfvvtm27Wq1Oj4+7jD1t96+e3l1lZdVkiS3bu8lSfL4yQkhBCMbRVFVVbJtbxxfv3/v3mQyacssTdOAWz/wEQhQJIp7ui0urqbHB7tGStFqC8j1A2tQVTR5WTRCDEbDpi6LNKdxiI2pVBu4jjJ/e00QxmCxBYuMZZR2MHxKqVG6ruuuQNoR0TDGpJRdEqAjs+sqwJxzIBgAOmdEKc3KAmNsjNFaY0M6Zy2E8PywqiqKSRRFWrUXF1cOI7u7u0JJ1/Up5ZQaigkAMMaEko7jDAaD2XQ+Ho+vzq8ODw9Xi2US94ui9H0PULdoYWstwTQIAtnq7a1hHPU6jbC2bSnh1to8z7uabdM0Vss4jh3HyavcMQYh2nU4O5R14gfGGEadsiyFkISgbgHQWhPClGr9wO3W/k5Lh3MOFmNGO+HlNE07CED3Zbu8vNzf282Lsimbye6+asXy/Hy4tYU/UVlgDDDtSr6Ec6ItiBoswgAgBbGGEaTqhrsethYwBkI6eULg3HFU3VolDSFEWmu09jgJQz8cRtpU6rJExnpOWCEmhUCGVFXleJ/SI/Zz78df5r57qZFe8vWft32x5tPN5qsI4Je0n9r+A0BHW08Jj+OYczfPitVq0zTtcrn+x//49//Vv/pXjPEPPnhQ17XruovFwvO8fr+fJImU8vz8/OLighBydHQ0Go0oJZPJuEs+uK5bVnkHASqKggByKEvTVErpe15Z5BcXF9vb25TS999//7VbNxl3nzx9dvzaTYTQX/3VX1lr7969izE+PT39BNYyGAyEEJ3rzLKsIwSO+z1CmLaIUEdpWG3yomodP8IsEBoJbRj3CeVVI/KykEqNx+MsyzjnHfNa04jRcFIUhbUWIYIx7WjxMaYEiLUIADplrg4g1EmDdehPay3CWLQtdThmtKiri+nVcrPuuoI7RGkjRMcT1znNDp3Z4US7vWoXDHXC613zRLe6rNfrMImNtZgSZXRelI7nZ2nOmUMZB4xq0QDBrVYWgeM4HVYVAAyA1rosy7KuKHeKqmqV6g+HaVZqi5QF7vnKQKskYFRUJWG0Eo0f+QaZzn1rAwSzfr/vBn4lRNMIx3GCKFRGU0pd1yeMU+4QwlzXLbLcauV5znDYn87nJ8+fB1EotXJcX4ONeokfxYTS1Xq9SVPGHSFkUwsAoJSC1t1lAa27OElK2VYVKGW1BmUAkSD06yKzSmJK2jyzWkWBL5pKlzkCA8iC0WB0KwUoxTknhGlrEMFSt23bKNVqKYGC53nI4rqWTS0Jo1GSBFGI6VeKYF9K+yoCeOlxfnzX/8kT6DZ3jBHKtbZlWSllxqOt/YODw6PXs6w8OXleV20rLQLqun4QBHVbh2HYCjmdzpHBO9t7juOVZRl4Ydu2HZLdGMM4wRjHcbheLxEGAJNm2XI5DwLP4ezp06dCiP39fcbY2dnZ67feGAwG1iLHcb7zne/cuHHj9Zu3zs7ONuuMuU4YBBYArKYYc8qsYU8fPT46OkrTVAhBMeoPB1I0F9PTOl+HAR0MerHvFsWmlZYTDxGnbpp1mulWu4FPCPEcVzaiKkuXe4QQKaXr+lK0FgwAYIw/bhVG1iIltWjrboMPxoZhyBjrmOy6RdFaSyj1OtykUnVddzBHqVTn/QGg6wjrunYRQojgrt7QBRCe5xGEu7VtOBxqKc7PLzzHCYKg1IZg3MmtUM663to0TaMoWq1W+7vXZrOZQ1nV1MoagBcQI4NMvskRhiiKZKvnszVjvCzqKGoJZkaDNiYM4qou6rrq95MuxCnL0nVdx3PzPO/o22SrhRCgjet6rutlWUoJ55x/UvaklLcyNcaMRiOM8XK5xBgDwV3G7/Iqt9p03bl5nmOMkzgcDofnlxdbWzv9fnx5ceH63nhnt8rSjt+0lkLUDcUeAqy1JsYA41Zp5FpAoJqaUsp8HxtZpqs47oFqQVmEkGlVXZaeHzFOTdOxzLaybZqmXq0WJPSiIO4lw6pYrVYbTlHg+cYYAPtZBYBXhbv/KgJ4tfZVBPDL289u/7vnnWZvmqZt2w6H46Oj492d/fPzy4vzqzwrKeWO4ymlmqYxxhDMTp4+Pz09HwwGh4eHSqnlctkVTrtsEsYYYdulShhjqhUUQZ7ni8UCA0IAeZ5LKeM4RMgWdeWFgVAy6iWO711dXe3u7t6+fVspVdf1jRs3Onadne1thslms+ny/p12WF3XXYLFD2OhzSYvqOuNt/b9cGCxoywjzLWEVa1qhMKEMdfp2soopZvNZrVaJUnCOc/zvBP2AoOQxdYgAAymqwGYDl4ZhYk1SAjpeYHWVimTFmVWVhpQJVpprEGYMscNQkBEGlvVoqgbobRB2CCsLDDmdM3DGFNrUNdM6zo+GIsBIWwt6G6FsNbWdT0cj6RSmFFlARBh3K2b1vUCwKhpBcJUtMrzw7yoaiGVUoxzi5G1ljnc830NtmlbRGjc688Xq7yomOPWjXK9cJOlrZTU4VJrILioK8qY1AoRqEXVNG1RVIBJWVdCCM8NlAEguGtsBowQph2vUSu1tZYTWmTpaNBnBHueNxwOp1czi7BF+PzqcrVZl1WlrMGMc8611tz1i6Jq6hYAv1A8prTMC6M0I5QgrJSyFiFCDFiQ0lSV77lACWjFKNFKtmXhe65sBRAEojVNQxyHUtrUAoBQyqU2Gqy1FpA2ts3zLE1Tzp3d3f3RaNsaUldtVuR5WZgvlnP7yn5R+2oB+CXtZ/cjL4iCLTLGhkE8mUwA8OPHz77//R8w5iRJ7/T5+ZPHT8MwHo+3NpvN8+fPe73e8fExxnQ2m9V13TW7dnXLuq474aw8TzmnbdtgDMaqDsMTxUHT1NPp1HXdroH28ePHvV7v9u3bUsrvf//7iOC33357s14/efJE1I3W2uOO7/vvv/8+pXS1WpVl6XJna2trennlO6619vj4RtPKxWo9GG3defNtwv3Ti/lyk3tRn/txa1BZtQbhuD9wgrARghBy8uxJXddhGGbrldVmPBxWRf1CKbyTyHoBBDJGW8YcQkgcx10QQAj58WYrz/M67FNZlp26OuHMGFOJpmkaa22nG9x1fnUl065O+0nJvdssa627CnCapk3TxHGcJEma5lrZuq6FkoiyzSYjnFHCOykCznlHal3XNeUu5y4grMFy7gZBxB2PEOo4zmg4aZq2qpooTJQ0rh+s1xuljGgVpTwMosVipcESQqIo6fjmiqLAGLetAsBJkhBCtLIYUWMsIbQjUu6uD0KIUpxnG4fTbkr94eDJydOqqXuDvlamFq0Q0ljbXYFNlpZlyRwvr8osy3q9nsN4s1xKKbVSQEhXQcEYA2EGcKtMWRQQhkAZSMFcbrWsiox5DrYAlIJRWmvwfea4xhjAxCCsdafdA4RhxoixykhVVU0U9kfDbc+PCHfAIoSQHwZfAYC+jIbhxxioO3vZIf6beN6f/7JPrHvNj88B/VK82C87z5cd5+ddTYw7NuNeb1BX4uFHjy8vpv/kH//TzSa7f//BYDB46623EELT6dRau7u7nyR9x/E+6VRyXXc4HPu+3zQNY2S9XndSiGEYUkbSbH367IQRvL01LsuyruskSTAGz/MePnxYFMXt27cpZ9/7wfcHo+HR0VFHaq+UGo/Hnuednp4Grre/s1tVFULo1q1bs9msU4Qvy/L69evz5WK+XCPCuOMtVrkf9TViXthPC+EG/byS1PV7g/EmzbWB7b39JydP2rY9PLzmujzLMt/3Pc/bbFae532i9IIxBkAEUc91tVS9JFmvVlqpwXCYF0VV171+3w+CIAyXq5UF6PX7jutagPlikWZZEIbccfwgAITyoiCUirYVbdupCWNClJSM0uFgUBaFNlIbCQCO4wBAURSU8zfefPPk5FnbyqppGHcpc+qmtYis1mnZ1I4XXM0Xk51dqVWaZ8Px6OLq0iCoqsr1vdVmI5Q8OD5SRl9ezSrRHh5f3z84JNyJesnjp0+Ho4kFtMlSbY3UyvP9qqm7UsH11245XrC7f7Bcp7PFinFXagOAXdddZ6kywKjjup7jeQbg+MaN84uL7a1xFAVt2yRJNBwN8jzf2dm7uJyKVm3v7tx/cNLlprjjnF6ch2GotD0+viGEzLKCcy6ltFZXZS6qUjVVlyJL0xy0dfxQKeO6LhSlXi1M2wKhHfqzXq/6vbiaz8FxNptNM5sBQNIfVHVTlI0FHMcx43S1XixXc2RNR00opfK9aDjcooRrQEBwJaqfvd3Ix+vQp/oB/Bn2Cu/HT7VflT95WXvZPoOXnX/3Xy/BBfTL2cuOj/4O5dBeiX0y4eFw+PDh4/Fk+9at12fT1dnF1c72tcOjG9/73g8c7l/bP4yipCiq9XrtON5kMqHctdau1+uyqOIg3traYYwURXN5cVlVFUI2DMODg33X5Wm6uTg7VVIyTgjBUrZKyQ5Fbq3tvPxwOHRd98GDB0VRvP3210ej0cMnD1er1eG1A6nVarnsCCn7/b6Ucnd75/z0jBPqJUlXu67KZnY1w0Y6nh/1k7PTZ9qa3YNj1ZRAvHsPHr9+8/pqPruaL/b2r9V1/eDBA8bY9YM9a1RZZAeH+67rXJ6fhZH/MUd/h9vHqNMMQTgrS0Cm2/Z2W3WEULe77yq6HfoFMLLGeIE/7A82Wbq3szudTrXWOzs70+m0Iw7qYoUudOhy7lJKbVG3juZ5nmfZZDIZjQbr9XqxWLiu25E/a62Vkkppaw3jLmDkeZ4QQokWPo7hXMcvysx1PB3IzWbj+y53XSnlfLEgiHQFBoxxr9fzHAchjTA0TSWldhxGMDPYaG2NgY72LgxDhNBms+Gc+35ojDo/vyyK7De//euPHj0SjcQYd2QSp6en08vzui6T/oBzjpSum3Y4GT99+nQ4HCIMaZZfzRdv333j9PlJVlRJFBhrO1Ap59RxHGxh2OtXVcU571hDrEVKa2wtIrhtBSHYdrT9UmitCSCK8AuuCA1hGEptXEKRRUYZTDmmWBkDQByHe55LKCrLnBKOEeXUi8Je4a/TUkglMbKIEPjJO7fzSr+Km/JV2v8Ab+Hn2N/utT+P0dGn5cpf6vVf5Kv/U5NM0/T69es7OztPnzy7uLi6cf3mzs7eu+++r5QZDEZJ0k/TbLFYOI63s7MzHA6DILi4uLq6nO7s7Ny9u08p+eijJz/84Q+7PfvOzk4QBF1hIE1T33elFB53HMp0K0GbDllY1cV77703Go0Oj482Wbperw8ODrZ3d5+fna3miyiK2rbt9/tlWeZZ9gL8AxBFUUcxtrOzk29SSkiapgghwrjnB0GY5EUzX2VBPJwusqKWzI1aiepG9gcT5gTL5XqTpsdHB4AUpXgw6BMKFiTjRIhaqRa0wvZjoA6ANlIphTE2GjCiYHFVNdYix/GUMlUjDCBMmUW4aWXVtJiyMO4BJn4YX1xNARPKncVqHURx08oOX9S2SmvruQFGVDSSEKKl4pRRTIosb9t2e3u73x9eXk6bVllEMOXKgNQWEUq5iymzGDVt67huUZZ5WTPHE1IRRhHBUivMqON7WZ7nZeF4rkHQaqWMzsscYayMdjy3VUoozRwXMLWAMWHc8SlzlYa8qBhztLYdhc46y7OyIJRaBEEQKGXuffigPxpOp1MlzcX51fbWVrpeNlW1mM0opb7vu75nEAxG49lyZRCe7IzmS5nnOXGcrneEYNa0rev5ncYkASSaKvBdBEYq0V1whJBS2lpwvaCVL9RvrLUgpVUafwyg0tqAkK4XpHkhpAVEDaKACCK4bVtlFWPEcQkhpCiKpmnrWiCgvWQ0GI1dxwcARH7ijvgfyV52Z/3lshcpoO6H/96g5TOu0S8+/s++/vOY1Suxn50qpdR13fl8XpblwbVDa+2H9x/UlTg+uh7HvTTNpldzx/Fu3rw5HA7ns+WDBw9d133nnXeOjvrPn+f/5b/84aNHj4bD4dHRUZIkVVWl2RpjIBSLtmmaRmvNOSMEay0JQRjjsspns9lsNptMJgih1XK9t7d3dHS9qprVaqW1DVxPKcUILcsSITQcDh3H8X0/yzKXc6WUy3ie513SKen3DIC2SEjtx7HrRWXVFo1ChA8nO09Pz0dbe2FvcHZxWTVtHMc7O1sYI7DGcxgGa1RrjDJagVGADKGIYYSwNcZI2TZN0+2FO4/TcSx3+YTuN9ZawJhy7vu+6/ue59VCYIzTPEeEdF1mHR60S/p3ECnHedGy1A3eyQAYY7p4aL1ebzabOI6jKOpeSQjxvKArqksp8zwHgLqutdbxCxIL1rUgdGrDlHKjwVpEGCUEAUFN02gjuzJ+J8hTljXGhPOOC+EF+WueF00tun4FKSUASKmrqjEaer3BcDh8//33jQGMqda61+uVZck5m2yNOGecc0KQ67pdCsXzw/litXftIC9BtPLi/Iw7XkfJ19RtFCWEMtCAMU7TtFNYo5i0bau1RYARQoRy5AeEMG2sslYrq1RXdaBKmY4VTgiBCM3SoqobQAwQ7XJWXbeaNtIYRSmx2jSNKNK8KlvH8YbDcW8w9AK/u7w/61++XNH8F8p+OY/0suPjn/Vlr9ZedvzPez6vyn52nlrrzWYDgPb2rvl+eH5+WVXNm2++TQhbLtZpmo5Go+vXr3dNAOfn54SQg2uHYcjfe+/s+9//PiHk9u3bN27cuLy8XK1WnYuRUlZVVZZlIyqKgSBslAZrCSFKtx0C54037zSt6PTfe8NBVhRVVe3s7ERRNJ/Pd3Z2iqJomubo6Gg5X/iu53necrnsuhBOT0+7TuBue16L1gDaZPnW9v5gtLXKip29w6g/yssGENk/OHz2/KysxXA82tnbVUaOJ/26yReLq14vNkZfXJxHUYAxsvZFeVZKYawiCHNKEUKd40aoEzN4ob7SwfabtkUIhWEYJTF3HW0Nd53Fannt8MAikFpv7eysVqtOP1Ip1V3zT5gvu9EATF3Xnuft7+/Xdf302QlhNO4l3HWUtqJV2gAgYiyS2ihtq0ZIY6WxmBLX97S1UuuiKj3fL+uqrKowiTGjXXexlLJpqrzKi6qqhVDWWAQWIC8KTAmmLC/rdZorgwl1tcFpnmFCi7LapFngh5TSLuqq6tr1grt33/roo4+SQZ97/sHx9QcffcQI3Z6Mkyg2SnYYMNcPaiGHk635agkAkwmkaXp+fo4x9jxPKaOU6mrCXc6trmsppReG3dXAGLuu67g+YArKul6AEOkSdEopIJRQ/jEmDZS2wBzquMYixLhFRGoDBBtjELJaS9E2nNMoirTWRV6t1xvRKMf1e71eHMcf81v8rSf68bz/l9rMZ9ivel6vxn46BfRL7IV/kXXpFxkfPs2rvvL5vBL71El2WI7JZKK1/vDDDx3HuXv3rhAiTfM0zTw3uH79ehAEz58/XywWW1tbx8fHVVXdu/d4Npvt7+9/4xvfGAwGl5eXeZ4r1YZh6PtulmWr1QrARFFEKbWgW9loLY1VeZ53XNBJkqTp2vO80Wi0WCyyLIuiqKMH8DzPKGWMieO4C/+7Pa/VhlI6Ho+fPXs2GAyqqupkyjGl3PVrIb0gMoDyohmMx3nROK6/u3f4/OxcCLl3bb8S7WuvvQZg0s0KIev5blHmUooo9JVS1mqlWiGauimFqAGM47IwDOu67qS4uiZnY0ye562SGGNlzIv2Lkq6bX7ny6IoMsZwzruuiDAMO3ffqQJ0e/DufVVVpbXujh0sqgPhRFHkeR4AdGtG9zF1Accnn9onCKJPxMI4522rOvKfTxBHgEw3SNM0gIwQwpju6hprkFKmKMosK+u6wYi4rt+2qnsjQgjHcQimTdM0TdsxXe/v7xPCLi4uPM+bz+fj8aRuSoSt63EhRPf2O1nQMIqiJF5tslu3XmuVZA5Xuu0N+gYBIaybm1K6bVsEBKEXHcyUcs458gJwXbBWliWl/3/2/qvJtiw5E8Tcl97iyFBXpSgNVDfAHhtyjE+k2Rh6qJ7Id5I/coxvJI18IK3NZtDdxBSqUI2qSnFVyCO2XNr5sOJGJTLzFnCzMpEl0m1b2ImIc9ZWZ/ta7v759wkChkwkAOtCOXHG2DhM98l6oU7PzplUyBUgZ0wUUYRChW2tNUqtViujdM7Q9+N+fywnK7TikgH7LgL4Ou2rOaV3Hf/zKaCv+ST+6bC/e/wvdazfxPH8/valR3hycuZdvL29LQ98qU/Os93tdk3TXFxcIPKbm5uu64wxFxcX+/2+67qqqj744IPtdrvf7y8vL621P/rRj4ioBAHGmPPz89Vq1XWd5DzHVEp28zzv93c5x/fff1YUVJrFwsVQVNqZ4NfX1wCw3W6LzuJyuby7uxfyjT7UdV0YckqZoTDVEEHbLgEwphxTLmnxfpjudvuT8wvTNL/69UdPnj3T2qSUqqrKKb58+UIpeX5+ejzuUw4XF2fWTrMdQwgAWUqhpRTIiCjGCDkrLgGQCBjj82yn2bbNAqFQPEhCdM5P0zx772IMOW/Pzg6HIyLjUvbjuFxvdoejkCoTMMYRmXOec1EpY0cLAOM4Nk1TVdXLly/3+/1yuZRS5gQpEjDUlVFGEwIwrk1d2scykdK6xD0ZgHOOiGUiEUKUaKNZLoghICaKysiYg5TSOVcUjDmX8+zmyXEuBVfOhcl5zoRWlbUeEUujNQBIo2fvvI/G1Meue/+DD16+fO1cuLy8fvToUWH10VozjoV5u9ydnPN7770XQhBKbrfbojfgvS9Z/tLtXDSNSx04WgdvpjqIsRRmfco+phIqIeI8z95HJoQxhjHGpSTENI5V1VgXEkEGZJwj4xlImaLKaXOOSqm2XWpdOR9v7/bXV7d935eD+eJj8qfh/b8uh/uHab8FfX7Tp/Su4/+BX+IvHt7r1y+3J2vIdHt7u92uT9abcRw553fXN8vlcrs+ORy6w+64XKyXi/Vut2MEy+VSKXVzc/Py5csYY13XSqnr6+thGEylFotFaeO6X65yliiH4HwM1tpunDiXT5+93zSL9cnp4XA4dMfHT57oytzd3a23m9VqsdvtTk9Pb25unHObzWZ/uHv85KIINK7Xy9evXn7ve+/vb68qKdw8YkqS8eF4pBAoBMz0+Ox0d3dTVyY6G6xdtPVqvXj9+tUPv/fhq1ev7q5vFk3LEe00b1drLVXf94umKfrvSqkCYC0iAcfjUWpjjEHEMuVYaynn09NTRDRSGWM4Mm/dPE7ReQ54st4Mx+78/HwcRzfbp4+f7Ha7e4YcgHu4MENjjGlqH6OUOqS8WCy4FJ988nyYxu3mNEWy1hZFsJJ3IiKkrJRKKSMTRCSlykDTNBUJ+wys64aUs9amH6aQ8nZzLrix1lvrGRNEaHSNwLWqBFcZWD/OLsSmXS9W65TZMDobU9XUzjkpdV238+xSorZZBB9//evfLBZLKTVHsV6v+8Px8fnFxx9/LKSOiUxVVabWUsTZag6Y/NTvT1at5PT61Yuzs9MQQjfNL1+/nt2UMaecdWV0U6HgQklPyWciYERkZ2enHrwHRC14cJZyFowDMW+9dwGYFKauFktVtS7C7aFzCY795HyMAJnxlMHHzJlkTKRSBE+paoyuNTEahm63v+26zs82uIj0JQ/Fn8Ac8Cc+AXyR1/6tVPhIX7q9lW/6n16pz8GBv2hlqMJt/TDy7+C5Rnq3rbSnFhZeBry8/qfn99v/Przhi9tb3o+VUXc311rJi/NT71yRl/rZz372V3/1P3v06Mk4zuMwLxdrJfTYz5yrlBJHOOxuj/u7tq2bporeKcF3u9ucsxJSS1Vrg5mi80IIoVWiKKS+udtnYONkf/yTv0yAUlevXl9XTZMJlamev3xh/Vy3zaury5RCztFUinMchi7naO3EOTaVvrp8aQTu765qLbRIjWKN5I82G4PYahXnQbMEYW4Fni7r6Ib93evz7bqSfHd3ZSo1jX30UQInnzRTkslkIyPmbTg7OT/sjkpVRjfjHJzPPqTT8/P9fj85W3rBjvtDf+wenV9M4xhDEJxDTBDTqmkrqbL1Cvnh5i7H1B87wXitzTyMkDKkDAAppZRziFFpjZzd7XfI+c3t7vGTZ9Ps/tN//jtk4v33PgRgpR1Ma93WDRKk6IsChJ1HH9I4+9OzR9Psun48Pb8Ahi4EU9dMqH500xyWq1PGzM3tUarm9dXtdnPWHcf16gRQNO0qREImY6a6Xai6ud7tz549+8VvfpOl1E376vI6puSco4ycS6XMb/7x4/OTR1rUP/+ffqm4mYfpbHN2+eo1ZMqRhGqa5YnU9fF4lAgK4/761dPTZSPS8frlD95/Ijnc3Nxc7/bnT566lPqpV0a8vH55/uTRXbe77Q6OUmK8Wq1sTKOzhJCBiCIgAaU4TeD93A/J+dVqo007T372UC1PI1MBRGJ6cMks15e7Q+ecqOvIuZDVOHvBzWZ96myIKYx2Egqfvn+xOVt2h8NxtxcJeUTImVJGAo6MIxOMl638ypExQAaIBF9tY0DvuOGXbl/5AD63vbOrfUddk3fVO3nb9rZx7o/qK0waf5L2+0/pnHNTqeNxn4I/Pz+/u7t7+enzf/vTf/PTn/4F5nR5+Wro+5QSY1xKKbnYbDaffvppSeDM8yyEWK1WpcT33nvvldS88xYgv0msR5/iq6tLKeXN3e12uw2JgFhIablcNu2yqqqrm5v1dlu3ben1PXt08fzVSyFESRqsVqvD4VA3BpGSd5QjyxGyhxQEZIngpx5zqhWHGJJzEIOdRsxh2dRaCiXY7c3V+cmpt67UohkxLITPhXOAMc75Yd99+OGHdvaTszHRNE2nZ+dd32utl8tlSXnP8/zkyRNjzO72rtKmsDhILooHkVykGAXn0Xk/Ww6IiIVFrsD5S9Oc1poxlomKrOPF40fTZHeHY9suHz15LLUJISh1rwncdd08z5AJ6X4tMk12uVw3y0VGSCnFlIiISxFz7scRAEooACDqZtV342Z9RoTzXIo6/eHQHYdxtC6kHFLeHY6Hrr+6vim0CTZErfXx2HMmY8ycyf3u+NOf/tuuG87PH83z/Ot//McnT56cbLcppRfPPzk/P0cmuFRFXMxOoxI82il7ayRTAjnFxxfnUvHFYoGcSa1vd7cfv/jN9mx7u7/dnGxjTvVy1c/WBj9HH3NOdM8yHf08jsN9vyEgIgKxlGh0YRit89mH7DMm5CiVNE3dLpp26WIivM+JcRSSKyhgIaRqYUxjpBamUpizmz1m/Ao+8Tv71u3PaALAL6szf+kfv5oppXKCgr7w3nf9ARk9ffrkcNh99PFvlBaPHp0OY5dSPDnZHo+HQhlkjNlsNnVVOWuPx+M4jk8eP14uFt77YRhKCrgUQq21h31X/hhjbtul1ial7F1cLtYFUnnY7ZZtK6Xc7/dcCGPq4BMyUXjkS6ZYCJFiCN5CSgwypYiIxhgpxTSNjMNyueCcAWZjFAAU6V3IRESHfffBBx9M0zQM0wP15kOZFIGXOuR6vUbEw+FARMvlslAlb7dbACj8o4yxk5OTEIK1VghRap6lveuhqFuc/gNHdJkAynUoTWRYpAK8LwVkJXV37IdhKEqQ4zh2Q6+MFkIVwIyUUpsamYiJYsiFp2Ga7DjOnPPCf1lwmdZ7QvQx7o/HRKSUOhwOi8Wi6Fx2Xdf3fd/3JbOvtS5HhYj9sZNclAnG+7BYrEJI1jrkfJrm4OOrl6+FEOfn59fX169evXr+/Pl6vSaApqkK80dpcCtlee+tc7OUvFStnzx5YowyRhWyUufcfncseNYQitJ9vicFesNNG3wqJZAYU87Zx+BiyEBcCl7wpkoCZ4AcgCFyxqUQQgotpcacJGdSMAaElDiDnMLYdz7YSslKy7rSm81GSlnuyFd+cL6zb9HemWjhj9cezvmLv37xxbsbZyjmeS5wnU8//UQI8b3vfTjNw8ef/AaRqkoLyZbLtqrlNHfH7u6jjz5ar9eFDLmu62mahmH467/+64uLs6ur1y9efBpTiNHH5JUWxadfX1/XdT3ZebPZFCxg8X2FhLIQO1trC2R+uVxfXt00i7awDBXKh7ap3DTO85hCBAAiSjFwpKrWXOA49SlFpUXKAZGapjFKSSmnaQKA6APnfLVY+9n72RpjlFKIvCigRcrl27Tdbg9dpypzv9/zs8vLS2PMcr3a7XZFjWu73ZYu6LZtGbtvRkXE4kcKitGHwBgrncMPqLuC/ykvCmInv1EfOxwOjLFCxz/Pc9d1pdrhvc85K2WqqkLk0zR13TDZuWobANjtdt771WpTGNYKfL50FYzjSAQFOjVZl1Iqc0Y5nlJ9fWhlIKKzs7OS4ZznmREcj/3TJ89CiNZawdXJ2el/+fWvYozlJuacP/nk4/3+rq6NVHycJ2Jorc05lnsagisrCc65dRNjWNV6tWxz9Cn4EN1iseCc73a7QsddVdXV1VWpkRTNgDe1/XsxMmIYUrIxxJyBMy6EVKaqGqMrKfWb86KYKcYcfWBIRnDFGaaYgocUcwrBuW6/s9aWa3t6erpcLh96Hb7UvoZHFxHfvjL7usb/pvf7O/3wt2Z/RhEA/FPX/7m7gr93EFBWYUUpMMZYVVopMU3DarW8eHSyP9xeXb06PVsThN989F8QSQiWc7bTPI8TACwWi2dPn/7g+ye3t7fPnz9PPlRKj+OYc26apu/711eXs/NcKq0rKZSpm4fnMMY4DeNxfzg/P9/tdv3xeHZ2xgTfH7oQsw9psVyP41h8wTyNOXrBQHCEfO9GkTIwcsH6YL2341iWt5koWWv7w3G5XDLGKmUKzKlpGoYiI8SUCq8DQy6EYIIT4jRNZe3POb+8vDwej6vVxjnXj8PsrK5Ms2hnZ4dprNsGGBICcia1UkaXn4WhQWvdNA0iFkxOoVoqbVwAUDgkpJQFx1l6nk9PziiDs74y9XKxAkIfYkn/Wh/udvvL65vDsfM+rldbIXUMuW1b09TTZJ0NZdizswsEPk1T0zQxpsvrmzJLTda3y7XUFTF08R42utvtdrtdCGGz2ZSuvXHoY4xKmmGYFsv1NDvvY9sslTLtanm7u3v+/HnOsW3bD7//waHb73a3zlki6seRSzHOE5NitLMxJlMEyN57pQVRfvToESIqLQq1X8759vZWKcWZBGIl+gk+IjAptOCquHUiKq3LTPAMGDM5H613NviYKANGAh9TiDknAGL3/aEpYg6UQ4o2hTknLxCU4Pv9/u72tjscMVPbtvdQqz8VXPyfm/0ZRQD4ZZ79c//C3yMI8N4vl+tpsn3fP3p0zhi8fPlSSGQ8//KX/0AUnjw9f/ny09/85h+FwJTD06dPj8djWTlWVXVxcbFcLv/jf/zHX/ziF4h0fnHGGMx25Bxzji9efLq72zdNY2e3Wq5HO5+enhbW+AcoJ8A9/wxjbLVapUjL5bJQNK/X65ubm+1mRTFAiqKIqUAGIo5EKZZUjDGKc/TeFmaxTDHnNHTHEMJ2tS6g+Ocff0Ipb7fbkokKIcREyFlRMSsr8aqq5nleb05mZ//+Z/9gmlZoVTh5yuL0oRm4pH3gDUag/DelVKQlpZRFcBHfcIeVOQzf9A/ftxADAEBVVcaYnHOZNUv37zRNhUM0xrjfHW5vb+fJMiaUqbphKJNiZRpnw91hj5y1zZIxUc6UoajrttQPKlP7mGKMq9VKCJETvAHj7o/HY9d1OWfGsZxa0Th78uTZr3/90enJI+fC69dXL168evb0fecCZbDeCa18sEKI2Y5CcIKUUigqlSnFcn2EvI91lOBCCErx5GTbNFVj9Ha7RsSSOru5ufnwww8LH5+Usuu6shZRSpUjKak2G4NL0aXoc/KUXIgxJ2I4WzvPs7U+hEREHIWU0kjl7ezdSMEjZMopR88ZtIs6p3g47A6HfWlxQMSq1py/VRDm935q/8kT+s2N/03v95/1xd+K/dlFAPCZtf/n7gr+fkEAIn+g5QOAlKPz8zyPH3/8m3E6np5tmtZcXr3o+kPdGKIMRItmcXZ2ttlslJButq9fv/z5z3/OCJ49flKYihdNK7l4/erF9fU1Y6xZLFFIn7JSpq7bEJIxtZIyxSiEWC6Xt9c3lTYnm62dfQJslitV1U3T3Iv95kQ5ScGkYEApBIcIxSmH4B7wQjF5RCrep6yy60qn6CnHGHwRqxGMP/hfxlgpMMaY+n7ANzSQxT8qJVarlXPOObdYLApBEBGN41haokq6vyRVHrrAytI+vxF7KUkhRCznUqaB0gtWIhgAaOraO9f3fWk2ds5Z64lQ1w1wMcx2d+xcTKZp63YphAohhBAJkQnhfQBii8UqA3EhDsc+ZGqWCwKwLgih6roOIVgfkAsfQ84FHMkeuOG0FMOxc9MsGS6bOvoQc3IhORc4k10/vnjxSghRRBTW67VS6vLm+sWLT7XW6+1msnMGAoY+RWNMuSYpJUSKybeL2rm5tDpXtXHemkobY5pmkTM8f/5yuVx2XVfXTc5UTr9MliGkGDMAY0KFmDMgl0JqxTiPSImoPAz0pt+V0v1MnHOmFHPwCFlxzpCC8zlEI9WyXeQQ53nuh+P19eUwDJXS9Vv0IL+zP3D785oA/iX2ledqIcQwTG3b1nV9efWKiM7OTm5urg6H/d/8zX8rJf8P/+H/e3Z2+uzZk4eM7Xvvvbder/f7/TAML1++fPny5dOnTz/44L3zi7PDYXfs9qenW8bh5csX3tlmuVLKLJfL/X6/3W5zzmVtW2qwQojFYvHixYumaTabzeG4yzlb5zabTUrp+ur1+dnJ1eVrzIkzYEQ5xOB8CSBKH/8wdjnnmLy1NlMEIIqRclwsm7qu9/u9ny2kuFq2lVHFfTPGhFBSSiGKtqI7Ho8nJyfDZNvF6vLyuu+Gv/g3Py1lXqV1WYmXWKEsVB+Ef0uGpxAblNMpbw4hFPHIQgLaNE2pY1dVVZR4i7MrsULpSCrNTcfjcZqmtm1LL0V3HMZhRuB1s5BSz9Y/uniy2WzKqplz3rYLo6vd7sC53O12KaXFYlVCnLquhTbW+bLidi4AsNJMVxJQBY90c3N1PO5LxX4Yhk8+fn56en55edk0i6qqhNTDNJeaR5m3Su6u0KAOw0CEUsoYsmmacZpKc3KZBuq6ttMMOU7DyBG6wzGFuFosHz9+7L3f7w/jOJZ5sdTJS4qsSK0VsYSS5qqapm5bU7dMypTS7HyJkLTWQjAAyBRTCN46N9vCJVe6zBDR+dk5l1JcLpeMY6Zorb27ue2HI+esUHB/Z3909iUTwDcd2nyuIeArj/O243mgFP/s28ofP3sAXxzkc4f3rucbYy7gk0JF6b396KNfayP/N//bf/+LX/z8k08+OT093e12fd+/9957VVU/Or9YLdqxnw67Y3lQn1w8+m/+6/+5tfb6+lpy8fTxE6n4b37za8VFQc5YF4ZxVrr64MPvf/Txp4t2paSZRts2SzvPtzc369WiqU3fHSjlJxePgveXL18tl8umNnfXV5AiUJrneZqHTHGz2ez3e0SsmhYYv73ZSa2Lw805Fb/ZNE1j9NT3WgnB2X53e9jfjd0RchRCTHZWlWnbdrVa3d7uQgibk5Nhskqp169fF4QrY6Ku2uK1h3FknO/2+8urq6ZthZRd38eUALFpWy5E1/eZqKpr531JXBQPW65qQbwU7qDPcgoVNeBSCQ/eM0QptRBKmXq53t5c3714/mqY5s3J6Xp74lNmXH7w/R8AZ4kwA7vdHQjYoyePE9A4TNM0V1Wz3Zx6F1++fG2tr+r23rEqnTJloH4ckLNhGJbLZfIhh1jcLke23ayuLl/1fU9EXT+4ED95/iKE8OMf//jq6mq52pw9eny3PzbtcrXe9tM8zFNB6PoYlKm4FGXY69uby+vrdrmmmK6urhhjpbJSILCFKmqz2QDAPMPNze33v/+DlMiYmnPZ9yPnMmdAxJIHY4zlTN0w7o9dzKlZtMv1qox5t7uRglVaQU6MsrVDcPNqvdDaRIJDd7TWNU3TtG25zk3TCCGMVMvlommq6MM4DN7Nb+P3p7fY1/W8v+393/R+33X8dz3+t9m76ii8ze4XcO+6+6/LvsKZ/4FbgfMXRzAMXUr50eOLzcn5L37x93W1JMb6bkBkWleCq9VqW6nlr371m5To5ORkmiYhhNb6008/LetlLQWy9Omnn+52t8mHwm/DOZ9n973vfei9L0vmkhgpK9+S8y3LQAYIkKOzxijBsT/sjVarZRu8rbW+7Q61UXVdL1fr69tdznm1Wox2LCkX7/0829pUdWO8013XNUZSDrvdrbXTelFXRkc/3N7enp9uVqsFIl5dX5XvvtZ6nl3MiQirpm6XayllzMn5GOYpBFdgPIhY9lWS3eWiUWGMACinVjAwJYVdrOiFaa1LzqfEBA+goHEcp2k6Pz9njL16fXV2dla3y7/7u7+bZ7dcr5VS4+zmblgsFu1qpaQhSs7NMcaqqpRU4zBP4wScCSm74zGFZIzWWgNoIRQyMdp7PXrOBOcRAIricUqpXTTr9Xqexzs7pZSK/IAbwwNVw4PemdZyvVpsNhvJybpRKbVoV8FN8+Saps0JGBNEFHOUQhcOiZSIEQPGgAByFoxLfs/1NgwDIj5+vCqkp4VvrmTnSh2l7FQIgciRZyY4hWitQ2Qlv0SQJBcCgXNUEpFllgEo5OChFImQE0MiROTEMGdy0Qkhco45JimlUiJnB0TwB6Z5+539S+zbSQHh7w25+ZeM/zDB/utMNsV1FtdWACQnJyfj2Jel9OtXV9Nk33//w8ePnoaQx2HOGcraeRzH4dit2sVisZimKYbAgBZNlYL7zT/+o5/tNA9S8uVqg0wgE++9/2HXDVpXicD6wBiz1t5jZkxVig+MA+WYU6iNoGCHvsOclosmOnd7c6UlPz093R2OhIwLGVOOmYjQ+0jIE9FDFREhh+il5NG7eezbxpycrDimaewAoECDvPe3t7dSKS4VMD47+1CGXSwWiDjPc4GKlzhAa13auN5UDmJZ0RcC0QIJfaAqozeKiWX+KwmNkikq6KMyW3jvD4fDer1G4N1xaJqFEOrm5m6abN0spNAx5BCiMdXm5KSqW+u9kNqFGEKSUjMmijTNdnu6XK65ELOzLgSpTYmKxnFUSlXtwhhT17UyunyvyozFOReMQyZGYKSqlJSM13VtjM6Qq6Zan2xR8BAjIu73eykl5zKEWIgihKpUVSGXMSPjijOdExhTVVUzjnPwqfQSE2EMmXOptYZMiKzresb46elZqUIXCryS9C9Q4KZZADBj6hgjAudSAfJpngvZEQO8T/hTFBy1ZJKR4qQ5McxcKgKBTCJTmRihRCZcSJOdi5y9c05LXmlN6U+HHfPPzb5EEexd3eVXdq+/5zSAb1lx4JdpiuF9B/VXObx/oXnvC/FkoSR79OgRQH7+/PmTpx9Mo1XKXJw/qUxzd3eYRts2291ud3pyZq2/vr5u21ZrfXV1RZR8CKen26Lc23Vd3ai7XVe369VqdXl1d3Z2ljPc3uxW60XxgLXR3vvSU1bQkDlnJWUMrjIKUtzv7iRDJTnmnIsS7GpFRLe3t+ePngghbCRkMuWCZNVKGcHVAy5eSu697fujEHB2fiI53Nzcdcf9D3/0ISLud8dx6jmXxpic0jiO1toUiQlZmVoIMc1unh0RKaNFZIhY3Hep95bpoQB7YozOObqXKEml66qs8UvS/7NBz0Plo+TKHy5+KQLX7WK/3++P/fn5uTZ1Nw7Oe1NXq+WGCxVzQuQpZcr3xWdkhMjbpl6tF2PXG1MnHhlDjowxlmK20Uuhs86lws2QZ0AmeJnS5nmO3lk3cc6rShNR3x83m7OUknehKB7fTxVSHA/79WoBjIo8TkoUQjKmBQAi4kwSJyIudWV0tT/sGAEASOREKYZQVZUWcib7UDYvvWPWWik1IhpjUkr9sWuaxpg6pSS1tt2xNqXTjXkfg0/lmkNOwducM3KupESeOTCtORfEUCRLmUlCGQGJMWLcBR9CVlqNIzjnVM2k5A5y6QWnt6SUv5bn7l2TN9/0su/rGv/t5/uv0Vr9rRWBv9Eg4LPJta+WaPtKluva5BwZY6enp0R0d3entR6GSQj5b/7NX73//ocff/z8V//4cV0vnz19zJl4/eL11A8n640x5urq6vmnH8cQ1uu1VPzq6vXd3W1V6ZTS2A+PHj3inI+zffz4ycuXL/txqOq2nNo9uXEmSJlSppQZkhQsebeotHd2f3tzul0awbrjnkG+uLiIMb6+uhHKnJyex0RzSLppq6qRUitpijcXQhayfo5sHPrgp6bWDOL1zetjd7daLVarVTcOs7PW2tPT05Qo5zwMQ05QvHyB8ZTyxj0AVHBiGCmHnCLljEAMmRTAWUYoXFQhJ5+ii6Gwpd7PKG9af2OMZbYrWaCSKQKAoujy+uUrRDw7O7u+vt7v9ycnJwVMxRhfLtaLdgXAvI9EWNd1yZ9IZULMLiYmBZcihvzq1SVjrG1bhgKRCyFQcGAspBhT6sZhcrakpAr2sWCBhmEoiCAhBEPMOacUZj9bNxEk5+Zh6Erua7lcxpzG2RHjyhgC5myy1mdCAEbEKSMQcq6JMPgYY3IuUMyUwbuQUuZccMCS9BNCvHz5crXaTJOljMvFGgCEEJxLa33XdcMw5BgRMSegjIj8PgecGYPMkSDHGGZGSTFgOQhImmcGmXEZgCcmspAROOOaC2N9BGTAePnipRggE2fAv4wL+jv7w7d3iADeNiP9Pu7195kG3hYBfHHwr7aLr/D+ksEoS9FPP/3UWv+9H/x4mhNlYWc39jH49IMf/OjDD37Q98FIczvcXlxcXF5e/of/8B/Ozs7ef++9qjKnp6cvX33y0UcfOe/atv34k19po773/Q+ev+4YY8aYX//612WxX9CWdp4KVCOlFCAwxgrJJUNglKOzMbjN8sk8DWN/BICmadq2vb7dcaFcjMSlNvX+OCxXa4E0jmMMWSkDACWRNcSZc2yaikM4HPbdfrdc1j/64fe7rh+GsVIKYNG27dXVFVCiQkrMmNIVCh4D5ZyZlKbSEEPOsSSCHq5Y8YkPeZ6yoi8QzwI+Kav+h1z/A/a0JMFLQFCg97fXN3VdlzZgxlgpFWRCa129aJEzH0Nd69Vmw5jYHbpxmutKFfGvnDMRn+f5cDiElIypjZIppRjCPMeUAmNsuVzP81jwAQAQY2RCTmGWiEIwyRWBwpycc1Kw1XpBlFJKjIHWcpoma21d15xJxsVudxuDk1JIoZumncc5xhBCFoJbH3PMwHjwcU4xZ2CI1s9am1LsCc4DMMZEivfoqeORfvLDukRLi8XieDgsFovlcjmOY6nD13UtGE8phZBSJI6iJH8QQErJGMQYGEiGyYfARGSgQ7CsWSeMxJQQJpNgSkulPSHn8oGDOoeJkmeMARC8ZcH6dfmTrysC+LpW1l/X+H+mEQB8Y0HA5/L+/5plAOdccVj7/X6apiIJUFqZrq+vj8fjhx/+8C//4i8YilcvLwusZZ7nv/3bv/35z39+cnLy4x//eL1eu2m+fn1ZADDB22kYP/zwQ6VU3/dnZxf9OAqlzs/PS7akVAIfyowlJyClDMFrwfvugJAXbV3oZXLOOYb9fl+4eqSUu90uxti0y36YiBCAhZAK7jDnvNvtSqJAa13VZpqG42G3XLVPnz1BpP1+91BsLD63eP+S3y/5+lLyLdfkAXjAP2MPAAZ6009QpBQYY5vNZr1et21bZgJ4M2GUdrOChwGAeyIgpfb7/Wq1yjkfDoe2bauqKuo3dV3HGKdpYkyUdlxr3W6301oXbuecodBTz7Oz1l9cXJSGMs65kHK2dp5dQZ2WsmrxfeX4H+6vlLJSmjPmnSt/JEhEqap001TWTt7buq6J6OrqqlQUcs43N3fTaLWpuZTOhpzJWjvPM2W01nfHoTyh8+ScDZQxhORcyAlKtR+IIfC2gZINe8iMFYxA13XH45FzbmfnfSCCYJ23ruTrc4yQyWhFOYXgU4oEMScHFDjLQElIDUxxYbg0jEuptTQaGBJD7yPnvKj6eG8ZEaW3UkF8Z3/I9u33AfzJwIFKv9JisQDkwzBtt6en549fvbz+9JMXRtePHz99+vTZdru+vr775NOPlqs6QrjZX/+//z//r5//4n/6y5/++N/+1V9aO49j/+Llx4fDrmkrpUQ39MDw+z/8wfF4dG5+dH46dMftenV6srHzGEJIwc/zzDhorQuVi5CsgE+UUl3XCcY3y2UMzk6dFBhTsPNwOOxu7m43pyfIxOub2zmkxXLdj7PzIUbPMbVGYHLH3XWwPSWPkL33u91hntz52aNlu3zxyQuKSXE+9kMKcXfoTN2iMEI3IBRxGQlizIkiY4xRzsG7YEOKOecMBPDbhqMHzE9x7g+J/tLZK4QiwtLQlDMQoVKGMVHIywBYjJkIpdTbk7PLy+sY82q16brO2bBdredpKrGR1vrs7Iwr+fL1q8urK2Wq5XLNOfc+FNI072IiNMastychpX4cELGpjRTMSHFxdno47Pr+OAxDCPdc33VttNa6rnKGIhDGUFBG76OzwYUUY2RSCKEmO1triaF10+X1FTA8OTsFxj765PnHz1+M1vkILqacwHrvXSSiYN04juWr5YMN0dE9w5sjSPAm8QUAJycn1tpSmC2loBCCi24YOgDYbDYEeRwHTpSDLxn/ROBSjIBCquBjcCGFBOk+DkMlQEgUAplErkBo5IrLSqoaGQcA761gWFcaIMeYM2L8rgb8x2nsy3i37ymzIVOhzy1/fFd+7d/xkc9+sOzlYUf/8u1tONyywCmrRfhMJPWuegZFmeCL2+c++PD3EFxVVSHmcbRGt1LUds458fff+8HTp+9vt6cxhk+f/yaT/eD7j30afv3xz//u7/+Hl68//q/+F3/1f/w//R+EzCnPtzcv9rvr7WZpjHzx8tPb2+v3v/ehC6EfhmdPLwSmYEfMQUuxu7tqaiUYNJWGFLWWV9eXMcfVZvXy9cu6ru8OXVUvNydbY0z0k3dTUwvB0/vvXQzjsWl0SL63U7vektSiaW3Os5uFhBwmN95Oh1fbhvNs33t08vyTj/a7Q4jw3vs/ePzo/V/946c5wqqqpuOu0lIIMc3+1e1eLba8PZlIvt4NAfhye5Jz9mFSjOapl1JyJZngGQEYcimAYUjReie1KnjQ0l2VQ6SY6rr1PnofGRPeR85lVTUxZs50ijhPibNqdzdotRC8nqfE0DTN9urqZrXaQMbKmHmaJEM7T4qLdlGH4C4vX/V9b5p6vV53XQeA02i7rpda66qSWj968p4UehgmRL7f3e7vbjXHZ4/P765eBW8rY05OTgokt3DzbdYnUmrvgjGNrhbj5E3dbE8u9vt+muzJ6TkB++jTT4Cz0/OzYeovr68Xq9X3fvgD65wP4fs/+pGq6uevXu+7noABU7u7gzS6qiof7Nn5ieKMYW7rWkpmjBQSY3JVLUwl++EYUiSEmJMLgUuJAkc7KiO3pxvr59v97dP3n/rkd8cdg5jnHuep0jznKJsqCM6bNqIapyjQSDDZoXcw2jyEkLUaxyhVPU6hG1xEzUQlTeNTjs6u21oymvsDQ6yqKoFwEZGJzwLS/3nXw758yzl+6fYFIPs/Y2/zD+86zlvtbbopb9VTecswb70+X25ve/8/O3759XPjfPsRwDdkv+PKfkM7Kv1KRclWSHU89gjiL/7i3/67f/dfD/30s5/97HA4VJXJFMapi8n99/+3/97U5n/3v//v/v2//28Px7vj4W4eu647SsWEvCfIXKw3JycnwNg4jpXS3WGnJW9rc3dzpYWUDLvukFJo2/bq+rJpmqapbm+vz85OpFYPiuElHbxcLm9vb4/HvdQKIPvgSpZpvV5zzg/dcRzHqq3aWg/9bh72Z+vmhx8+fnS2/sdf/sPji/P9/vj0yfv/1X/931zfHqbRcSaHYRAMEdGFwJWum1Uk0c/OZ1Dt0rTLSOBTFEIIySHn8uUDzjjnwBkxLOkgxlhhlSkXUylV1zUApEQF1uK950zmBHb2JTeSMyCyEGII0fuAyIypFoslAD57+v5+d3z06FHf9+XEGWOLRaulurq6ijGaul6tVjGTMfXl6+tpsuvNmVYNF2bRbhiX+64zdZVznuxcFM/neZznsdBRTNNgrZVKrNfruq5TSofD4dHTZ4zz6+ubuq6bejEOs9TV40dPU6L9/hhi1qoqAutcisdPn4QYR+uYFBnBhZgICBnn4vT8bJ7dq1evjTGEeHNzU9e1c+5Bgth7L5R0ITjngN3rG8ObNojSLleK0vM8CyVzjlWljVGcwXA4sBwro4XiKBCZcCEe+6muFgxl8BADIZMgRCCcXUxElFnKLGYGKBOymCnn7IPzYYphztHnHBEZcsGE/Nd53L6zr9f+NCcA/EJ14ZuYD744eMk2DMPABXvy5NHJ6dba6R/+4Rclmb5aLx4/frzdbm+urv+f//f/x+PHj//93/x3T548ZYzXVUMEv/rVr7TWTb1AxFJF2G63JycnJb0uhLi72xfigaurq7ZtAaB49q7rpml69uzZ48dP59nFmE+3J4u6rk0VnLfWfvzpi6ZdTi5K0xzHCYRcrjdKKe9tCjYHqxgwTFqAVkIrsWjqtq1TCnfXV/3QDcOwXK9+8OMfZaBxtien54euH2fLhYkZxtkpXVVNEylbFwD5YrGo6zpnAGBaa601E6KEYuValUDt4S/DMBRKuAexFyKarOVSZoBhmoRWkfJo54xgg88ITAgXgo9xnOeQEhOiG/r98RBCKBD4lBIXopQHmqYpnhoR1+t1odG+2x+P/WCqplmsfEiJUEh97IdDd0yEiVAqs9psQ4p3h73QRgihtC4jFz1exlhKqWmaruu6rqvq2jT1cej7vm/bdprs8diHkJbL5XK5jCGPsyOGdV0fDt1sfVW3jImHea6u69evX5dO7Mvrm3l2Uuir25vZuUzofZwmW7RlUiJrneD30phv2Jx+C0wqHXNKqaIrUC6stVOiXJJs+JnCmK6bDGwO0WdCJpCpmJlzAYghcsqIyIRWhZe7kN1667z3IficM5WStPjWWkq/s9/HvqSB+G1vfbf46Fu1hwP+3Iuv8by+dBdlPUtESsi6riHl29vb4/4gJFssmpTS5eXl9fV1Smm1Wv1f/s//1w8/+GB3e3d5eckZK9FDUdiYRnt3d0cZT1YnWldIbLXaeB9LTbVIoJSusRLKdV13cXGBiCGE7XbbdZ33XklOORLRoe/6cVJ1y1Vl2pVP6CMpXUmtkHLwU5hHw+l8u8zeTt1ec1i0JkV3e3X56tWLUkT98MMPg08f/eYTXdXExegCMBkBJ2tdiCgVMBYT3XdpcelDst4Dw0QYUuZclK6F4vrjGys11Qf+sgKjIqKU6OHsSn81EYUQyuUteymVz9JBFkIos8inn366XC4P+85UVd/3uq6qug453+0OTbNomkXbLrp+nGd3dX2zOTl//OwZMu4zMC5sjHf7Y8qsH0fG5Xp7moHu9kcfUtO2wzgWb1sOyVpbfm2a5vLykog2m83xeJznuUQeN3e3ZXqoqiaEVNL0Z6cX+/2x1Garqgk+5ZyNrhF5jOH29ppzbJpmnucQMzA2jrOP2YVMBLe7PRc6RhJc5wQPjdOlbF7yG0X+rERUhRl0mqZ5nl3wUqtMMQRXqApDCJzLzckpII/AU4YIPKFImcWEIUHMjJBnZIzztm3ruhWCaa1zLNX9dB9/IJVI7vfyQ/+C5/HrGv87+6z9aUYA8K/VbPzZF4yxaZoQ4PR0yzl++unH19eXq9Xi/OKUc5ZSIkq73e3HH//GGPU3f/M3m9X27/5/PzOm3m5PX758+erVqx//+CdIOAzD7e2tt2G73W6325wghrxsV4VNE5H3/VjXdQkIqqrp+3673S4Xq/3u8Pr160IL+urVC+fmeR5NpVLKq5NT4krU7RyhXZ0Ms++G0XtfabWoNIQx2b5RqHmmMNvxMHZ7P40Mqa60FvyDDz4goleXr4HhZOfXV9fa1KpuXKLBhkyYAWYXUkp1u6jbBSJOzsackQnrw2EYY6KYoaBWgFiRqaKMQExJU5mmrlulTIx5mqz3seSFHqSvxJsAotS3EbEQHVdVVfAwMcZmsZBaW++3pyeEUIDwi8VKKX08Hm9vb5+9/37TLgDY9fXtNLt2uT1//B4xNdm4WG10tRjnwLWWVT35AFJkzm8PRxRifXo2OT85O9p5dtbHkIiAMS4Fl2J/PGxPT7Znp/vueOiOm5Ptaru5u7szulq0S8Hlfne4vrmNmRaL1XZ7OkxW6mq93gKw/bHzIWldAcAwDOv1ujCGbjenxtT7Y3/x6CkyFRMiq/aHSavG2cS5LqFDaaIurv+hQ6LruiJPVmbWYRgK3kwaGVIqCE7GhJ2snb3gag4pZEhcoKgSSBvABcgkfYyJIKbMuWybZaHYk5Jzjm9wW0WvGwgA2HeCkH+U9icYAcA7poC+2i4+N3gxzjGlMA2j914rpY1EysPQASUGeZ7nFP1qtSrP+SeffILIF+1qHsYYskAmubDW3t7edl3XNM3Tx8+aZpF8WTqnGGPTNAAwTdNisZjnuRDjrNfr1Wr14sWLkpX+6KOPVqtVVVVNbSTHlNI4TVLpfp7r5ZopM/kQMyilcgxu7CDMLNpa0nS4XTTm6fm2kizMHUQvkSintq1jjre73Wq7cTF88umLul34TEyakDIg51K7kKwLTMiCj1SmUsooaZSpAbmPiRgCwAMG9OG6FS3GkjIqHQClrfeBCrQ4egAoeKGccwkRCsy0FDkKSVlpCa7reprmuq5HOzfLRdO2KaXDvkMuis/t+tH5mDJ77/3vx4TPX1xOLi7WJyikDbFdbJjQQlaAvOvHcfKr7cl6s73bHdabkzItlSxNme/v7u6896enpzlna+3FxQXn/OrmumkXiLxoCPd9n1ISXI7j9Otf/7qqqvV6q1U1DMPxePQ+AgAQk1rt9/sExLjcHY8xUd0suKyASc5UJoYgGMoYyM4B4bcUeA9fv3IMhWa1gIJKsgsAFouF9z4mDwBFqJ1imqZp3/XWBZcgcQ2yyky5hM6h8zA7CgkiATBh6qa09WG+J+LGN6k8IgL8OjFAv/uh+86+XvsTjADeyft/XbsAAEqpNkZK6YPjAs/OTpfLdpqGeR4RaZ6nly+fD8NwfnZyenIyj1PO8JOf/GQcx08//VQptd1uX7x4MQy9d44ztt1u27YtXGBCyHm2ISRnQ1EJllJ33VCQ6cbU4zhP07RardpmYWeXExU5FKXk8XgMKYZMg3WqbnTT7o+d1Gq9Xjo7HXc3LHkjYsUJyWc/Yba1Yo2WQM7O4zQNQrJXr14VUObry+sEtFxtmFCT95F4tVjJqnE+EjKt9ez8yxevigBvuUKcS4Yiw5uO5c/UAMoFLGl6AChNDERUVqyIGFLkUiBnGSjmxKUIKfoQGOdSq5hTBnLBZyCp1TCNMScu5fXtbT+N1lqtTEq5H2fr3eNHT6fZHrrh9nZ3enrOpWJc7bohEJp6EVL2kYSqYiIXE1MqIQMhqsXSxrTvB900dV0jZxmACQEMrXf9NE7O1k3T9X0/Du1y0SwXx6HfHQ/S6MnZYbLWRyZVVTU5w+XVzT/88qNCxLbvjoduQOBS6JjuaZxfvnxZhO8P3TFSbtr1sRsIhK4Wsw+r7YkNEYW8u9unRCU8KsB/uG/pYoVPqfwaQlgul2++MLIfB0CUjAdrc4yVMUaaaXSBmMsQQGZuiNchy9FSP8YMHLgA5FwqYwwTqmR+ADJSghwpx88Wcr7eR+w7+9exP8EJ4HP2DX01vzhsaSaqquqDDz5YL1e73e3QH0/P1sHZu7sbZ6cnjy6+98F7pTTnnGvbNvo0DUPbLvvDERGtne92N0KIuq6XiwURdYcuxmSkiiGHEIqOfMmMW2tXq43W+sWLF4Vi+vb29vb29sMPP0wp3d3tC0GYtXa1WpmqEkIBMe89E5xzDN4edjc52LPNYmnkeLi9OFkd7l7/+le/HPuDFEDJQ/arRXPY7RiHR4/P/8uv/nFy9oMPv//66vLJs2fD5BPyul1KZULKnHOh9DzPv/zlLw+HQwihn8ZhmHxMicC7WLgiin1W0bckskv2vywtQwgZgb3R/3po933I/5QaQCEKnaaplGQBYLVacSmK7m7KebLz/tiP80TIHj19utsdjv1wOPZnF4+E0rtjFxM+efrBycWjcfKEbLnejLOfXSBghHy9OTk5O319ef3Ji5dP33t26I7OOS6F1jojOOcY50Xp/nA4GGOMMa9evco5n56eXl5elo5oRORMlhsRY5SSDcOw2+1vbm6stU3TVFVVLkjfDavVKqU0zNOjJ8/a5fL67g6ZzMRM3ViXNuuTkrTZ744hpHGYCwlgGRkASpkE3iAIQwjGmMKwlFJ0bhaSI6Npmrx1i2qxXK4Zl4AioQggAldRmIjaBjbOGXnFZcWFFlIpbR767+iNCHN+8+Kbe8q+s2/aPs+SX9Zon+3YfMD2vm2IP7SQ7bNH+9mDf6ckz1c4/rqu27aVjM/znFKoap1zev365Tj21s0/+cmP6trEGL/3/vuMsevr6wJMnKbJGPXsvScpRefnoTsm72L0OUfAjHi/Ri6Ct4yxGPJ6tUXgbyTgfdM0paJY121Zd5cMQHlxdnbmvZ+mqa7N5dUrxqA1Ktp5f3O1WdQ/+eEHkOarFx+vGiVZ3l1f1oqfbBY5uhR9DH4cDoB52TbTNN3eXj99+vTnP/95UaPcH7qT03Nk4m5/WK/XlCGH+PGvf7PZroUQ0zQV/vrSqVvIiqXUzoWUaLlcH4996eSSUh8OHQJftKtptDHkum7nyZWSeBGSLEJaAFA8Wul0RcTj8fig/K5MnYGFnGJOy9Vaa3M4dIyxnOHs9OL65u7Yjz6kD773/ZByIkwZq6YNKQ+jlboWqvYxV027WKzqum0Wi8n5//E//qd2ufjeD77/6vKaGCJjLnihZIgx5LRcLveHw6cvX+i6WqyWt7s7LgQXQhtTNfX17Q1ydnZ2BgAoeL1oY4zr9Zpxzjg/OTnRWk/Obk5PjkOPnFlrrbVSGW3q2fpXl9emXdwejt0wvXp9+ZO/+Mu//8U/tMvVL375X1KiIv9S/P5Di3LJklVVtdvtCjvsbrcDgA8++OBmdxdSSBSHeYgxNlV9OHR3d7uzs0ebs0dzwsElkA03y5dXB6EW+86NLmRiUlftciuEIgKtq1K3n8beOcsYpBxDcA9HUh6cd+oG+Jfbuz6/n3uQv3IfwNuO5137DL6t6/AA/P/Sw/gOvPW12X02FjA6a2N2IYYIOcMPf/TjnNh/+k9/+4Mf/OQv/uIvfvObj0brNptN13XeR6VUbXQKduiP3s5VrSXjMSEiKSGJyLsQUgohTNc7Ju5JCEIIq+WGMTaO42q1maYBEZ1zRUrQOSc4W7fVMRy5tZzzutJISTFYVPq4u0byZ9sVRqswh3msNF80RmDUigHFebLZW60YQoLEVot2inEY+qapXr58/ujxedNU/+k//49//dd/nXO+ubtTSgku66o5HA7I4OnTp5KzFKPiAiiVr9zsbAyhpCnKtTLGFAGDwuMmuSgZf8YYFD5qrR5ofx6qneUiF73JgpZpmsY5x6QomRAAsMEDACEAQMyETLgYfT9mZMvlSmoTEillckLOJRMSgPmYUgoMgQkebGKMZyIpZdXUXIl5cofDYdXqQlbBBEdEQCxhChO8TLEpJflGr5gxVtd1CVOcn4cBCn1T01SIONuJM/xsSWO5XN687vANG5IQApkA5MAFYUAudsdD0y6Ox2Ndm8Nu7/zYLk15pEsW6E1+BiDnsiaY59kobYxxzl1fX5+ebTnHebZ1tfaz3a433ZyO3fDeD3/6Yj8nUDYhCNUszyOZTLNSC65rTcSlAiYQGctZSVHiFY73C39CSEQZgP2z5Fzf2R+eMfin7Plf40z152bjOLrZejc755ybMyWlxWLRdN3hbndzenby4YfvHw77169fG6naui7JnKqqlBaFbzlEVymFCFIyJRgiIWKhdrkHujQLpUzOUKTec4JhGKSUiPxe+Nv6ArYMIUplUgYfA+e8qQxEr3gynMLYVZjONwvDiVOY+8N62WzX7TD0goGWPIdA2QuGADllZ9307PHj2+tX3lkl2HLZfPLpx23bPnr0KKTsY1quN1wwLtjtzXVt9KKp++7Q7XcFhMoAipcvV6kAFgHgIUMSY6zrugDMiwcsb9ZauxgKaahPsRCIFj5Rn+LueGBSEENdV5Oz94kgwQG5D8mHBMiR3wtJTrPbHbpM2C7XOcHx2KdMyBkTknNZAizvfaLM8L6sWuabUorw3jvnMlDICRiLOSfKnPMMRAyNMTEn6z0hCiWZ4FwKU1cpJcDMFasawwSG5DNmlzzjGEKY7MwlYwz6/ui9lVJ67zmXRVMBuSBkGZBxXi8X1bLthr5q65u767atkdE8j8iorOyKR36wMkEWIFARrRzHseTuGYdyYbtDL7lSQsfMXALiyqy2nunZozDLYc7AawKeCZiUQKzwcJT8W0nf5RQY3nfXA2aC9O09ef+MfefffofdRwD4mUDpXa/RH8s1/abPK4VIKbN71jOuhBBKCaVePH9e1Yv/9f/qf3m33//87//L46dPlRLeZ2OMllJyNs/jOAw5R4GYKVo3Fy2R4GbvIyAJxhQXrFZlyS+EGIbh4uIipVSZpojfAlSli6o4VoCckTGlhVAESQmOOShIYbhbaFQsaxYPfsCUvJvWq4XW+vbmSnJsGjOTzY4JhkgZKOXgucBx7CVXppLdcb+/u/3pT3/ad8M8z6enp1rraejncbB2evzoXCthp4FSbswipZRzBGCUcuFKYm86Hgq856EeMI9TqaAUFFABHT5UBYo7Lj8ZY8MweB8edMTKIFKZBz6c0jfHuXA+5nty5qy1advlYRgPx65pFqX9qiDaY4xEOeecKGutBYecrXMuxoiAglHTNIjonbsnJI1RaoWIwBCIPXjeMiBjrGlqO82IFON9zSbnpPS96hnnWACUMcZpHqy1fd+XBA4ihhAY8uCj956QtYsGIe9uO8Fwt7tdrxpjRMr3cQZ7w3eCb7hPhBClMLBcLjebTekJePTo0fXdp+v1ctmsOOA09Fx0zeaxXG5/9fGng0sfvn+WQO8PPfDaur6qVi6Q9MS0JsaAkHOeKDPGCqUro8QEMHYvKvMVnqO3PV6/e7SvZp/1b1/7mH+kVo7/80Xg38E18Z39bmvbWmvJOTIGQjJE9MENQ3d2dvL97394dfX6b//2f+ACV4tlqZFWWnLOx6m/unrd90elpamE91NObr1qqlrOdhinnihxzpFRobZ/4z2llFoIUVJJzrmSTP8Mm6bo5xml4lLHGBkmRr6R6Lq7lQGDgWwHYWYUpWBGqtI7VsoYxYuF6IiS1np7srl89VIr2VTmuN8Nx8MH7z/RSux2O+fCom6Ou72bbdd1y8Vi1S4qLSutF029bBsleAzOuzkmXzL+jIlCuimEAmBEqHXlXJgmC8AA2Dw772JRMilyhmWqeAAIFZHb0nHdtm0pdZa0idRKGc3uebI58nsGaeSyaZftci2VSTEDsLpuOecUoahpllUzAMToCbIQDwSlRekEF8uGc+5jKORFGaFqGyHl/TQGAAyBYcjJxZCApNEnZydCiWHo+747Hg/WTYtFs1ot+qkXWnCOMXofXYYEjG73t4iolAJCOzsb/OzdZF3J/nnvU47j2OccD4c7LoBzJEoPud3Si6uUKvDZcvoFCFSCqnaxmJyd5kFr5exklHY2NHVb1Y0PpE3NTavbpTRLoduUlVBNyuhi4kIhE0JJXemyvOCAkOL9Sb9xF38s3vA7//Y5+3wEAN/8Svnbsrcd59sWBe/0fvYZkoP7D2LOiWKgRxfPnLUf/eblsydPpG5evXq13px03cSZ8n7a7+72+z2nqI1ApEzJGF1VJmXy3uYMQCnElFLSRoRxKsJYhUfae1taZIvOYjmwUokKOXkHAJwQYoyaEUTfCJjTzLMGcm4+VpLlnHWliej6+rKqqroxjDHvrXOOYSLCVdsyIKUEZrq5vVo2rRLSKDkMXWkB7fv+6vpy2TYMab1eUY798YiUEBhB4uKeOr9IYhWwY/G5VVUhQc65aZphGADgt+2+iGUh71NcLBZlJV5VVVkd11Xb972UIudcEtxKKalVpntyIaVUjgkAcoJINE8OhNRGElHXddYHpYxUyo2OKGdMb2plCECUc0ixNlJwrpTQvM7RpuhRSgRWDjLnLKWoqgpSTJwLJTmyAuZhCMURM8amfiiziKlU0XDXWiPSPI9VtYWUM0VkVHgvgrOaMSllJooxKjIF+cqATc4qAYQZWVpuly5aJSulWfmm3fNCAxSnT0Rj35+enpaZ4Obm5uzszBjTD8fFoiEG1lrn0un2fPa8sH+fnj/aezh0Q72qiMtMIUSyLplMyTpRp5JXFAxKDeaBd7qkVYoMwMOLf/lz9K1EAP8KY34Tx/9N2G8jgO9yZF+LOecopjdYgFQWdE1b7w93z59/WjfmvfeeOee6ris0BiG4rjtM0ygVF5JP0zDNY5FeidEXvarFYlG4H4pnJKL1el1IFMqaPaXEUAh+X031PsaYEVFJo6QhZKm4RYS5PyLFRnKWrOFEdq4k984KhoC5FCSIyFpbXpfsgjGm73uGNI09pLRsW6Xkfn+XYwCAuq4Ph0OBHkkpucBh6PvjkVIOIczjxPE+lWSULmvGklVHxMKbVJx7aa0qnVwFx1L+Xsge0r0ypSyvWXGUObdtWyKDh46wBHRfKOYspFgGIaKUCADHcX79+vU4jlLKGPM8zzFGjozj/XofCR7AEjnf1yHKvlKORfC5aZqSniqzUakTCCVR8ASEjBW+oBjjbnfrvVVGrtZrY0xKARglylJKqThB4hy1lkqJujYFtSWELEzXpY3u4cF8o7gAxmjGIGXfNDVg/lKQW1GJKZLL0zSVf/V9X0iZ+r5HRC1VXdd936dIQkhT1Ye+J2Qx4bEbXaCcgTNpfRzneRiGeZ4hw71oj+TIiOifJP3/kFfW3/m332F/uLftj844l0yKghIpWWlEUkp13WGzWT26OPnZ3//n/nj3+GL74vnHlWGcUpotp7xp20orNw7jOEoutNZFy4lzvly2QvAYPedsf7izdpKSD0M3z2OMvm3b9Xr9kEkvuYKcs1KmaZp2UTMGmTznhIyGsYt+kgIkkhY8p4CQ566jFCVAJZSfp5KIR+S6qlXdoJDAkHP+y1/+0nv707/8SWE9E1rZ4L2dayNTdBfnW8FRMHDzbKdJa7lYLJTkRVOFc57SPYtDySE86MOEEOZ5LlwFD+ouWmvT1N77IlDDmIgxB584k5zJouIrhIwxtm1bPmitReAAQJFKLr4M5YONMVRVZZQQgifvuuOegleC5+CtdwkiE5yJeyAN4T08STDw3kdvATNDAshIYO1ElKqqKpFKjHH2wcUQYg4pztZP81wmHB9iP4wZGXBBjCfAcZqm2Umpl8tlKcwSUZFfLskbrasEbxiVpdBaayMLJkoIJgQ/7A6lFk1Es3PKGARZNso8E8+AJaXWLFazcy6E5XIptQop+hgAwPtohLHWaq1dsAC56w5SYdcdGUdEXlcNInbTCJzVTVNVleScAYTgUgrAgDEmteAcgbHChY6QkYAX7/rHsfD9zv6J/VYSkj4j1Pelb33XkIe/42T7ru3kbxv/rSmdt4zz1u9tfst1+NxIb34jQIIMBBkYMJYBvPfex6auBKfrqxfBO2MqIeL5qen2u+XqUc0zZ5SncTjuIKaFqaXSwzAV11k0uRD5ctmmzCbbf++HP3r++hOmwEhVVVU/H4d5qBe1lHKyNhHV7ZIJlQjdNPk0T2MnW+3moWnl+elJY/A4HwWDGJyWYn9zvahVq8TYH6Of28oMXf/+s0e//lX/gx98qI3UOX/0/OVme+pnu1q21k5KixCzkCbnTHlOtt+u6uTm2si7m9sQ3XtPnpbYhYuitpi0rjjX4zhjJiPM7eUtyyy5NNOcItVVC8Qq08QYvXdKV0ob67x1wad0fn4+DlYKs1qJcZyWy6WUKmeKITf1wrvImdxsNi9evEACJaqu7xfLRmv96tWLYRia5aKSxrmAwDD7y+vLtlmFcaB5ikJliiBq4ixE74JnkDLGEOOyNpPLhbBv6g5SAKbs5lFLIZWZ7YSIUulptoyLAunBjPt+kqYBxn3Kl7d3KaXt2ZNj36fgnj59enZBu/1dynDsBl3V42R9zL4bmqYJiQAEQWJcZoTZu5yztdOiabrDLgT313/1bz7+6DebzbJpKmcn79Ppdq31knKqqmYYurpepZSmaWhPVwBwe3sjJNtsVoeuQ4EZc6SYCCmy6OH09KyAu5p6+XRzOox7gRXkJBm+fP7ietevtptxHLkR1k2cEkLMKQBQ3x11rfaHG9OYfJsoZ0TMOTNEJXSMMfOHJ6kgRB8ej7c82W958Njbnuu3PKbv6q/eam8htHjbMF9XCuhdj79E0l809q4oXCqf+s6+JssIGdgXbk4Wgjk/xegrI7Ti83S0c68EuP5Izubgo7M5BlZ6X2PCe9RKKkleomTd3PUHxjGlkHNkDIhSzlEptVy1Sqnr6+vLy0tjzOPHj4UQh8Ph7u6uaZqT7TpFv1kv7+5uGUdr7Xq9vAeMI3HOGECK3rs5zEMKvqn01dXVxaNHd/vDan06jHNVt7vdIeUopRTsXqpXV6aqqqYy89Q3tTFa3lxfNm31o+//oFAxlwX+G3gilY5fKXTZdalh4BvJjnKZHgoY9wENgOCq0MYhcMFVkQQIPjEUp6enBXpf1K+GYZidN8YA0fF4fBM8LTnnw9gNw9A2lbVTY3R/3D85P+OUc3RKCYAcgnN+DtFFuq9qciVLWy8TIlJOKeWS2TcVE5wy5DcBDQqOXJRWZ1Y48bnIwAA54xKQS2XKfKxMJZVOBFpXSpoQUghJKWNMDcBSIiGEi2EY57Ztc47DMGSKfd8LjkiQc2xMU9hDARC5OvaTknXwOSdmdKuUsdYPo2OC120LDK31hCCUnOw82Wm5XDImgBglyDlniACZC5CSKyU5YA6x8JsKo5jggxuJEmcwDX2336ccEMn52XuLnFWNuSfcBoSUvXWUvpME+6O07yaAb9wKnDHGWMAq4zgWFd9+ODo33zugEEo+NyZPlB4mgJKasNb2/XG9XpfXJYH+BrUSf/azn22323/37/5d0zQff/zx69evtdZPnz49OTnRukqRcoKUsnfBOVcwlyUzzhggoxiDtaNzlnKETGM/NHVNKVPKKUSjdN/3JTFS3LpgvMwE1lpTNX033t3u22YphT4ee6VMUdlNiVKimChlIGCAHDifnHMxMimJMRejTykSJYDys7zwKYWcicgYg5wRFncqCCGk6IKf7Fy3zTCN91JiQFyKwnxJAN77AnsvTWcpJa11aSir67pZtkyKBMQYM0pypOht8oERKC4KhionKDvNgDFRIAAuhKmkrpCLjCwBEuMoJGMCkSNy9kbZBhEZE8AFYwIAtNaFmqLMed57JoVQMmUo1EbGGMQyr+fD4XA4HKRSiXKBP0kpt9vt8Xgsp1PueNmLtdanCJw9aEGXkLH0UhBRQdBWVTXP836/L2AqAChfgEKg7byPMXIuEpBPeZhmQCZ1JaSeZlfqMcMwXN9clnbfaZpSCJRybapywUvPRAiBia+NDvo7+9c08cVA4+tCAb3zOO/07t8xzteGYnrXEBK/9FOlremB0yaEwBjPKVg7xxRSkeTOUUqOjKKLDIAoIUOilCmmlMvH1+v1ONt5nlerVfFuwzAdDoeLi4sClbm9vY0xXlxcrFarlEJOcHN9hzkfDsPF+eP5eNWaap6POceYY0ocGSGxmHzKATBzLoahq43quuN6vX716lVpVS3eXwsek6cUUWDwrtC9pZSOx6PWervd7na7/nh8+vRpgbRTupcAe3COxe+UIm3h8CmDP/TQwxtqs1JslFrdNwYDlGbgh76nEhtprQu6ZrVa5RzvdjtELAXke3Cn4Eqa5XJ9eXVdVQ1gfvbs2etXr+q6reqWS+FjiCE9AG1L593sbMoY5sko7nMWXHFtuFKIGSgTJGTEmWTsPl6pqqocYU6Mc844AGHCCJQF4wyF9Y6ZCoCNs63rOnMUQnB2L6FVHPc0TiEE0bSloJ1jiiGv12sh9cvXr7SSOed5nuu6JUrOBill3/ePHz/RQhyPx9mOi8VCKTUMXYwRWWYcS4E659z30zAMxhjJGUcoBDA+RXBhQgs8hJxiosn6qq2RCa50ttY5V7eND/bYTTG44Ow89ATZu1lKyTh6FystUXBI5cvwnS48wDePinzr+F+pBvNdBPC1GSNgBAw+vwXrtJBGquRDdF4gE8istQA555RzaZW6lxfOORbO3ocFfqaolCiyX0XgsK7rsrYtgcJPfvKTYRg+/vhjzvn7779fJgPnwvX17ThawU3brJtmoXVVcOJvkjOh7LG80JpzpBw9R+Znq4Xc390U3H1b3xOWuWlmAAww2NlN83q93u12VVM/efZ0GIaU0ubkZH883sNhsWiM5wf/Xjh8Ciy91KsB4KGRtTh9ACgfKSdY+D5LHFCWzIvVUmo1O9ss2na5uLq5PnRHoeT+eCiIl3tgDJeJMPiEiFyKe7IEohj9OA3H477rDzkF8p5CgJyQcgrRzbZ0GHgfB+vmEIkLoSsmKxAyAhAwZIIJyYQE5JkwxNw0jRAiZPIpEzIsfbwZOBeEKITMCWIiYMLHnAhSIl3Vpq5CzD4GLkUp9rRte/borDQ6ENHd3Z0xZr/fH4/Hpm0T0DBN6+3G1NU0TVVVqiY+I5Qe6UKGkVJKIUouSogWnJdccIRpmkoMUerwSpkC+kqJClsqchZzygAuBsaF0Ca4mQFxgHLx5nme5/lh4V+WIA8NaG9LTH9nf+D2DhHAu+Llv/EI4OvA7/+O97/rEb2B/38xArjX5vU+pERSaMZ4DJExlnIIIQBmRCJIRMA5JoCyGs33va/IGBdKvvj4tambtm2rqrq7uyu8wYUNVEp5enoqhAghFXgoIgLyx4+eKp4vtu3Vi38UXB4Pd7UixligmAkBMkFOORIELZSbbW2qaR7rqur6Q4GEElFBKHrvUyLOJWeQYiJKx+Nxs9lwzgvfPee8wFSq5RIRi08HgodcFmM8J2KMFTFbJnhJ8qQQMxAQEQJDJAREZIL7GJjnhSy6TAnFhe12uwe2u67rttvtm1SPyjnb0QJA0zSlNlAgpGfnp8d+UlpcX1+enGz6fnRuZpQ5ZeDEpWCMJcgpASNmjAJIyAVxDkKTUgRIDFOMjCPD0ueBJQ4BAAT+gC9MQIgcgIBx5DK4uUB+cyapjAiJkKcMUuqkU44hvVH0Hea5bdbGmG5/EJI5Z621z548mmdnTF1V9ZgSY8Lo2jkXY2aMlekhpVgYiuZ59rOtGyW54BxKxCA4SikXixYzee+RcuJcI2NAlMFDjJRc8ol5wVshslDae88YN8bEuUvBcwZGSQ4w29EH24BCRohojAnOxhgJOXLhXEBk747k+BO0d/V7X1fR+G3+8HfbdxHAN24ly/FQ1P0tKplRCM4HC5CRUc6RIEnFSxtq/owVounCfFAQhMXFF0hiId2ENzqFJS07DNNqtW7bNWPcWjdNU0n79n0Pb75zjCMAxRhC8CnFFINWMvogpZwnx5nMGYgQkBFgzsAYU0IiAeWopOz7vlksc6a+H5QxPsa7u13TtIQMGEdgCKx8NmWKKTMuY6JC1JMyKF0pXYWYU4aUIRMCckBeCgZc3OP6MwJXUlUGBQ852eBHO/sUieEwT1zJxXo1e6cqo4whRtb79IbDJxEwIQuP9P1doMwESi20EfPYuWnM3rF8r2zFOVdGEwAIyZRGaRITiXhEQUqj0EwYLgwylajM00woOUxjTCS4kkIj8PuYRShEnCfHuORChZiFUlXTMC4z44EAGEqjS7tWjJ4xKJkxaaSPcZhGQvAp3qf+xpGIqqqapin4pE09zQ45m52dnXXBl/RaEcUszXHRB46sgGKNVOVF+S7FkMv7yyRd1u9MCqmVMSbnTABCMESapw6yb2vNBaVQPla06W3Rpg7pPhdX2EC/sz86+24C+MbtQUYc3wgZ5pwLG0wILgRHlBDvBVIeNLvvV9AApaA3DtPjx4/bti3NU6VGyjkvSJgiMFC6bZ8/f+6c++lPfyqlvLu7647DL3/5S60qAFiv1yXxAgCIxBhDpJRCCPc6M5ip1CqllC5GrU0uWDEmStRfcsoUE2Ps/Py8aOE+ffp0nueu61arldb6gZayzHbsDa94OSnrnbU25iSlZIIXkjUiKgv/QuEJDIEzVZlyKR5QQ4UzpyiIlQJAXdd1XR+Px3JShRGheDTrXUqprmtEfH11nVLo+365bC8vXwFELcXu5vqwu+m7/TgOzs4x+nL9bfAZgHFJXERARzwzwYRBqZnUwHUGlqhMTVxJM45zqYhIbYDxnJAApdQp3YdQiBhjBiaUNOUQQ8wxgzaV0CamFGNUSi5WS8ZYERiY5wgAx+MxUq7qerc7xJCMqbtu8N43TWOt9z6UC9v3fYEVlI8Q0TAMpaOi8GeUBE7btqZuuJQoeCnOYOlBEBIAGAMhhFESICMQY8BZdm5OKSrJBUeklCl673MID7R99yUiXX3XYPVHal/DBIBvMXqLvW2ct73/bfa2/X5bBpnKhgRIwADLhgSSCynE/WshOLIcY8lZl0KiMaaqTEppmiatdSmWFhEurXVd11JKa21KablcEtHJyUkBFCFi27ZKqSIX45w7Pz8/Ozsbx/Fw6ASXQqiT7RnnQnBV2NaK30TEoh4ek69rkyki4n6/19p0x34cp+3m1IfUrtY+5WGyswsl40FvlEDmedZaE+L+eLTeN4vF6fnZ+aOLchiL9WpydrfblT5hRETBXQztajnM02q7kUZf3d40y0WkTAzLGt+nyKRQlSmpm2Ecp3nu+p4ApFKztQRQN43Suh8GZOzxkyfXNzeztXXTpBwK34PW2oVYVU3O2cfoQmyapmkaJnC245Onj4RkIc7rVdPUinMMfhq7fjh2MUauJOOSCVUvlwRcVW1GIZsFycoGAKG5roDLDIJxfZ/Ni1FKHTPd3e60MjETcsG4yAnadkmMR4JEOM42ARJKoUy7XK5Wm3meiais7rlAKaWPoRC3KYV97zabTVm5V3Udc1LaJAJdN5Pzs3fIeUjJxTA5u1ytOOeLxSKEcDgcNptNWRAwAi2k0dp772McpqlILJQp/7Dfx+S1lsu2gRxTtLvbq9WiqY2KbnLzQMlrxRbLCnJaLho3TymFGCPkXIolpRm773v29YnCv6t9W37jXf3b2+yt/uQtlt9iX2387/QAvmb70jtHRDknhHsRVx9DWRtKKTOWnq9USA6EEEXgiXFdyGcQABEZE4wxQgYA9xrBKZUvs3Ou5MSNMVJqukeO9sbUkGV0Oc45pACUMOcY48nJSXTDNHZunjiCUiqG7EMQQqAqOlxIwIDxRDjbGCL4mKqqQi77YeIMlsuli8n78MAeQURt2zLGbm9viWi1WpV54vT01BhzPB6rtnkIC0qUU34tKf5SPHjA/BBROeeqqsrav+BoC89PWXg+PG+LxaII4TZ17Zyr6zrnrKt6GAZdVSEEKZGIEuU3DycBECIQRWQkGTElMvHEGGDOOQNnmTAn9BkTMUCegUdio4t1VQFyH4Ey6coQxH4cjK601jkV3nyeCAl5IrrX2waeU5JauxhAKGQipAxERmqhDBFZN8UcCpqz1FEK7Mq5+6LrPDsAqKqm6I4hYGXqFIdCy1NgwUQUc0TBC681F9C2rbU2etv3/dnpCTJmfWCCH7o+pFi+eIgUnM92xnZhpNIcbZj9JKWUUgAqIQUQY5JzwZCQiFL0gXMOpbxfnA7jkP4cm4B/h4/+dvb7HQroW7eHe/PZm4Sf6XgqDu6NSt+9xweAEGKMiaFQ0pQSX8n4MxQADN6sWorDLbqvBRZpjLm4uChNT59dCBBRjD5TSikUKiGtdfGnh8OhQDDv2XUizfPc9721NlIuCXoulTJ11a4y4wk5U8ZUTSacJovIizKUjxG5yICz8wCsaRYZ2OX1ramaxXLtXHAu1IslMT45z5hIkQhYJuRCcaFKf0DKIJUJMfuQGJdC6lIDMKYOITAphFYhp8nZSJkrKY1mUgzzRAzrRVvYN4VWKHgmGsZRGQ1vtFYWiyURZKAMVPw+MABGyAE5ECXEzAVTWkgjueKAmHJmXBKykCllAJTAVM7SR4zAgSniMt/3JogYckHBCi6BcSFEBkbAlK4Iec6lIIwhJamrlIELlRBjBkLGpRRKxpRK10LTVIgkBBvnycew3KyBQ9ePXAgbvJRaq6rvR2WqXGSWGUPOhJLjND10ACilUiJELBUjSokBeusaU5WVx2K13h0ORTbSe6+4oBSmsacYtEQjEKMP0zG7QVGujBActGRacoDMIDPIITohS+YwvUEoFErqP7sU0Luu3P8w98v+5QO9646/rve/q31dx/Ouhl/w/g/jl4eEiB6KbwBwD9pLVP7yhn9NIKIU2ujqDWEyADDK+Aa3d68AXlVVXdelDvxQNigEamWPZV/e+5QD56zQiKaUDodDkVHUWqdE4zjGmLWqiIChCDFnZEwoJpU0JmUUstqenCFXwzQhF8jEMFnvYjkeegMELDOT9365XBYIChEVYvrioRJlRCy1EHpTx364XPdUw5yXark0erRzqUyUnw/Qw0IELaVcrVbW2t1uV1LnD5WMohDJpSzgq3IXHujthGDivmmXGAfGgDHkAoUQjN/fr0RAgIxJLg1nKmZ0PtXNMqGICVFqlKZU5mPMyEW5s4ScgBHjVbuQUqdI98FKRq2rAiElZFLpDCykVJQdZ+cykDKaGAohCkXddrvVmk/TpJThnAutQoqc3SMvx3HkUpWe6hijqSoXQ8GPCi2apgEAN83GmLZtN5sNER0PB22qzcmp9SEDOOeGoWMcGMN56KObOCQtmOaZJUfe5jgpBgSJMRCcKMecEyLEGATj8CYRQffQLf41Pr/ftH1dz/ufhn0XAXydxgA4YGkIeHjBAO4VXQCCdcE6JNJSPSD9UyIhlDG1UoaIYsiFBy1nyJkoY2k3FVwCABGVDs9SGMg5X19fF/qdIrJYxixJoaLWVLghkVFJlZydnTVNg8id9fNsUyKtzXZ7UtVt3S44l1IZxtXsovO5H2cm1GJ14gP1o2uXKy7VoeuAMSl16SguaM5+HEreGRH3+73zfrlaFax6yU0DAHBW6PIjZRs8MSSGCQgFl0ZzJX2K3Tj001jmiUKJDAwL0T8h+Bhc8MCQS2G968dBKNkuFwAAmE2lYvRa634cS10E8F4boJC+iXsQPxOCCyWYgIyZMJewgAnBpMiAiMi5FMooZYRQGdCFVDcrl2gOUelKVVWIORIU8UVgPIZ7QGdKSStDwIioMnXOII3WlZFSI3IELrXKgOM89cNQ1CvLJFS4JQqd32q1KrkszrngijIOw7BYLWPIlHEY56qqioSZEKKu68ILK6Vs21ZKWdd1qfQIIU632xxTSRYBAGOsbhc2eGstUcopODvOUxfsKFlsDK8U8uyyHZASxcCQECEEl2LBFueCmPpcvrvMAX9W9q65+D/M/X5JH8Db6hjvOnm+7f1/aON/hbrNl9obcjqCfxoE5EyMMQQe45tFEzLOuTG1y+hiAAClVFVVmdC54H1EzFwEziCGzJjgTEhJnHNMEQBK8pdzHmMuK25ELDn34j4454yB9y4GD0DGaG0Q4Lehg5+7AgeqqioEkVLqhkmgyIQ+ZqG0LMVMKZnUjAvnw+Qc49JUTYo+ERqlgLFkE2OsAHKmaVJCGmOKuDkirtfrnNIwDFrr+Y33KbhDLPwBb6iMH/BF8zyP41jSU1VTlzmylDcAoJwdAJR6w36/Tyk9efLEGPP8+XOjVCOls6GsxxGZ8+4BAPrQkHyPf+HAUQDk4u4Z58juxXhZikxIzmR+w5fOkBA5EzLOhDnXVSUyD2zkTJjFSklVQhwudEoUQxJKp5RToqpthpu7dr3hTBpjQk5CsLLwD/M89j1bmIJxKoFUzjmEUIKYuq7nYSQiwELi787OzuZxKu8UXM1kS9pHa+2cE4KnlIwxMca2buZuKG2FoDXn/P33Pvj0+qpaLLmQq9XKWwcAOefg5hTJTwNXParGCJ4ZD877EIBETkkyQMTgLDKGjIoAGAAxxnJGKl87eFhcv8Mj/G0txb+u5/1Pw76LAL5+wy/kgh5SJZ9FeUoplVJSas4lQ4HAibBk9hF4ihRjyhmEUErds9KXEQqkEgBKb9R6vS7AoQIGzW9ImJ2fQ3Cc86q6Z25hjG02m+PxOM8zEKuqpjINZzKGXOgTnHMueKmV0CYRCqmqZmHq5urmNmXYnp25mObJ1XXNuSxQpTcp4M/yuFG7uu8F40KM0z0PQc65nGbRKgBiDAUQQ+DlfO3sC+2zkqZMcmXMByaJ0m5WSheIWPCghWqpVFCl1tLofhpL63JZHX8xA5CAMhCTgknBpeCKcyWkFkXRt1RfhBCIHAiBkHOhlMmAXGllKgT+cOLl8IBYyAnvZVLu5Y4Ln880TSUW4VzOk7MuHPtxtnb2bnK2ED+UuK0ku3yKkTJypowWWhVJL+99VTUhpBiz97GqmvvBrS1dbAX0WarxD1+Aruvqui4XbbPZAGfHoS+M5eM4cs4ZUsoBc4rBBTdR8AySQDKCVUpxdg+r5QK9tyEEBlhScPCgP4P35JR/hqmVbyvF9PXu97sJ4J+xwnL+z/5EKvzovw3E3twSBgA53YtplKUuAJXGGRRcCIGMpZRCyiEEH3NV1cpoznlGYAyYwLJyLR95gMogcqVUXbVXV1c3NzddN8RMSildGQCw/n5tWNe1qSsiGsbRhiikdgmIS6HrhGLwcYrZtKtHzz4QqmZCITIptWQ8WBd9gJwr0+zuDozLk9NH0+z7OahmFYn5kErBNuVc/G9xVcaY8/NzIjoejyGn4zDu9kdV1YkQOUfOpdZCKeQc2D3/TgbwMboQCLFqmna5rJtFilQofe6DmxAykdJaaR1iBMSz8/PlanV7d3dze7vergrOR0reDcd2USdKVa3qhQEgwgSQEySClCATUSJCzgrNnFBaKs2EAcYRJBNacAVMAmFphWNMKKkpY2XqumqBsZgJQWTAabIhUyRIqSyMsWB4lFKTm8plLzyaOcdx6p2dhu7gnYOUKRIRMCGFUACFnyPmnIgyEZVaRciBCQTM7aqd5zFRtH7WlTr2B654CIEYZqCUwUjjvc++0CshAPR9vzk5AyaAsZDyenNGIJEZT/IwxsQM8Aq5BMyQPUVHcaboACNTTNYGuSIu7tukc0jRIQWGCXIAAMYAGAJAhkyU/gx7gP9EJgAk+tzGS8r5X7x9kf2G/c6J5SEE++xxE9Hbxnnbft+Gw33bBXrX9zMkhsS/8FMw4Aw+95Pdp/yRPrshJ+QInDFurQ0h1FXFkGJwbduGGG9ud8duiDHHmKXQTb2IMcUYS3VXSlE3hihMcycEAiajpBYSMxEhZ9KHdLc/vLq8MnUjpJ6t1ZUxtc6Q6trM81y0Ep31LmVhapvo189fjz6rdptk7bmJ0kDVklm8vu1CJGOq87NHgnElZF1Vcz/UyhwPh0ePHl1cPH31+sYlsX30fmeB1PKun0274Ep34zRO02azGcd+s1kdDjshxHsffrDv+mM3bLanm4uLV5c3wGVMlAmVrrp+BOTOxwe60Kvr25evLqUym+1pynBzeye18tGZWl88PgdGr65f7fu9qlWEWC2qxPIU5rtulzk9/fBZpDw7yyV3wbXLJpFHEW3oR3f0aTStMq1qFjUx6McBGCJnqq58pkDApCFugBsh2wjCVEupl1o32iyVrrhQSqm6rr1zjBjnkjL6QDETF8a0S8ZVTMSFaprFMAxENPZdStHUevSjqmUkf337um7E0N1C9nYecgySi+VyOfRWyQqYOXaT9TZEt1ovxqkfhm6zWSkjq0r7bJfrphv2QrPBHuulHuyxWTfWu2EaldTlCSphmbX+7Ozi8vXV2cWTZ+997x9++euT0/N9N82eJF/GYIQ+l/XTo69Y+/jo2Gr7GBG14o0iwRyAzxDmFPZutkya1RaETCkEO5EbGgUQ5uCnEOcYfYaEHLhAxpBhRkT2ZVtJDH1xe2cj+tLtbeNj0av5wva5Z/S325vGnc9tZXn3xe2h7+dfuL1tnLdt73w872jFy33XB/BWY/RPXvz2J37hL/eWAYCQAT7cjzIPIgAoZUpDZon6Aeju7q6URomIcZlS8ilxzgkYY6ysZzNkgpwhEUKOydGslKmqKiOb59nHxBh7dPEEEQlY3VbL9cI5F5IXKBBxnmfOZKNVsrabrI+pXW21BJ/DNMzayMzUYGeXHAqxXKy04DGlkJNzLsdUln7TZLcnZ5O1gSgQm3xqVqfH491qewKcB6IQM1c6xMiELA1c3nsAlomsDyklgZgRJutTIpZodgEAmFCCCeQyZri8vpVSGWWYUMDE7KZmuZrGQ4HxXN/dHo9HKeVqvVZaO+9jSjZ44CwBEYKLIcTIGLPecSkrwRGZloYxXmroQgkCYBy1qbhgDHmm5EKMAIJxYBxQMK6lqpkyyDUCz4Cc31c7EQkxVabhHGKMsQA5hWIMKUFIlGMq6S9EBIQQfQgOkGJOQvGUkhA8xmC0EpwV4Y4SM2UuXUgMEkOhlKoq5ZyOMaYUGGNSccYwxxgpAVCGjBwypAwpxiiNyQh93xulhJDOBTvPWuvDvlsu1+M4rjcrXVf7rq8XS0DOORJxYNJGUO2GeE2UZus55wISw8i5chBDYp6AuEiIETjPgESYE1DkwDnm+2YKZA/Ac4T88PObs3+FxfXXYn8sx1nsW0gB4WfAf1/89U/SiKj4sgKOLNwpXX8ofAwF9Z/zb1ngS/GzCAM8RCoFxFky7/dzSYhG6eVyKYTQSizatlCPFRRQSYIX6k3nQs4ATABn02y51Mro2fq72/04zFXdPrp4rKraZ0qAmXCcrb/n+E1cCGn04XDw3ldVZZp6uV6P1i0320gQE/mUTNX4lLWpgXHrg/VOKlU+HmOkmCTj+EauNr+h+y/I1NLhnFJ66BordA6Ts6Zupa6649AdB1M1i8UqJQIuSsolxoxMMC5DzCgkE2qYZyaUruuYQQhZmQaQKV0BYQgppMykktowqTJgIuBcKmWAMQC457oQWgiBnLE3+vJKFbwW01UFXKQMIaeMwLjkUpRDJUTOOSJVSlZKhuBSDiGmcZw5l+M0E0HX9YAsxAjsPhgteyxAKSFEcAEzSsYppkJzrYRkgACYUr6vbAPPCSBjSklwpaQZhqm0ZBdYqtZ6v9+vNutpmhhji8Wi6w51WwGmnIN3I1Ieul2lebBj0cg0SgqGgnElheScUubAK1UBsPuSDmGpmhQdhW/rIfq2Ui7vauwt9m0f15fbO/QBvM2+8o353Nu+6Rv8bX2BELHA/AtWpDjlUoUrfD6ln6tA4B9qvPSGGZ/eEOUrLRhj3vt+6KZpYhwKUUTR1C0w/EICg4gFEV/QhMMwHIde11VVVV0/9uPEucwg9vvj7Pz5o8fvvfdB1bTjbLt+nH0IKc/eAaI0mgCqttkfDnf73WS9rqvlapOIYiLGlY9QGrtUVcVEum4AeYjZu1jXddM0v/3qcyEkk1oJIUKKIYQMBADWO+fcydkpACzXKyHE/ngoxyyEklIyJjIQl0prDcAOfVdkgTmTgChEQeBA0y65VMPoGBNcGOdCyoyQWZ+BCWCKkCNTgJxxzYUSsmJcalNrUwmhCDljHJhAxAdpl88WnBPlDICMAWeFsY4QgAkmVWExQsGLT2eMjeNY1LWcD1Lp2Tsi7KeRcxljIkBCyEBMSK01AMSclFKFyq08kqVir1VV6vwFcuncPXSHMUYEMeamWfiQxtlJqYHxTJiRJcqcIzKI0VeVLi1vmSJQAPJSwNAfBAdnB0guemuEkJxJjooLye9Jn6qqQUTKmOi+xnufuf1DdWTfnL3Nb7zN3jXV/HX5pa82zreTAvrskZUXf8LYLHwjjohvlsCFlbNgP4gSAHKB7H5qED7cE/3nnLGoQkJGYMUpECVrrdHNYrEglNbaoT8WrbFpmkJwUkpjTJFmBIDgY4wZgXOhSChirF2uZ+9vd/tE+Oz9Dz/44AMhxPNPPg2zDcFXgt+3SymFgkckoPzq6hI4A4Y+RZfj7d1ds1pFQGISOTMtcllFsJWQdp4AmAtRmapq2tSPQJgAIedEOeeQKfoYGQByjkTWeyZAaHHx5Hy0Y/BusV7MfkqU66ZxIcbgE6FQBpiwPoYUY8KUMhcSGCKxlLIPab3e9sdhsh6QAxMxESHPwJALJmS5FClnREQmOOdC6hijZCCUQaYQQColtcolyYfIOENEZFQwXCklD1kpqXRFMfgcU86cMeDC+0iQAcAGzyCnlI77u3Hsq2aBjClTU/AphkyopM5QCuai5Ka01t6JHCOTAt5EiogouZJcgCLnnJHS2ikSee8lF5RIKEGA02SNbjronAvS3DPuzfO8bOpxnpq2nZ1tFvVi2UzzwDiXXNeGVYZTslo2iRxnUivOICMBpZxjIhSCKZBKcEmYARkhR1YAUYzo82znSBmI/nUSCW+Dun8FX/mdPdg79AG8zd52A942zpe+/3dMVl/X3PBNj/879otvOmCLPOE4jt57xmTBL5Y/IqLWCpHN1hfVxpQSl29GyGStY1yWnIMxSms9zu5wOJRpg0th7RRjrCoNjOeYamMOhwODKLTSCr2fQwiL5VZA8tEpXT9+9GSz2czT/5+9P32SJDvyA0FVfYedfkVERuRRlQAKaKC7p8nhDIe9vGb4sf/ZkVmhyFBGZGWXIvzC4e5yOexuNgEQVxWqKq/IiPDTrnfoflC3l5aZFQVkdSbqQCoCUZ7uHnY8M9Pjp6o/Hdp207SOQJmiJGsBIFNoMutiCDEOXReBz+9e+ABD8OvNtun6u3fPm8PeFjVHn9ssMJAyEWi725ssH3xApVFpJlQ2i85F4MDMIURZjpfjIe/9Bx988LOf/cxa+/3vf/9nP/vZ+fm50rhvDk3TxhiNsYFBMVibd23vYyhNDgxEKnjsul4bi2RCRFaGQaHJsrwipap6EUIAZbXW4H0IwQMhCR8fk9KkMkZS2mZlled5H5ilUYE0Ikb2McYQOAYgRagUIVGWoR84BNCoiEPwikAhIkQJd6T6VtvMuxgiRdCD6wIrBnLeAaNVKrjggq+KXBntnAuBrc1jBK2VtYiIMlNzGIa6LPteEekYO5ObGKMi7SMPvdN1HhgYyAf2kbU2h31jTle73W61WOwP68F1JjPtrlWstEKjMcQ2+A6iVkDBtQTIkQgs+9B1vdNaZxZU7iIj6QgAhKiVMkcLyjQytv7RyJsamNsM1ZuiQO9aD4t8bREATHx/TAHmd1SMMc4FRLTaHA4HmbLLHJ13VTkry3Is8dQxxmHoAKIPniEARMTjfcPMHD2hzvPCGNO2bbNv/NDN5+fOOUTOjA15ECjJOee1D9EZwsxqjr7th+hBm2y/u5nPqjvVrK6KQ7O/fPrMWlvN5u1hn1cFMA9Dl+UlaNV3TQAehmG1WmV5riK2nd8e9mRN50NAJJvvtpuTxbxvDnm9wBi2TX/n9AyVBkmukrImZ6CIYDUKG4Sg6uJWkzaIuDyZ7Zu27YfZYukja5tpa5xzITKStsYYk5FGRgIkZaxzkVEBsba55tjs28BINjO21KZgAGNLlZXe+6womqZBskgatAIMQBRBRQZtKiICMgBakdYmI22i6wi10laChmFgKUJlBJNnqIiBgTRZq1gRRkCvgtHKaLTROUMYgmMOWVZ0gx9CjF2vjWkHp7QOgC6wQdDa9INz7kja4Zxr2rbOssEfp7swko/yqWZUEUBrTaSzouz7HpV2bsiKXDpAi6Kk6J1zpLXNMu+Htm9Xas4ITdeYoLSmzvXMHDn07T7EHrjIMtu1HTBXZZFZzUTOhYiQZ1XQ+aEPRBqIlNJaGVLac4zhCAMBvFTH867Tv8e9fEs8/W8s3P+F8m061m+pSP4WxmGHfd9LgabgxYKVSwtoAoum6P/xvkfOc8vHNh8MIex2m6ZpxINumkZe57lFRB8G5/um3UsfwDAM+0MjFGZN5yKrLC+BzPXN9vJqw6CLcq50HlCpPA9IQ2TQhgmH4IFw8C4vi5vtpu07z7HrndL20eOnkVUEars+IoUIeTnTNveBZ/Ml6hzIRtBMVmW5ykpjSyQdmTkiEikyIcbgOTID00c//OFvP/nMWLuYrz77/POz0/PBhb53pLK6ns/mJ2U107YEpm6INi9JZYgKydq80LYMDCGSsaXOSzSZB5I4oB9CRG3yStuCbG5skRd1VtY6K0hZk5XaVkqXgJrJIKoIOLgAhKnXGhE5Hvs58rwkbXzkAIjKqKxQWRbJOCYGxWSZCFCh0hFI2xzJMGoXQOksMNk8J2NIGRkWJvNeAjAQuuC7rsuKHJEioLAYWZvnZVXNamYGIFSGtE7sRiGEop5FIEYoqkqZzHmvrcmrUgYhhBCIYBiGzX5nCxuCkzaMIQxaK2NUVRUI0fvBWpvl+ZG1m4yxGRkbGAEJCBkVaUWkGSgAx6/PUXtbWPm7lm/LcYp8gQF41ycwbRyF19pl36BO/xZ50+O/7ftvcTv7/T5OeI+lqyvP89ls5sOwP2yNUXluh6GTQg7JDxtjmqbZbDbeD4jouh5CLMtSKdW17ae//e1qtfrxj3/MwRHE1WpVFMX65iYGt5wvgvPDMJydnXVdtzvsZ8sFafN3P//Fyfm91Z2Lfed6z62Lg4vndx8c2i6r69OLu9eb/c12mxUlaSWUO9baDz74YLPZ5HnunDs0bV4W20NTL5YhwqHtlidnNsuvd7vrzbbz8cH3ftAHvrpZf/rosbKZKSrQ9mqzy+u6dV7ZrKxnZGxgAKXzsipn8zsXd/+vv/nb+XJ1/8OHgWG+OmGkABgi6CyPjMpm+7ZD0kyqKOsQoe0dKbM8ObvZ7PZNe+/Bh+3guiHk5fzQOtI56dyzOrlzb7fv6sVJXs0Hxx7UbHVm87obIprc2JKUjUyz5SmSLuuZc06WvR16UFTUVd/3y+XSZoXWWvI3zDifLwBN0w2zxSmDIlvovLJZqWw5RPAB8mIWAE1R14sTW9Sdi6hN2webl90waJsf2qYfBvEAZrPZYrE4dC1pu97slLY2zwPDoe2ubtazxWq93bV913TtYnXy7Pl1Wc+1zZWxgBiBUauyrnwM28P+Jz/5Sdd1V1dXH37v4e5w6NxgsgwQbzZr0ipwlOqmsiyd77f7TVkXy5NVXhQAtN7tSRkXmWzhmHRWoLGB0do8K0oXWKg7JCX+RbUj31AF97rcpmduk3CL3Pb927h63vT7b6qXvpp8/RHAt+jW+coilomZE7jPI69nmpZ1hBo4IIGU9MkjJ7FCjN5mxrleG+q67tmzp6enp/cuzv/mb/7GOffw4cMQwpOnj87OTuq6Xq/X8/n85OSk65qub7XWm+3+0ZNnzsPJ6TmqTOlss2si0/d+8Cf/9ae/OD27e2j6m/UOla5mC5vlLkQ3BERlbd4PrRwnSVMoo9ZaaYOIStum69fbPSDpLGcgRtUPPitnv/38SUSd14t9G1Zndzf7IS9qm5XKWKUz0kbpjJEi0+ADkgFSg4ttP/gAgcEHsHllbE46A1QMKkYIET0Do57Ply7Aoe1m81VZ1l3vTV72noGMMjnpLIIKEZFMVs32TT9EsGVts7LrfecjmgzQkspJZWW9dD5K0oKBsqJiVJKJldotAGDmIq+k/hIRA2MECJEGFx0Tk/aghqgi60iGlY2kA5PSmckrJhOJQNvBhX3TBkYGsjY3xkZm0eDKEBGt12tltM0zH3gIUVmjjN4dDnlds9Ld4D1HMCoqJK3KugYAFwYk6tzAxEVVtn3ngmfCrut6N4QI0k2iyNTVHLXygD4wIKGxpK0PfGiafdP4CEjaMUQypqjI5q2LETSgAkRgYoQIBKgA4NueA3hbqvNdH+dtBuNtfV/ka+sD+MIX30nhkYmMR8LkiQGIqVByivk4P7TtwbmeCKzVSqF8OpvNduvNYbt7cPeec+6Xv/xlbs1sNru+vh66Zl7VTdNcXl6G4PM8C0MfBudC2DWH3rv7H3xwcn7xy48/QW0jmRBpvjz75NNHP/rTP/34t58zmpvNgXQ2X5wqk7khSNGRpGqNUckFBgDCY/52NpsJObOQ2bkQGYiVHiK2TjIOta1nYIsBsKgWWVEZm2uby28k7SP4wPKOC9z1LjBKPllpK+zTQIpRCXKitFHGzuYLRur6oZrNi7IKDCYrehdRZ8oWqDNQNqBmZfNi1vXBRyrrpcmqfTMMjm1WRdARFKlC6YxRk8oGF2Rs45GcGdD5QMYwUYxcVRUcyTwyGVmJqNshRrRkSqAsomXKta1MPlNZCTpnZbUpGIlBZ3ntArS9y8vKx6ittUWOqJhZqO6UUk3XlvW8qGZMGBGysqrqeT8MeVEwoAtBaVtWM1mcvCwisHMuL2zXtYhYVdV2u/Xez2fLwIDKmDxDpZkUGTtbrowtIhrHyMoW5byoatSmd7HpBsccSQdUURmdVayLzkVUikgDqYjEoz8aAb+o0z9+i6gg3lTRf111/V9Nob+pvAEE9KaW8Eu+/4U24E23/3XJmx4nT4jDpDyfiLQRPh+EkQVMrIJ87fUgUaIHKRtXGsuyXF9dPX369O7du2lalvf++vq6bVtR08LvhojBs/dxeXJ2eud8f+gZ1eDiD374J58/emKL0tgyL2ab7QFJa1Og1j6yi1EpQ6z84ITjUwrSrbXS0tUeuhhjXZdZliFiVc20sb3zHsiW9bZpzu9/4EA1gWcn59e7tpqfmjw3uiCda5VrWxpdoMoQDKPJbGXzGsG4gIRWmUIpE6QFFelYkZ/lNiuKogqem653PobA+13T9o5Rdb1D0mRyQO2ZtMlRWR+RBazXmc1K1LZzAVBneRURIytl8vW2KavFnYu7N5sdEEqIRuOoAwkFBL5DRI2UaUMMShml7eAiKWuyGdkSdYamMMUsK5c2n2lbhkisdIgEqPKi0jYjpReLRd/3RFqAPkaU6erKaFRG5dYje0DHMMRA1qCxjiEieGCyNqsq0spxUEYHCKCgrEsXhggBNV5eP4/M9Xwm5jnLCgAKPg69Y1BFvVRZEShjZU1R5fXc5BUaq7LcAQyR0RY6LxyqgRFsDqhIK1AUmQMwo1Cb/9HJu1bEb0vvfWsiAJHXbcB3VXhMY4gqx3HKubT7huCc64eh834AjDQSJqem2RQxWG0Ou/1sNquq6vPPPyeijz76qO/7q8tnDz94EGP81a9+NSur+3cv/DBAjEVRSL5hPp83bfvbzz51If7oxz/ph3h+94PnV+t6vprVq+fPr8/P73btsFyurMndEGTkt6g8MSdWmzA4jVQWRZ6XWVYMw3A4HIA5M1aGExBpF6IyFpU2RZ3XC7J5N4R951wkk1cRNRChUnScyXL8Ec5JZYxQLsg/SVkknX5IGVJGGUvKtP3w5Nnz3ocI9Ojps5vNFlDd3KxtXtm8CIw+sra5tllgGFyYL1ZZXgKqwIjKKJMpk6HKImht85ubzXJ58r2HP9jtDkS67Z2P0YUgnJqSCgYgRBoZXci5gKhQmW6IgAbIMNiIFihDXZItUVdoClAWyQAZ0pm2eZaXRVHZvOwGzwjaGNIKEQVYT+DPZrvv+r4fhs12P4Qoc5K1yUiZ3g0u+MAgiWJUmOU6zy0SS4egEGYQ0e6wF4DRBw4MbT80bV8tTvN6pbKClfGsAljWmnRWzpeBVR/RFBXl5WHwTeC8nrPSqDShAkCZ0YmIHPElbx8jQpS5F98WuQ1zv02+ruP8w0QeX1AG+qYa+TYjc9t2cCz6nNoA0ZJvtP2vS77wOBHhtsNM9lxqe8S7BICUFUBEGSAbEQBiCI5IGUPM7AOHEGQkZFHO2vZ6vV5ba+fz+W63YwiZLU9PT3/xi19cr2+Wy3lR5tJb4L13gy/Lkgn6vjfG5Fm57bfr7a6o6qbtN7v9D3/w/edPHhfV7LPPH5+d3ynLPMSh7zvvIqFWioN3vh8gyCQvZy1Yk0fUFvVmsxEOA4AobWjMrJTKy9o5d35xb7NrdFb4oXn6+HK2POkda60IUZEhghgBmBEMIQDrGCIzIihCi6A4KmDKssxaA9BrbYHaGME5p5QKwDI1k5QZ3Nai1Vq3vc+KmdEZg0Zmm+XKUGQMEPJyDhgHDyFCXsxsZhl0ZgvwiKQYUGlTLxYhcuAjRU/f91aZPM+D9zKqTMi8YgjAPHQ9oNLatm2fZYULSEAQlUL0oIghkmUItrCKlDYZQGRmk2e50SFEMWOK6OgBxMiEeZ6XdRkRuqHPyoI4CppPyhzaJp9VnRv2TcccaKVJK22NMSovM3YBkU1uuv2+7ZuT5QIRu3awM0OoSamqnMUYGbUp6rznvPC7w6HzEbreeWalbFb0XYgUVZY7Mo33gydblOxajYhCuMQ8Eru9fG/zV5tE+22SN9Vvbypf73a+ngjgCyGgr+VI/gAiOd4pziMKWtIAaYgjyIAO55iZOSACEWpDSh9homEYiKg9NH3bzWYzY0y7P2RGIeIvfvELgPi9731vv99fXl7muVUKt7sNQ5R8clnWJ2enPobPP/+8rGe/+s3HD3/w/UePHp2e3mnbzntflrVSBgABSCmliUJg6V5mZqM0IWo6MlELQcLJaqEQEFFQIGbWNi+KYjZbaG16H/rBB1RkMlDWAyAo0kabTBkLqCIgS6euMoEhMipjjc1RaUCljNXGaGPVcQkoBh586AaHQHU1AyTvw2KxLOraxai11cravJDMgbG5MhmjMjpjRiQ9+ABAs9lC2cwFzoqSkYbBL5cnNzeb3faQ53nTNFqbsiyFSSm1qslQASmAkWuntc6yHJG0sT5AYMVkAqrIFEABGtLamlyGnYGiwTujs7Ksu76fzWZ5nqNWQBQ4CiFgURSolc0y1EobY/JCZ7myphv665tNXlTz5YIRXIiodATovbOZzjLTtHtELIpCPAkZEQoApJXUs85mi7KeaZNFJrJFVs5sVkZWfQAmmxezbnCglMnygOQiRyRW2kPCvjXwUUsgYvj2K/wvQZu/UP7ocgB/GLk1Pvj9+Pff9e83pVe9JQSOxECECgliiD5w8Bx89C44D/wixlREiCrG6IbAzD5ClJniSilz1Dub3bbt+vv372prfvbz/2Kt/vGPf/jb3/7mr//mP/3kT3/045/8yXpz0zSNjIosikIplKYzSQk8evRku949/PD7l8+uPvroR599+mh1evZ8vXEM85OTfde7GMT/1VnGqJwPjol0HlArW5DJSeUxkncMrIH1xd0HtqhRZ2TyANqzUjZXNl/eubjZNWU12xwaH8P9+/d3zcFmBSsN2pIxrExE9EABIKBS1kbSEZFsbvIcTYZao8kC6kAUybDWUalAJAxuvfN5WfW92+6boppZk+93jZDzkLZkNGmLWqHQ2mT54B0zxhgRlc1zBOW9z2weQui6YXmyev78+eXlZZYVzW5vSJVZAYGZWRFJIVCWZajIZFYrS1ohKuHbIKWMMYiIilAZUhmTjWhZGVBFUNoFiKAi6iEgGmOL3IVY1nOdZTIfOETsHTOQskXXe0QdUQemiBZ14Vlf77vLmy1oUy2WWZEbY4yiyGG/3yqTKcp2hzYy5nnOKKPirDKakQLo3mMfKZjSq6ID0/QBQWdZZvIClQGyOq/s7HTd0UB1tMuesz4gktFKRTcAHBn/QfjHRRvyixQwMnwbG4ne1ADcJu/6ON/UAHy14/wayOBSuQtMRksDHPm18ff+rQAJ8PXfJGzaf7/fX4Jp3nZhEJVQhcmRKECFSMjWKATGEDB4Di76QXEsjC4zO/Td0HcAIKEAoVbKKLKIFCP3fb9vDvum6X3vOc6XyyH459dXLg6Lk7nK4P/zn/7P1u0/+PD86vrx88vH+93Ng3t3rVbr681ms6nrGjU+efpovbm+c3pW5sW8nv3mVx8jU1XNAHXrgq3rfD7fhzg/Oz00XQxQ1XPnoVqetIEc2RbMug1t0JQtsnJl7bwqz+blafD6N59dnd7/6Om6a4Kxi/NDNIvzD88efPRffv7rk4sHURtlTFZU28O+KLIsy1oXKaujyrtAKp9Vyzu2WlJWsy4cmF0Xsnrl0T693oEpKStZ513AYn7yfHOYn150AQPZfLbyrCKavJ5d3Lu/3R+AVFHVWVEwKgbM8iIvSgaMgDbLSRuxGTYvmq5/9uyyrmdnZ3e2223vnDIkQP/m5kaTCi7mtmgPHUTMbYERiWloh+Vy6b1vnXeI+65Hoz3Htm/rWSVc703TzJeLsp73IaItwJTR5GBrZwoq52wKU9V5Ne89Z0W1WK4OTdd2fnlyxxR10wdQJdkSsHBez+d3e6eHmM3PPti0+Pjq0EP29HqPJjdZkefW9Q3F3hIHD6cXD+rZSTu4Q9vdvXuXiIqqPPTD6uI+5dV1G/PTD3dc+PKio1kzHONLQyq3tiyrrDo1s7trrnewsqc/ivldNMu+izmDPxyc6+ereVZmMkxYEbph4BhHAnoan3CKSBFprAV69QeR38oPc/jCn9v2+6bP723ytur0AfiNfhDhC3+Y4xv93LYd2cs3yIAntftN+A1vIzsvYQSHYxkFcOQYCMGQMkYpgtzooihym0lEqVFrawCIGWVSCoy4UN/3UtUDCsuyJAXb3XpwzenZIrIjxSE4gCiMktvt9nA4WGu9H4wxp6enZVl2TTsMbj5fAEDXDkU98xHysgJtFqcnjGq73TIpREJjD80AJkNtbT3Lq0VUNstmAezg4NC6q+fbfgj//f/4T37z6efLs7sqK642h4sHHwY0P/vlryPZrKqr2SowOhcWi8VyedJ0LWjNSkfSrDQrE0mxMqCNBwpI8g5oSzbzQJHMELGcra63u9Pz+70HRnV2fne93ZfVHJXKi7prB2uKoffW5AiKkQJwRJDfACB4hVT1SMt0GskgFJvCRC2YCcRYZJkm8sOAzHoS6YcQArDWRluDiqKkL4yRzIfWOsuypmkG75Sxgw8eMKvmPVAAHVBFJNBG50VWVaao+xCrxclsdaptnVfLYnEaybYDEJUuaOfRsx2CBlWafNEOGDHrA3cDG5sLoUhujTFZP8TI6u79h6Rs2w1PL59nRWXzspot2r4nUyzPzi/XhwGtnZ3uB8ir+RDier3dbrd953xgRs268FR0WLZQDJBHzAmtJmMJFR5paGGkgHtlIMk3Snv88cjfXy9N5f0lfOeScP8jwSei1FMK3iITaHFMjKe+MEQkIkVGKcPMQiC6XC6Xy6WwDS+Xy/l83nWdQNJSqtj3vXABEZFwS1RVVZZljDEEKQ3MmLnv+7IsmVkS0VVVNU1D2tosa3tns3wIsaxnETSSBdL94G1RkjakdZbnnuPJ2TkAdd1QlbOqmiEoADI6I9I/+fGfff7541//6uPZbLGYrzabXdcO5+d3s6wgfeRCkBwAoAJSIYLQsTGSNpm2WYgQAclooXKo5oveh8XyBEkzUL1YKpMdu2pN5kLQ1iZ/lEf27PQi1fPI0AXpypYqrKZppCVbqj8F6xeHN10CSd4kRS+WI5VpyUd1Xbdt23WdMUbm4SAiRj5W+CitlLG2yGxls9IHLKt5Xs77gGgKm8/bAYZAxeyETAWqULZmMqaYLc8uyBY6K3rHh3awedW66COarDa2RJM7xtXZBaps8LFpXTWbDd4P3hfVjJnlvsqM9c6VZYlAMQCOY6WFMLUs6ywrSJmXhmaNHu4Y2r5QMS+wb4yA35ra/++SvGUD8LY29O7kTU/4tu+/a/nyU4AR+8KRcd5773zv/RA5HL+DMY4TvYWWPc9zISeQihGlVNd1+/2eiKqqAgCB+GXsu2gfAPDexwj7/V6SAW3TbzbbLMsWi4X3Xtq/xfwcDm0MPAz+en1zce9eVlaHpsuKSqhyDk3XuwCofURjcyClbWaLAklfXNx78vjp6cmdzWaLoB48+OD6ao1Ii/mqbTsEZW0WPDPD2en5anWy2ezyQjp7LSnDqCJjYARUMnTdZAUDKZMZm/cu+MBVObu+2Zydnjdtr5Ut6tnnT57evXvfZoWxeWRUpgiApG0MECO8fiFG7xURUbx+IpJZK4godlHM5zAMzjkxilKpJcvIY6JeyPtEodM4KwYR+74PIczn8xjjbrcTjSkRGwARaWtza3JCExgZtdK5zmtQRYSs9wiqZCq6oPLZaTm/k5Urlc9VVnWOXNTz1flsdScrFj6qpnVkyhBxCESmZMqK2SqAHQLYoga0y9WZyeubze7y2dWdO3eGwR8O7fn5+Ww2e/78+enp6Xa7dSFmRTVfnpg89z5670mbrKhIW2CKjCHC4MLgw+ACHqcSHSvWpnfye/nOyPsI4J0LEeHYBADjVPcYY4xeNEUIQY3pRKEFBQDpfhLX1ZhMpqM8e/bs6dOnRVHIU/306dPlcilTq4gojWPs+14GkgiPsag5pVRZ1uLAaq2FkG6/34sj7IZQyXjbSEU195F2+2536LK8snld1gtUxvk4+Nh2Q9N3Ebiu58PgmJEZyrJGpLbt27a7vl5rbe7de/DgwQez2YJIxQiBIStKbTOhCI2APrKPzDhS9tssAipjTZZ3g/ORkYy2Foj2TTNfLi+fXzsfT+9cBEZls3ZwRVk7H4uy7n0IEfg1eyy/pXrHOSctV3IVmLmqC2t1CC5GPwxdCM5a7VyvFBqjYvR938bo5Sc5+4goaBIiCjonkQEiXl9fHw4HMdgS2AEQsDamMLoAVgG1spXJZ71XQRVZfWLrU8hnDot8fs7ZXFUnjkqHxb7n7d5lxfLOxcNqfspUdI4CZCZfdI6Aikg5qhxM0QVcnt6NaOcndwD14HgIkUGT0sbm1ubGZBqJGHof+m4YhsBMigwq7UNsmg5JM0p1P4YI3kcfAbXckDCCyKL3I35xdcS3qRP42y5vt1/hfQRwq9ye7H3j40n4j0AHqdsLkYVfRimcDgKbwhepQ3i9XmdZNp/PRdfL+LC6rqVCVICdLMvyPF+tVvP5fD6f933vnKuqqigKqemczRYAoJTu2kEqPmVwY1XNum6IjFleAeqm7TfbBsgslmdIdjZfRSYXIDKECFleKm0D429+88lPfvxn1uafffooywqOmGVFVc6KolJkAKg5dJ9//viwb7/3vR+QNhEoAgfGCOwjRGAgfRytpZULjIqUyVzwjMqFeOfi3rPLG2tyY/PffPzpw+99BESBmYEGF0nbCGSLkkHLSK9Uovf6pXHOCekCjx0nMupdVg/GvhuxiwIWScoUXgzhOppwCQLkEiilqqqSCt2madq2lWhssVic37nQyvT9wKiyolS6RMxMVoeo14ceTJFVJ2TnoGc95F20YGtTrZzK2VRg6zYoU60e/uBPi/kZmdpF03u1Ov1wCBp1xapsPIGpdDavVxeYVRGtY13MFqen955dXpf18uTsvDm0wfO9Bx/ebHaz+QmavO38oRlQZ7PFMsvrwQUXYvAcGBGUVMBpa6pqJgFTeqBgAqy9B3++M/I+AnjnIkpcSCAEOpDkIUMUfgWljtXl8h3RUCMKEb0/Wveu6+7cuXN6etq2bdu28/m8LMvdbpdUWNd1RVFkWXZycjKbzRBRWEWFQEJUHIweMSLKRiRhUNe1j4AqI51tdm1kystqsTxFZQcXs2LWdK7tB0aKCLPFXFnz299+Vhb1xcW9w75tmk6RyfOyKmfOhYcffl8p8x//v//pk08+vX/vgw8+eNgcuhCCj3HwwccYZIYWKWWMCzEwR0AXAiNpawMDaSVgUe/CbLl6cvkclP7ge9/f7g6AavCelOmGISuKyJgVpdZmqvqnr5NzlGWZzEyWlYkxFkUhil58dgBo21airpQ8EF2f2gLEGAOAxGpFUeR5/vz5c2kXEKV5c3PjXfjzP/3vZtW87xwzZEVtsxLQMGimYghaZ3OH2aYNYCqVzw9ODViwnXfesKrLxR0wVVYs7z74QVaulJ1HVTQOz+59L1KFdk7ZAkzlMEM764KulxcDG9RFVi6L2XLwYGzJoJTOAfVicYJkIihTVLaoI2ofEVWmsxytjYDSjYFaSQ5Aa50Xhdi5iTs0UpS/0P6/o97mvbwLeVMH9MvlvQG4VW6LAN50O3FC8Z/GzMLRr0RRXN578danOYCXAgKm5XLlnFuv11K4MgzDer3ebreCP4j3GmNs29Y51zTN4XAoimI+n4cQm6aTLOh+vzcmAwCZSyyOP0cgbYqqMlnmI683O5MXd87vL0/OD80whGhs3vZD2w1t75quDwBt2202m//hf/jHz58//+yzR/fu3cvzUim12ezm8/lud/jss8+I9I9+9KN79x6IkvWBvfc+hhjjcY6uIqWUvBOBQwhSzA6ESumiqtbrbTWr86L67Sef3b/3QZFXh65XyngXjTFN2+dZ6X3Iy0JoFWQdXnkwpM8uxV7JAIjeBwBJD4gBEPKMBHknvE7iLRxb1nls4c7zHBGvrq601qvVqizLEMLTp09vbm5+9KMfzedL7yNHtKZEZXzE3mNez205z8uli2rfepXPy8UdtGXjsAu4bUMfSWXzQDagyeulthXoPGI+eFuvLljXbOdkF6Y67YPuwKwPrj65G1WOtgbKWg/l4tSxurreL8/uqqwcPKxOLi6vtox5tbpjivmh95t907lIyiqdk9HaGqU0oIoxMoDSx5D01ScCQrqv/x7P1nv56vKNMwC3HdDbklsPfXzUp4fxFTr03iLU84UiGgQRy7K01gqDQmqpRcSu67x3WWastc45qU1ExGMagEzw3DQNAKzXa2H5F7oCmSQjXAVElOf5MAx1XY86zngXQzji1DHGzXo3m80E0FgsFgIr3blzp+/77Xbb9k5m6n7y6Wchoou82zfz1QmS3uz2Xe/qxVIZHZiV1o+fPPnzP//zzWbz7NmzBw8eWGu7rttsNvP5PMuyx48ff/7553/+53/+Z3/2Z9fX133fz2Yz5xyCMjoDpu1mHwOURX19tS6L2g1hu9lbk3sXN+tdWdQI6tPPH3eDq6r66uo6L8uH3//e5eUlgnp+vc7KKkZYLk/afvjNx7+tZwsEled5uhBiTY0xxpi6rvf7fVVVh8NBynj2+/1isQDgvu+0ViF46bvebNZZZvu+a9smBC+Rm1JkjG7bxhjT932MUVZbllFiBZliDwBa6+fPn3//+9+/vr7+f/w//1//8n/+V7t9M1+uNtt9YCiq2mS5seWhGVoXdFbvW79r3OLkwkW1OLt7ud470IHs/ORcZ7Nf/ubTkzv3i9mJttXs5KL14DivVhebQ3RUOsgGzsgusvoEbR11+dFP/sGzdePZrs7uFfWqWJz2HkHlTQ+Y1aY6AVXYYk5Ztd33q7P7WTnrHMsIZe/joWmMMcvlUnwOpZT3A3OQCBUAjFXj85W0/7R0/c2ei3ctb6oH3vT4v+T7x6WZ+Itfcpxvy9H8auvwPgJ4y/L6iuOkm/zFJYc4DF2ITr4v+A8AaJkCzCTpGdmCwBEC8SulNpvNfr/P87yqKuecVIUqpVar1Ww26/t+t9vJJJOiKMRXhdGZ5Yje+ydPnrVtd3Z6Lqp/tVrFGBeL1W53+PTR5z/5yZ9lRXV9dfOTP/uL66ub9fYwny+bfnjy5InJCgB4dnWZV4VoUkTM83yz2UgTMhF98sknjx49+uf//J+vVqtf/vKXq9Wqqqr1eg0AUrQq4LtU5dNIMppl2UiDwSlNEiMURfHb3/72ww8/XK1OttvtMAxVVcUARFQUxW63W61OmY/jSnhkTpVlT/kxWXz5SCB+GEn6pp39sveXmhPHxZ++P5VUR7Tb7fI8lxqtqqqqqvrX//pfX9y9+1d/9Ve/+fUnd+/e7TsXAwBpVKZ3YXfotc0jaJXlymRo8pvN7u79hyYrrm52SJaU3Ry63vMHD3/YOs7rJahSl4tsdjpgYeenbTRZffKDH//F1ba72Q/z03v/7ePPf/IX/6Mplx4z1iXaemDbR90Fdb3rWZesSwfWRRVURqaMYLrBaWt9ZBcCIhIBMwMHhS8B/a8hP+/lOyLvDcDbFJyEI9M3cQJNwKhTpKoEAJiDGABxu+SvjhoncIws6mha5yNKTZCi+XwuBaCCtEgm4O7du4v58rPPPm+a7vz8LoLqOydqd7vZ379/fxiGTz/9tCzLuq6bppEi0efPn89mixDY+3h+fvf58+vPPnt0cnJ2OLTOucViUdXF4DofhrOzs6ZpJAV6OBwuLy/n8/lyufzFL34hLvC9e/ecc2Kxdrud6Ot+aAfXkQJjFWB0vteG5J95Ydvu4MMQ2dtMA8bovO8HRPzss8++9+HD3GY3Nzdd1wk0VpZlWZYQ+f7de33bSQNEQszSOqdsudgbZs6yLNUCkQKlUY4BMDKEyD6yZwgMIb0pw5lThiYVXcj2u66TQtLZbCZjfKTUKi/r//V/+9/+xf/yv8xXq7/+L//F5LlnVtpkeeF8uFlvsqJkwKwobV5om+0ODSq9PDmtZnXvnDGmni2fX28u7n3oIgUwDnXribJZF5TjHG3p0Rwco60ax1l9wrrsgjL1yUB5NJUuFoHyqIqgipudbx0NlIk9IF3pvGZlA5MV1ujARGS0xhiBg1FHi3is98dkEV/x/d/Lt1ve4TyAPzZ5Xft/YYgn6kO0EhHJG+lTKSzBscTQOZcGh0m7qRQaCmGZlK4LubT4nlL9KT1iv/jFL+7evXt+fn59fe2cWy6XiLjZbJbLpdZaGgXqal4U1eXl1Z07FzJXQPzoO3fuMONPf/rTPC8Xi8X19fVisbhz545wkT548MAPXQgOkYdh8H6oqspavV6vHz367OHDhz/+8Y+ePXumFJ6cnFxePpX0Q56ZYRhcPzjnog8xRj84Y4wfHCIapUM4dj9rUhK4OOe2262UVN7c3IiZPBwOWtNqtQrO37lzZ7FYbLdbWepkVnGsu5W1laV2zom3TkT9cOz2kq6oVKorF24aHMh1kfa6dHGntrzrOmaez+da677vpTtvu93+03/6T//Nv/k3P/vZz/7qr/5qvV4755TWbdtKnLTdbhVpRtBaSnyNC/6zR59XVfWDH/xgt9sNPt6/f//xk2dkzJ3z+4dmQJ1fbQ5R514X17uWqfSUffbo8sd/8T+SqR4/X//Jn/2jz5+tdbFwYKOqMF9GU0G2AFvvPd60vg+6D7qPKpoCdMaobVaZvJDTN1plWhMGxV4rxNHIpTucOXwFaOLrkjfVY3+c+u19BPCW5XUzkDRRUv2ilaReMMYY2SMxKYjROz9IEOC9H3o3DD4EJtJa26PTOrIaqLFP59mzZwnkkaIUAPj8889DCCcnJ+ICn5+fr9frX/ziV+fnd+u6/uu//uu6rj/66KP9fi8wzmq1+vTjT6q86Jv2Jz/6k0U9+9v//Neny9VH3/v+br2xSq/mi+7Q7NY3i7qqi3yzuanqouubm5ur5Wr+wQf3P3/06a9+9Ysf/clHH330/c32hjnMF/XV1eXgunv3LgDjbrdrDwdNiMzIURNBDMjsh14hGkW5tcjRKKUQCICQCXlzs/7RRz/cbzdPHn0+qyqrteu7Mi/qsrp6/uzsdAUcurY9Wa14rLWd2lq5BKLHkzUVQggY0bmU7Zyq9XQFeezdi+MIa5GpefDer1ar9Xrdtu35+XnTNCGEzWbz0Q//5H/7v//rO+d3/+X//D8/u7ycz+dXV1c2M3mROT9EDloRB48cFYJC4OBDcNKtfWh2ci7b3e7P/uIvAlI9W60PHdqqmJ9sW9cOoa5Phqjmy9OsWjy72plitjq7T1nNqvSUh/HHwREICpR7yqIqgEzvoPOs81yRUdpmRhljtGKtUCMawtTr+xokPfH9x/jgHT5R7+VdyvsI4K3JdDWmL5Jrn2ZJw+h7EsGL6roJ3MzMMXD6vqibpmmKoqjrWtrHBMqQ5LAw8kuZoyAh2+32zp07n3zyiff+5OTkyZMnzrmPPvoIEf/zf/7PdTW/f/++c14aiWXg+7Nnz5RS//gf/2Pn3H/4D/8BEe/duwcAoiIPh0MI7u7du8MwfPLJJ+fn54fDoaqq2byKMR6a3X6/t5n+kz/5k/Xmum3b84uz6+vrrm8uLi6ub55XVfH08aOh68qy1EQAUBUFEUGMzJwZE2Oc13WM0WrtnNNE0gjNzHfvXuz3+7Ztq6oyRgnjcfDD4XAAAEGiZDjltIUi9U+Imk62QWywkDBP7+GpMZji/ikjOo0AYGyOjWPbsLTpSWDnnCtn9dOnz05PT2OM/+7f/Tu5pnVdM8QUtw1DV5a5c733PkZfluUPf/iDGONutzk9WzHzZrO5c+fO559/fnH3bj2bszI+gGdNphgimqJmZZvO/fv/8B+zcnbn3of/7VefrM7vy2CygLb1EMg6MI2nQNaUc8yqqDM0GZqydb7pnDaFj1GW2ihEAIWs6Ojsv+z+v6AG+qK7/xtnA95Uj/1x6rf3EcDbl1fMAE5wfx4Jf7TW3g9xZFxJOQApCZ3q/WRCYGxWgpE9VFTSbDaTSn+pLpVK9tlsttvtqqo6Ozt79OjRz3/+8x//+Mf/6B/9o7/927/d7XY//vGPnXM3NzcAIJMmnzx5UtflcjE7Ozn927/+myePHv/pj3+iUHdNP69nfnDAochzrVTwQwyuKvP9fpvn9uRkeTjsPv/807ouHz78oO/b/X67XM5j9LvdZrGYWauvri77vm+axhg1m1XO9YfDjgi0JiF6JIKua7LMNM1e/pA5EHCR2cWsdn3PIc6qkoOHyPN65l2/2+1OTk7a/Q6Cr4t8aJtpF0UyALImKcee1vN1Uw1jdJWstR9FLtMr4UWy61IXJN+cz+fPnz8fhkGmpD1//vzDDx/8p//0H3/605/Wde2Dm81mm83GWl3mmXf9cjELfpAfrXC5mGVWK4Iys4U1xigiePz46TD4e/ce7A5tVlTd4LrBZXmVF/Vmt2u74T/+//5z5+Ldex8cmn7f9IDGFjMmM0QEW7K2HnU+OylnKzK5D6B0npcVo/aBlcm6wR9rZIHZO4gRIcZw7EifQP/xVu3/Xr61Ql878z58Jf79b768pmIij5w/pFAp1TsfIyAqYPLe+8EBgFHkXB+iQwiKUPxR4hiCK4q869qub7LcSNnJ4XDI83IYhr5zIYSiqIwxbd8Nw2CMqeazi4uLjz/+eLvd/ot/+c8Oh8P/8X/8m7LM/9W/+lfb3foXv/jFhx9+SEQff/zxbLZ4+vTpxcXFBx9++G//7b+9urn+y7/8S2W0MWp5suj7Hgjv3bvXdt3f/d3fzpeLP/3TP/3kk0/qur65uWnbVnKq4kVeX19/8MEHAkzdv38fAC4vL+/evfvrX/86y7LZbFYUVdd16/XWOSdoltQ7dd2AiIdDOwzD4dB6f6zemc/nl5eXWtNyuZQWB5tp6bl98OCBWLssy66urhLXHk6IN0TjhxDYB2LQSEembnoxCy/FZBIBJKQumQHZVCL1myaBJeuQ53kIoSzLk5OTZ8+edV0HISLG07Nl0x7KqliuFgzxcNhlmdnvt0qpLDcxxqqqUpzR9+3l5SURzGaL/b5BVKvV6eXlVdN0+31zfvd+13Xz5Ur6/ubzuRuGoetnswUZe3m12bfuzoOH29YP0VA2C8p61iaf2Xxus3K2WMq8zM5xJK2LubIFK2uybBg8okqWDwAYwMfwyvp8sQghKNN7ZtBvqdA74tNHht/J13/kzR8Hv75paMYv19jK6y+5WfkW+Qr7nUbHr4SKL3/EROCFXMv1ITjmMLqnzg2BdIagQ2BFhohi9MYqmynve+dbZhd8r4mNxuh7Dj2ya/c79m4YOqXw7t37bds6HyNAVuSHpgHCxcnq0O5vNpvZbPabj3/rQ/jBRx857x8/fZSX2YOHdyO6x08fnd+9c3Vz5YK3Wfb86urOnYuTO2f/+W//5mZzfffB3aub5zrTpPH5zfPtfvOX/+wvf/mrX/3yN7/+y//bP6tmiydPL7U1Nzc39+/fv7y8lM6Ghw8fbrfb+XzunNtsNtKUIMv185//PMYYGObLEyDVDX7wIS/rq5t1XtZZUT69vLJ5kRVVXlbPnl/Pl6urm5sj1BOCc+7q5nqxWkp5aNO2eVEg4tXV1cmds11zePz4sTDw1HXNzLvdDhFns1mmjet6BaiRurYlxK5tFVEMQRFppObQaWWrcjb0nlAv5qvgGUFpZRUZYCLUmS20siGwMbbvBo5gtA0+KtJFXg69y2zuXWibzmi73x2KvESgw+EA6Id+hzAo8m2zns+yoW+Xi1lZZIpgtVoJrJfnJTBpbcuy3mx2VTU77Nuynpus2uxabSuTlYz68vLqT/7kJ5/99hPkWBV53x0yhNj1Vqt/8Of/wAf47MnzbcOLOx86XfWc9cGeXHzoPA0uEmliqstqv9/fe/BBVJayqmNz5/73I2YhgrbG9cMwDE3ftX1nqsoUBTNjDMSR+Dj1V2wnBCmMYgH/iYkYiccZGK/90Dhg45UfjPyFP7d+/xa57Xl/hfj+d/Lmvykvv7rlh4DlhSbUhOnNN9Uzv1P//J5y+/ogCjHkN4R//7sqqQ2YmWP0IbgQXQiBGYbed90gvM1aK6WROMbgkIMmVMQInoOP0SNHQJnWhwwhuY1EJHqWUPd9//zm+ubmJgAvl8vLq+fGmLIs27Zdb65JQVnlAHB9fXVxcf7rX/+qrmvvB2vtxcVFVdd/8zd/07btj//sTz/++OPT8zv37t37v/7mr4ui+Iv//h/+7//7//7k8tk/+Af/IAA/f/58CH5WLwBAioJijKenp5vNJiVXxUvtuk6o7qTY3zk3DHKmBgCIVJ7nzvmmaZhBax1CzLKsbbthGPK8kJ4GQai01tIfJ71dzrmiKIqi2G63sndJib/+tBARAoQR/4EQFaBVGsKLgpbk1/NIoQyvuQtxZIxQSh3HOKd5zq89aeOuMQQPwFlms8zGGIahE9wPEprHJK42oc6yrCzLq+c3dV2HwIvFYr9rjc44Ytu2zvk8z09OToioH9rMaoVsFGoipVSWFdoUjql1bIpZHzCScR58ZKVM3zvZY57nNs9ni1VeLyKZwcUQ0fnonBuGIUSHeJxh+QajH/k7jpK/qWJ91/KmhvDL5X3g9s4lGYAkghdLa9IwdMe4e8QTpB9KavwBgGNqF5iUo4RIDN57Y4z0Ax8Oh77vrdWzWZVlWQhBOpLm83nbtrvdToyB4Bh5nmtNQnIpNeyHw2G73Z4slo8+/exsdXLv/OL//e//z9V8Udjs7/7mb68vn/93f/pn984vNtc3CrDKC6k4Wq/XkrRYLpfr9VoUrmjGruukQy2OdPzyTblZ5TSllazrOkQUZ3+xWIjSn8/nVVXJ8Bbx7pumEQUtFf3CurPZbJh5uVwaY5K/RoTHH4VIwBy9dwCsFMUYEEFrdeTmUyC1/+m3zTQSv9IQENl7P/R9l+UWCQbXAzJD7IcOCXxwkQMgI4H8JoWkkJm7rhuGQTQ7AEi3WspOy/VNhapyal3XdV0n/RN93wNAURRS8htjrOtaVm8+n0utkdwVQjAl9490ZSOi/EmWZeIixJHOqK7ruigxsnQtcIx+cLLseKxNoK9Rwb1dmUbqX++RvC15bwC+ZZIyh/LPqfMOx/syhuiEw1kmBAAHpVBPylcAY3BeYHHJZ4oiGD3r3odByEFlqknbHYosn5IWSNVp3/da62fPnn300Uc3NzdVVWmtnzx58vzysi7KPM93u91f/MVfXF9f//KXv/yH//AfPnny5Gc/+9k/+Sf/5IMPPvjtb3/bdV1VVYgYQqiqquu6tm3l5huGQSlV17Vw60vDmugUAeKrqkrNut77tm2JSMazJKR+tVpJFVNRFLIFKdIXzZXKLuWshX9fKHok2QuTtjuakMGFY5sriQWVkh6GkI4Hx7ZhIVYCgBS0wZhyFwKPOHKvCn0Tjsnh6d5xpCSRKTFSZyXvi22WPaY6IkQUTlbJCgjjtzB1S2OBWLvtdivBorW2ruvr62s5EjEnScUzszAayVnLvPiUt5CqX1muvu/7vhurpNxoh45tKO+64/ftKrLX5XU//att/5sWAdwmX2093xuAdy48GUuCk4og5wbkIKxbHOLgOu+dKBR+UXrBMQYJAkIIMJajSL2K6Mery+fRh6qqstz0Tbtbb1zXZllWVZUbuv1uQ8izqs6Mjd4PXef6oW+7GAIhcoyEaDQBxBDC1dXV//Q//U8hhJ/97Gf/4l/8i91u9/nnn//lX/7lcrn89//+33/++eer1SqpdalG3W63gjJJKlgpJV+Qh2TqUc5mM2mVkhy1UNrhOCqnbVupbS2KQs7x+fPnACCWIGlV2XJZlk3TSMpB7NBxOPv4NZykZKS3TvYi/RNJZScDkLqIXwRekzYCwX8AQAybBHBpHZIbjpO0v+AtYifkYsE4hAde1k3Jhe/7XhLp0l0s76c2Zukv67rOWisxQSIuhUm1scQB0nmXDF6Mcb/fSyDSNz37Y4FZDN47J9GDIlIISlPqQ/xDPBvv5c0l3iJfbWvvDcAfSKaKSZTL0PdHtEcjEUBkZKDjLNYoSh+ToxH5OJeVSPSU1tp1fQhBXHtJlvI4ZjI3lggPh8PhcFBKSViQ2EbvnJ9++umnFxcX6/X6cDicnp4Kti7H9sknnzDz2dnZz3/+cxkt8NOf/vQ3v/nNycmJTE9crVYhhPV6LVFLlmViAJxz+/0+UVyI4hPcXJx6RNztdlLRDwDiGouWFJ4fKaAEgKZpbm5uRNmJEw0AyfKJmYkxzudz0ZhpkaeqXx4MYaSAcSSAGCGGY0wgxkDCiMTGgWOJgWxQbIN0XQi6IquNI+Q13XVS7lVVSVtGqj0Vy5GMTZz0qckJChvg+fn5ZrOR9RTW0mEYVquVrJVQJ202Gxn3JtU76ThF3c/nczEAyapJw4dMLksB6GgvgQhkIoVSimTs77unefi2RADv+jjflny143xvAN65xPhSAbXclyPsENh7BUJIgJF9yivGGKVqSE7FYBYAAQAASURBVOGxhkE0qUKEGBUBKWjbg+vaqi6UUsF5DtFYVZSZqHJxWkWHKkXeO7EQVV2IZqmqYhi6vm9F/RmrTlaLX//qF7vt+u7FnV/98r8NfVtXxc9++ndXz5/92Z/++N7d8/1uk1mdWe2GTvAHyUIL5iCDxnCCwIihSmMUpT9W6BDEh03pDcG7heROoA/nnKD/gmuLsSmKwhgj4I/U/Ij6FjTmBXENBIYQggvBeT8URQYQh6HLC0sKur6BYxoWYvTMQWsiAu+HGH3i4ZaSLRnaE9mXZd62h75vjVHMIUZvjNKapEY+fZM5yDtC/Z0gLPH9ZeXFGMTJ7AfJqez3e+EUUkoJcR4AhBB2u52wNuE440yiJWk6E/4P0fgA0Pd9Xdcw4SGv69p7v16v1Ri3tU3jnZMLBJFR1AcBcSTpBYNvnIL7avI+B/Dl8t4AvHN5HT2MMUL01urR02SjkIiid117IEKCGKPnl8M6o3TSI0REgOIyr6+uGcJsVhdF0fe9OObGKA4hz/P5fC6coEKEIMD3z3/+8w8+uC8DA4ShOrf6sNsLCh9jlJn1RVF89tln0kv8wx/+UIp8EPHZs2fMLArIGHM4HGTjwkJBLzPyj37lEe9O3KVd10k0ACMUIynQNDBHQhn5SNjuZJa9Uurm5kYMgBQaGWParoGXH/K01JIxBoAw8i+J8y7TDXlszcMxDfDK44SjXy+FrcImJO+k4OaVh1B2nZK9yRCmawdjIA+TpEVVVc+ePUNE8fevrq4QUXYny26MieN0TzngEIK0RABAGhwtgJj0CYbjGLiZ1ebZ4yfy5bZtD4eD2G+lMEQnRutoQSECMKl39DR8++SbFgF84wzAmx7QFz4tX0He9XHeJvTyHAIY4Z306VQDwjiBSz4VREKc1hi9NSqzMl02KI3C7oAjnqvUsRFMIWtDITqEGH0o88IYfXV11ewPs9ns4cOHdVES0TD02/UGGaoy77quLEvkyMFDDO3hcHV5GVx//+LuJ7/+zUffe6iRPv34kzK3VtPV5VNhMN7vd7vdVkpopNi5KHLv3Y9+9MMYw89//rPVarlcLn79619praTuvixLAayVUuLai35MU3PjSJgsmlprXVWVwDtVVaUiUckNFKPIMpZleX19/eDBg91u9+zZsx/84Afe++fPn4vb671fLBYCm8zn8xRXJTxHIB1BqCTnjGMGRf4qJdWFUUNUbbJYku8Va5FlmXTeCZv04XCQDHzTNJKEkGxt0zTWWnHhJXUst0EI4ebm5vT0VJIHkr8RSMc5V9d13/dPnz49OTkpiqJt29lstlgsdrudzH8+HA5S74QjbCVFscMw3NzcfPjhhwCw3+9ns5kEDYL7yV232WyqqlqtVtZm++0hs9Y7J6u9mM3X1zdiq4yiusjz3MYYgh8I+LYk8Nt6jt71c32bnnlbx/mm8raw+7e1biLvI4A/hOAEFYHJJYzRhxBicABAzAyBgx/6NsZgFCqlOHrxfH0/AIDgv8zsvbfWrE4W52d3ZP5X1zQ8lsR474P3AFGyrFKMn+dWKbXZbPLcylxJ8RONMXfu3Om6rutaaWcty1LuJ3E5Hz582HXdr371K5lAcHNzg4jixUsEIEclnP6CyIdxADJOgHXRvGJpmFl0qMAaOI7NYeZkNqqqkhbfxWIhJKZSNirHLEhRSpjHeCslmcQQYmZwTG8qheLOx0nzcEL28eWEjch2uxXOpcS/xMxH6GncUcrKxhjFExebl9B8+aZYRFHi8qlcU0nVIOJ6vRZj8OzZs81mU9e1oEAy2yeFTTCqP4Gb5Eik0AgRJSCTHICsWDq1ZN7kohABEZE6/kZ8QZXxXt6WvC3D+ba2I/LeAPwh5BUDIKIJkEOMHiCSAoEIEFHqLNu2ORx23ntrVF2X83nddR0A5IU1VhFgXVanp6ezeeX6br/f9n2bGTWryswcyyKjDwoJOQ5dixzrsrLaNIfdyWqllbp6/my5mBGgH1xuMwIkAAKoiiIzpm9bZJ5VVW4txNi3bdc0i9mMQ9hvt/O67ppGwH1RcNNTiyPbmijExM8sOAwAJNxpWggkWAqP7D0xxpOTExl42bat9/7i4kIceamsr+t6agBE5U2m1MYEzSuNIToktpkGiN4PAFGaCWL00q0tkZa06U3fBIiSRfB+2O7WVVVoTU2zJ4I8t5JjEOhf/kSyAojHOQFCzycqW+rx5UxjjHmeC7AjzRmyCHmei1rf7XaSfv/00093u93Z2ZmEBTLXXtYtFfhK9kUS3cwsSKDYWmaWgEMotcXgEZEmRYDO9URkSBmlFIFCUIQkGuY735/5B5f3BuB3yG0n9qYn/HYX6O8vOGb51MtDVpPGJyKrjc20VUppLIpMEXjvo3dEII+69559AADxtaWrSyCIGCOHKE0AUtevtS7LPHUP0cggrQ0JbvP06VPxqQWLX6/XkkJIIMnhcIgx1nVdFMUvfvGLvu8/+uijPM8fP36MiIvFAkaHF8eJZtITkJLA4vNKVSIieu+rqkrl/1IhkyqXmFmGqCBiwn+MMVdXVxcXF59++qmMFXv+/DkixhilonFqXfjlUpzpFZczQsRUKwXHikwUqEfOOr1I3ctydlLvLx1tEhJJWREiSj1r2pEaBz4jYoxH9Em2IICP4DNiL8uylFBGHPb0jqh1MZaz2ez6+rptW+ntkiYMGH1/wYLkteRL4tjMLPi+RABjn/mRKHDahsbMNtNH9/+FCY/Sav4HeDS+Fnlb+uRd65k/jB77BhmA76qoUXDCNT/mDFghIx3xVvlC0zSIKFAJADTNfr/bNO3+7OykzKzwJgFGIoo+XD+/kui+qqpU68nBG1ICMRGRtJWKMcjzfBi69fpa3EPnBmvNbrcdU69BqmKkpgWRlcLDYdc0+wcP7sXonz59nGVGayqKIrxGsCwiXjyPgLWcrAxjEUUs6UqByBPAkv5EShuVUtfX16vVar/fM7MA4uLYJj0LIz7zylMxVf0wtgLIO1I8Kqsk3VU8VmcmzSiUczjpak4FSDD2u4k7L2OZ0wVNIvtNiJMYaTF4KQ8splFSEWKT5vO5EFzHGFer1fX1tdj+tm03m433/vHjx1KKSkQCPUkySc6RxiYJHDG0BPXIKUPk6KNRBiJINTDEaJUeD5lxZIHGyHFCBvde3oq8rRzA29qOyDfIALwtS/uHsZy/v0zLYJLCInrBLgkhhhCCG7z3EMLQt4hsrYZRYa1Wqx/+4KOLiwuJ4oVHIbJnjuJalmUpU0REVUmKT4yE7FoShuKBXl9f53l+586dm5sbGbErOdi+b+V4JD3LzMK+IMMdpXpHNLj3PsuOdSYw6llRN0opyUCqcayN4N0xRkljSt5YylcSBMRjB5PsHQBijOv1+uHDh7/85S8//PDDGOOTJ0/KsowxvhikM6mieSW6Slc82QAch6yJ/RBbkt6UZK9kL8RSylKEkRQ6jpzPcsxiUOXUeFIFxCOnEI4BBxFJMkA+kitIY5uuVPTLpSnLUi6cUmo+n19fXwPA6elp3/fX19cyAFka6GRt5ZTTcslqI6J8IY7lT8n2C+WneAlHA/AyOHk8BQjMkfk7S/HztvTJu9Yzfxg99g0yAN9VSa1AMPYEiHZIL+ShTbTDWmuBSpjDcj67d3F+587pYrFo23a9Xh8OO+nal2+KGyvRQNe0Uk0v+kV0nLiQXd8ojVJ80rat1MzItMWu62SauaD2MA6rads2tY9KMlYaqUTrCcjwyn0pL6R+URSTgEKCBcmxHbsZxpDo6JyCkMEdyxbFKV4ul9vtVmst7v/hcBCYWwKjNBhZdqomZHCvXwJZB9m+YGjC60AKkDiR/4ToJFsgnQQhOud7HwakF3MFBJtK11GgIRhrw0Ttpksg5nkMvAbRyMkMSIuGkOjJiUtmWE5TyHkuLi6k51n6qFMfWUq9pGQAjK3OsmUAEKhKLhmPDRMykFLgKcnba5L+X0VE0gHwLhTNe3lbCv3tGob3BuCtyetpM3GixMViBIFW6ZgwPOLOSinUChEZCRFBKQAQXoTZbPGDH/zg3oMPuq776U9/+vjx46dPn+73e9FB4slaaxiCqPuu62L01uosy5Smtj0Axsi+affD0OW5zXPr/UBExuibm5sQ/Gw2u7q6YubIHhHFURXftmmavu9ns9l6vRaGn4igtR2CL6rZ7tCO+PmxzTU5y+v1WjQUAEg4kkAb5tj3fQheZgOkCneROI7fEpf84cOH//W//pcf/ehHbXtomoZIxm9BlmUMwbk+RimyfKkMF75oII8cZ8KatNYhOFF5epQUosn7Av4kXCjTR64eozURRSEXQmzbFgQCklBD4hJmIgquF5Mp5lAMgBgSWWep+pXcPiIGz5ktpFj2yDIU3XxR73a73W4ndbcCiPWdAxadbYzOiIjjizxESiGEkTwVIjNjagxEBETOMpPntiiN0kAqSj8wEIE6Xo7vbBLga5JvpgHQr7/1ptu6LV/0trZzm9y2/QT4viJTHfH77Jdua4aMx+j4qF8AhW9cEZFofMBIAIgMkQAYmDRKpQwpUIqA49B3SinPMQTJyGmgOATvnGsO3Wy2uLh79/T0TtsPH3/822fPnvVuAKYHDz5cLpcA0LZ9u2/FAw/O913T9cfmXkRs28PhcNBaMQYXHGnQZNu+FYTBZvbRk8+rapaXdnfYaqtmi7ptGlGvh8OOORRFlef54mT19Pklo4pA2ubtbm+MLcr6ZrPJijyO0xCdc3VdWWuGQf3d3/2XH/7wo7qudrudUgqA8zzLMrvf72xuY/RPL59+//sPsyK/vLqUtLALbjabPX36rBv6oipRUVHWzrmPP/71+fmZtfrx46dte1idLLbbdVUXRZk9+c3ny/ni7Ox0u90iQVHkz549sXnp2csYLYHXFcJ+v8+N1UoF9jFGo7SLToyZtVaMnFJKRi4zMwLleSahj9HZzfVGwJkQAkY2RkfnN926sFlelRpws98RQwBWSM3hUGZ5O/QQYmDug7tz50572J2uFq5vm/329PTO0LXEcV7NLi8v5/P5488/nVXFYlbt903XdVpbpczdu/d/85vfOOdiDGVZVHVx586Z9L7NZotnz54ZYxBJaVMo2/R9lmWzRdV1rVa2yKu+64KLCsn1g7U2M7Y7NE3TaFKzqsDIs6oIwXFss5wGd5jPayQEiIF9CJEhIkKMIfE888vDINNz98r7b/p8ven79LZiktv01Rt+/zZtdZteum37t2q9W2D927b/pscj8jU0gr1r+RqP53WvKeLYFwoxAitxSEHyqyoRpfkYpG0JEZcnq8VioZTZbrePHz+9vr5WRt+9e/fs7FwKRaQsMp1UYvEVGL3v+8Nht99vyyonAud674dphaJzvVIqz61gMtLJ1XWdUkfqMXHnpZgExibYpuuGwS1Wy74fnl5eLlYniTtIstApUzqbzaTiRUrX8zzf7/d1XUui2xh1OBxi9HVd4ljzI8QGp6enAlgJCC71Qm17iDEaq5g5L2xZlrvdNs9zm2nne8ColPJ+GIJXSiEcSd+mdG8Ar6YEJL8dJxQdU6UjGJce2ZXTdrTW0XnvvSROXdd778ssH4YBIwMAhMjMVh3pj4zSAsfTyIMtWQFBwwSFn3QL8zB4ofdp21ZSDpeXl7/+9a9Xq2WMcbvdyuEZYySuYubFfNU0zX5/qKrKGJvKSY93I6ICxMgxRo5eAg6thY0uALA2kOcGMLwonJXu6K/0rPAt8lW29V7+UPLeALxzkccgZSynhSKCt/LIDCOQ7sXFBQA8ffr00aNHbdvKdFkimlW1UToVeEz5y4hIGxLKaNcP0QdELMuSEL1zMQStlDVGKyXTUQixyPOh743WdVVtNxshXBO9j4jCMZfKyff7fQhBGncPh4NUFqX8bVEUiSjt7OxMLMrl5eWnn34q7rOMbbHGaIV1VRz2W+/ccrEIzhulkWG/3RmlT1cnELk9NIRsjBaQRPiiJQEr9a/b7VZ6xFKSQwyVvIYJDdwrWQqcTFfGCYtnum3kugi1DiJKmkFN6IxktSXvIpCOtINJSiPxygnCIxU+8rdCaJpWWKpsUxlrStQLz3PqD3j8+PHHH398dnbmvRf2N9l70zSSsJnNq/1+L/GK3A+JOfV4z2M8pjdGOEgpxRwk4y332xfdsvidH/PyXkS+YBDj131I30GZ6p1ULBiDD+OgGIgMAJnWQn65223W63Xbtsaouq4FQe6HVjxKyd0J2ivJWBgJgQX+yvN8uVymnETSjKITU0sqIkrnkaD2ogsSpYxEG0qp5XL59OnTLMvOz8+fPn3qnPvggw8Ss4I0GcFYvfrgwYMY4+Xl5X6/f/78+fPnz8XxbLuD6FChPRDWBykrCiGIgVFKiVZl5pubm9lsVhSFVCJJjZMoOPknTHKeUiAfR5J9mjTxxglTf7ocOBIqpPenjqpUsgrbhCyRaHyxN4meCMc6UakKlXgo5bRFm0swgYhiCWhkcpVeYknepiIxGiv6U3i32+3kakqRknA6yeWTzi9ZPRiLU2ezmWxZWnlxgtXEGI/lPRDiOHfoNrD073OT//0jgG+aA/eu5bbz/cOsw1uIAN5uXep373iS45m0xsTrBIUsDFzp6j59+lQ4EsZOzo4Aq6KMMZICo7Qm5f0wDF1wDmLs+y7GoJCM0kqjVPsYY/q+DcFpTdZqQX4kcZplZhi6YeiyzGSZ6bqmbQ9aE01IiRFRhskkJSV9RoLViLYVZScKUVR5Xder1erm5ma73Z6cnMxms0ePHjVNc3FxISo71X061yuFSByiAwDvvXND33fSG8XMz549Wy6XskcYe6wQse97QY1S2Yzwhs7nc4mi1IR2LWWV07WYRgbJAEz1lGRQxRRJn5dUXgqJpoBdCSJTSkm2dvpkTm08T8pbxULgGPDRyCMtNjgVpwr+472XnoDz83OpiUrVumL2hAf7cDjM5/P5fL7bbY3RJycnzrlJ+vZ4U9FIxTo+BREwSs/Hqzbgve//RybvI4B3Lq9oh+PryKKniMiQIiLk6JxzXZdZrbVWBIhotZboHgAEaRHwYb/fHw6HBChP0wAA4L3v2y4hGKI6/ThsUioR+74XXSb8ZQm1GIYhEQuLzlqv1+fn5yGEp0+fLhaLqqqEpExcSNGPQuMs42IeP34sBKIXFxfb7fbRo0dS78gcBKAQpnvpDU4VTdJv9aI3AqAsSxnvnnqmJD8hDa6iy6T0SBzzBOnQy5QbU+WeDACM3rqazGWUF1LmL+BMKmaVmEmNJHECuyVQSE5HLKho2wQNIaKUnE4raOWiiCMvzEs0TvgRrL/rus1mU5blarWSC71arbz3whddVdVisQghtG17cXFRVVXTNImUaTzro+WTFbZWEwnBwxE/lGV/i5QPb8tj/cN4vt8cud3X/0Osw/scwDuXl13+45Ec4enxC4lYWIhuUiOP1rrIMq0phJAba0hF9s73wv6PyFqTUYoAvHfD0AfnITIhK42IiJExsgJUcKxulx+rNISokfqmHdrubHVCDNIc2zRNak0Q5S6etTjaAoaIspOiT0SUkcKz2Ww+nz9+/FjIZwSYXq1W2+325uam7/vCZsgBOdRl7rq+OzSLemZIZUYZhRwCxMjBN/td9O7exYW1VsaNSZtC6n5Kek2OSqITCRTgtYyL2IwkUwMAE+rWV74gzrKoaXH/RVPDOGUBhXFvHNclfyVgTvL35R1ElDGcovElhZvm0hhjJM4TCyEhhcBNXdctFgu5JQBgsVhst9vNZtN1nUSHV1fPQ/Cr1dJ7JxfiZn1VVjlM0BiAqBQao+SmArGC7IlQG0r9ie/lj1beG4A/xPG88gJGfoLERmkEuCBg5vXVNXCYz+dVmfd9t9vtOISqKkJwqflWkHdNCgAEEhmGQdKw4iPP53OjXhAy48QvDiM/PgBIH5MMipK8oiggAJAEQIxROClDCMJV4JybzWaCVKSyfcEo8jx/9uyZVAE9ffo0xvjw4UNpdj0cDsIUjWMEIBQ3MKIicexllc7Y8/MzQTzKshT9nvDuxKgj3Q+yFGk0MY/DtnjCeHObAXjlxpDvSE9cjDH9OSKWZSk5cMF8aCS3kGR4gu9xQkMdx25bWUk5YK21mBMJMsR68UiWJ0CZLDsACNG0XD4pphIef0lLXF1dAYBwU8cYY/SXl5eyBYA4hRyVUtooImAO3gsHqgcA6aJ7W7N/v2nP3Xv5fYT+/lj528Lc3/QG+qYlnV7fu2wnjiT1NE6gBQCl1NE70zLjyyflfnJyInnCrus0qTzPiCg4F0KI0bN37B1ykGye64cjjaVzEKO0BhFhjGFwHSkgBYARiQfXDa4zVnV9U5RZUWYhukOzO7tzQgr2hy0AGGMEWxDiAYGwiUhmQIYQ7t+/r7V++vSppCLn87mQOiwWC5nTK7iT9361Wq3Xa0T88MMP1+u1+NFSUFSWZVnlTbv/5JPfxOhltJb3w83NlTQeC8n+1dXV6emp0CTIAYjCnep0mZ0iTcLX19fJZ8cROJKeMhkekOpzAEDUbmrBpQkXQiJTY+bD4cDjRAGpfRLIXrafAjVJXSCiZMIldgEAGciOY36+LMubm5ssyx4/fqy1llY4yfGK8WiaRkbAxxiF/FlM4P379y8vL5PtF/T/yZMnRVHIiIKqKrz3y+WyafYyjExrTQrScTJzZB+Cc74fhj5ElzifpQgVJ2EQM041wys39isPWlq32/TA23q+6Bb5uvTG25LbjudNj/Ornde3IAdw2wV+WzfWuxac6Jfp++kKyWeaQGuyRnnvIESCY6OApiOThKRPhWBgGAYIUbCj9tAk7YaJVcIHeaRxZJtI2VH5p/i5AulITJDn+Xq9lqkmMKrIaR5YnFYYG1mlAifG2HXdfD7PsuyTTz5RSiVQu65rMWOnp6cA8Ld/+7cy7EVwGyKS+iJEPDk5kQTmdruVopq+70NwclIA0gN8PBIiElJoQcb3+31qrE0mNlnZ1KwwVWdTvcYje09Cfl6B7BJintjuUrJBjez/shdBxmDsnEDE3W7XNI047NvtVpgt0unHcWQjj6MIksYUvooE0UjRlBAZxRjzPBdeIGOMlIdKR3GeH1sBUApA+UWvg+xO+KNG+k8cWQgjvHkb5nv5bsh7A/DORY5qWpsoD5tCIkCp2UB+qUXgWBaiSGlEYogx+iB/DEeDwQARomcITdNEHwTqVYgcQvReNDWHSIAKCRkUktXmWCyE1DWt64fcZsjg+qHMC1ErRVGI/5tYxkTpqJHPR1StKErRX+LaI+KjR4/kUzUONuj7/nA4nJycIOJnn/8WYjRKRe/rsoo+VGUe/CCNC0Zpq030zg99cEPXtH4c/IKIcWx9ENPC4wzh2Wy22WwEXUkEOGKWUo8VvOy0TpX+1AaIhOOAlBfQqOxXiqCSyk4ok1zfRG2dciQCWyUOVMnAyz8lzZOSKHKl4th0FkfARybepGqi+Xye+CokPpvNKoC42dxoTcJOKusg7EZwzJA754YQvJiYEDwzK41CyASvdfOK7/8HejDeyzdAvoM5gG+aJIU+zTfCuG7MHKOPHCAyMgPEPMusNWqcTT4qHd/3x1qUBER474e2w5fLTHEsNEQGP/IDizZMz/z0HVFMQhIpWIfwl0k8IdBHHPOZwpMsBS2igkXZSflKnucC7hdFEUdiu0Svv5wvrq+v5ZBmsxkzS+OY9/76+rrv+5OTk9VqBWMl/hS0SXpZFkTqUNU4OV1MlBgkd8TKoqha+ZReYwp6xeGd2gZ42WDgF/UWJDOQ8H1R5ZIPkLosyfEqpbbbbdM0qSmamcVeJgOQbFtCt1JjgSx7URR1XZ+fn4tRlFTEcrmULjk5SJvp1BlHIzOdJJNlHWSyDfNxQBgpEPd/ov1fvEj30iur9CVy2/3/pt9/W9v5tjuOfxh5CzmAdy23YYu3ydd9vF8gNA4LfFmJOO+H4Hz0Lyr2Ej8EyIn7APGINgBAmleliHBcmbywpMAPLjjPHI5/yp4IvXcxhhhD33feO+F48d4xR62V1irG4NzAHEWJn52dXV5e1nXNY7+ruPz0ch+ZWAJpCRb3/+bm5vLy8sMPP/TeC8wt2kfgIJkieXZ2dnV1JThSjGGxmAs8og0xBCGrkCYD4ftMJaGi0HFkfJO2Lzmqm5sbyYEnUxEnvbjidyfT+4oen16gpAVSWDM1Bsn3n3r9OHJLpEwAjnNXhHI1TYORNIAZZ8Uktu2U06axvyyBeMmQSyZDCpDu378vX16v1zHGxWKxXq9lUz4MUp5rTJrmziF4yX9I5x2PcQ+N5aqT83+hSV9fmS98/718N+R9BPDORZwpqRecNiglfOCIKRNorXOZleg9BxcntYwC+IrmHR26F+VAooP8yF7JzBg5KcQ4FnECQIIvpjMClVJC5Tmfz7fbrSggab4VVCF1HcuRiHMtjbLirvZ9v9/v5/O5FORIQZGkFqy1+/0eI8vBS//qer0+PT3VWm82GwCQWbubzebq6kroEIQjU7KgfjI3BseGBjkXsTHi/gtmInU1iSQ5Tiij4eUy3NddSPnUT/h/REvKxZJl5wn6LxeFmcXMCF9FavIqy1KyNbPZbDabSaRV17UZp4ABgGBHMI6Hk7xLmkzAI9rGzCnREmN8/vw5AEiVlExHkGhJRjymg4QRWQohMAckYObInijV/wAA8C1BwPsI4I9B3ucA3rnEseHoFQNgtTbqyL07ffCSpzny8qIU/MBknAAetViI0R8r/TUyBD+4oetTExMBEiBEdv0QnEc+ZgX84CQlwCEapTNjxZ0X5fXs2TMpe/feLxYLUS7eeylglyIZ2YUoL8FkxB+X0e03Nzd5nktUIco9hIAIeWZcP1ht1tc3BLicL4aul9hFShTbZt93DUcvs8zElU5VleK9FkWxXq8lOhHXWHKtqUAIR5KGMGH7ia+B/qIZxUhM9YicVLpeiBhHgH6q/VNgIZ8KLte2rRD6Sw2PHK3MOJNdJFhfikEFbZvaFWZO02kQsaoqQbrEIt69ezfGKL0a3nubaZl1LBZCzMnUgMlSyMTp3xMHg2Mm4L38Uch7A/A25bUHRzKQUmynFBIRIUh5hpfOXmMMKg0APkTv/eAjAADSqCmAOQQ3DK4bht4FR0Qms1lmUIEPQ9/3MuVcTEmIbnCd9wMzZ0bR2AAW2TMEqQyhkQZHtKS2xhjTNK01qmn3UsuvFGaZ8X6YzWYhujFEcAIcee85eNJH5H0YBnFOHz9+LAQ+Msxd2H6MMWVZeo4yWEZ6u7qu2+/38mVm3u/3MfrValHXdd+3wzAUZUbIPgxu6CKL6RIgCObz+X6/l77Z+Xw+DMORMd8QYOQQQwjRh+B8MqVJ6Y8vIEbwHF0MMUbPkZkDMIzsrRGBiMhopRTTsYhTjaxwU4wuxXDSEND3fWLLWK/X0soLAH3fyzz3VGAqPQESZnnvJXITVyClMWgk3ZM8ivf+/PxcbiytyfleykwFa5I0g4QgKXaUOmCttTZEBICe2QMc2Ue+sAOAmd9WZ8B7+eaLZv79CaHejO/7bcmt24+38Ia/IS/5lwi+PFbwyzcSQXQIRlTAAEwgw0oAY2CEF3FAx8cRuvJOhOhDDAxEqElrbRSQPPAYgjFKW61i2OwaUKhJuxiCcxHZ5NYCee973w/DYExWFNmvfvWrH/7whzbP9od19C1p64eBvcsya61umnhodnmeB469G7S1EbjpOjmS3WbjXX/n7KTtDuuNunO62q1v8tzmhX30eGuMWSxm+/2+aw4yE/hms7bWlmXZ9p3J7GK1vF7f3Htw/1e/+fVitdzv9w8fPgwxFlXZXh3AGEAl31yerA5tc3rnTBnVNE1e5sqo3vVAbHPRie7YHR1iN/TRew8BGaKCfXBFbqXsXagRivrIk2MUgaJ+6Bkw09rQUeESkVIGUwYeQRk8Zm45oiJmcN4RIGkVQtDWQOTeDQrJ5hko5buOmK01Mca2PWit67pGRGHALstqGLrD4WCtXixmzOHq6mq1Wg2DD4GVMt53s1luTfbs6eVisarrOQA1TaOUyfNyHD9gnjx5khvr+2FRz4503CFWebFer6PzhpRVWiNZqzNjEIPniDH4viNUWZYT4DC0McayVMTcHnZEsFotgPnmZs3cIrssy4rSWGti9MzH8XMv3cUjsfwr2bRJ3PmWnvfbRs68IXH+bcfzpu/DGzZFv+k63Oabvq31/Gq+7/uSr7ckKJ67jGaKwOPCMqljFK4kx6sUaqJjBSiicLYjKiBEUBGBUU2imQgAhEAMSiMAuOhi9KhRa0LEEL3zA6CQD/eXl0/Pzk4Oh0NwA0BQimL0ANFmmiEMwyAlg5KNjDEGjgBAymhrhqEPIShFeZ4pRVIyaDOtlOr7VmZICfov7q+eTNGCyehj7/0HH3zw2WefnZ2dPX36VDrF6rre7neijo9WsOv6vr9z547URMIRdRGILDAzRw8ckFgrVBqJCDAmNAYmZJ+SVsUYfD+EEAypEMJ+v/fez2azNAgex6FjiKiVPaI6CESEihAxcAwhoCJZGXn/uEqEejK1OBUgCbwj2QiJq8TGCM4jLNlt2y4WCykHstbKIUnPdnLzxfGXcxGvX5YXx0qwBEClZJLWWmY5pq8BACJKQMDMiRooRo/ECvk49gtiYgp6197bN1C+gcjB1yjvDcA7F5qIGkXuuemb6RZMxSrT+xKPFSZRFHqqK015TpnBstlsVqvVMHTeewTQ48iRojiOmRVyZsknMzOHiAxaodUmkbsVRaFJuX6IMRZFYZXum5aIqqoSzSVHa7URNn8OESJrUsJUyiHePb/omhYiN/vDdr3p247GwSyCUUguVKqAqqoSZZfI7OJI9JZUnpTQpDfl9BFR4Jd0+qLrAcB7L6wVQjsxNRhpC9OqHpGkkcPIBaSUSrsQAwAAaSi8rA8iSrKXx9Hz8h05yKZp5Hy999vtVgo6D4eD1NdKFalU8khEmC5QSjPwy01qx0G+WkuuO9F3p/ukKjKMLI0RRZbTsYvi2BaXyosTLPYHeAS+UfLeAEzlG2QA3vTCvK3vv90b4rbJwAIri06BiYqfWoVpteJrNuBFnShNWlVT5ai8FlBYiklgQp1mrWUOzvXJr8SXJmQd/0lH5kgbYxSGZymtkeZVaUYV+h1EVJPZuSnRnTb+4MGDR48eFUUhnvjNzU1VlFKxI7xAq9Wq6zqZ7iLqMp0XjkQOabOphjKdV3on1f4mPjip2BHtJtNdUmodJoTMOCnJTRuRg5d/phMUA5CsiMQQkuWW/Yrznhj95FMAEC0vzc9CrSF9bWnKjcRDMvBHNpvuhPQi7TRZerEQacBLwjwREYmttSH4EJ0xKstNjN654ziaVEs2zYd/tfv8uyd8i3zdx/Vu5RtkAL7tkizGKzaAX+7IlwdbUouvG4BX5CU7FNkolRljtYboox+Io1VkSGHkoWutVnfPz68uL+uyhDHhicCEo/FjRg4hOGYmQE2KCGWQcYzRapMZK0696NDoA8GxokbURwyBY5TJYoBRksyRvQ8DQ0g558F1Hz58sNtvSEFe2LY7PHv2JJXHCFoiXWNCZZMor6cVU+nZe0UbTg1DKqwKI2enmKsQgvQHrNdrodCQbC2N/G5i0nCs4UlhwXS/8HIVvFT1IOJxGtdsJjSlbdumjK4aKUulWHa/31dVNZ/Pr6+vxdRprYXQTb4vN4Ac4XQ9I3v5p/zImyE6UpDlJsuP5WNykwAAcAAOMiBTTkpiMiKQrrV0dlM7ipPysz8eibfI131cX498gwzAm3rib+v7b7qdLzsFPpqB6bK+KDQkRK20Ncoc+bmSDUjA7tQSvHYwRzqEVyIAGOvljTFCvwMAzDEBGogolMJCaBNjZA5IPI0ncHS0E+gh208jBKw6AiDTdjYaZ8hMSyRh7E44Oztrmma5XPZ9Hwb39OnTruuEAS0x7EtTsVA+iKWhcdolvVy2mIyi+O9p2oEAMvKH0rwmr8WoiKp9/QjFGKQTmRrjODadTdF8AWFgBOj0ZA5aHHky5FDVyAkqJyjnJWSlUizbNI0cnlzr1PxFI5SfmrST6Z0ezDQYSjBOMorS/ccQEIUQghkCQ0CIRJDsZTIAX+0+/07K+wjgvfy95JWihtdXlsaG1dRABBOiiFdQoNcfzpQDYA4JBBdtLnPerbXeu9Vq2baN1hojR3ekmRz6jgClY0uj0EQi0jEOMEpZrVOmNISADMIm3XUdhyhAUHQ+KSwAgBANqUwbQ0qGDWgkq7QUqwxt98G9+8QwtF1dlJI/kLYvSZyK0hRiS0SUdgGazIdREzIMmMQBonmPjHgThTsyIUMCOpRSdV1PFTeMLU7T9Z9mZQBAKj7V2N+rJlPdRQWXZSklOk3TSAGobE0iD4khDoeDNNYxs5BkrFYrPY5xlhWQc0zUDlOrr8a+cWnCSKEPTmllQ4g+cAwcx8YRAEMqeK+QjFWIDBwIWFGUKzZdBPhjNQBv0eH7Dsh7A/A2BflFEDAVlnJQItIKtSKtSCv/Mq8AvsxV8PqtmbKgyeXEkTYAAIqikC7ci4sLqb4HiMmvHIYBCaxWAl9MUeNklqQdCSYqEsfB6Jk5oigajy5/QrSSU5lOIbGWCqnD5eXlarWq6zqRg2ZZJiNN5BTEOxZHHsdEwpQOITlicuQyV2Da8RRCEIY1OSlJjUr0M5/PJYiZJlTFzExjginaHifMo/wyH6p8JAagaRoJtoTsM4QgWRPZi0QG0ka3Xq9lWGaKLaTwSbK+ku2YDnN/BdqaXq+0zjxmBV7El8Bi1ENwiCxVBRLqpTTB9Hb6o9V67w3AVDSPrZK/cwniLXX3MMklwqRenm6pq03P4dQFFv0CL7Os4JiZ/OKdvmFd8G0w320njhP8d/rmbduXhxCAj/8bswJIhEjAEGPUEw83eCnqkAwtsXfAmoxWZGQpiAiPOD5ord0wCJFn3/feDQCgFYJRXXB5Zjj6oW/rsvKDm9ez7XqzPFn4MHTtEIZhVlYmz4KPRWZDdArQKqOUcpG9H4JnACiybBgGBqiKQh3Zjz0wRI5a63k9G7zz3mXayDSxqEmaSPLcjpo6xMghhPm83m63AHE+r7uu6fu2KAqOPgS/3W7v3btnrZVRlKIBpX5JmmllEq+1VhFIYdJUHQuqIzQ4u93u5ORECOxijN1YKI4jgBNjFB2dIJqUSiWirj02NgNAosTgse5IKCiqqvJp6HzvxFRI8CFTGBeLhUQwaizmkX/WdZ1n5fX1tdb6/PxcBoFJPYAwwSmlJOjZ7/eSsei6RnL43vssM871WlOM0LZtUWR5bmUAXIw0DANAzPOs76PreiIqisIYE7z3fkDkvLB5pgFiP3TD0MfoSUFRHItNeWRUTY3cX/4c/Z764Ta57XlJj1LSA/Clz9ebbn/q5cDk+EP44s6n207wd27/9/x+WudXjudtrcNXEz09mqkGf12+5A54xbP48kNP5dLyzxTjp5KV5PHxWPLxxRv6JqFz4vsDAjIcz+zl1WIAlDNCZEKllB9rsZP3z/H4ClI5ubh78UXB4utrK8j+WN4+FudAAH4x6gQAIBwXWe7DtMiIxzxwcgVgUoJJRAxHD1SSxuLdizP7hUshlZeS5JzNZt77PM/zwiLEYei11sIYKrDJZrORNACMDBnJMQ/j0HYcgSB5HUbi5bqu4zg1nkZWhumRyz9T3Uvyr+XFNJuSFirlGFKUIPv13uuRrE2mdIn6Fn0KLz+9SilQqmmaer6QVmeZ8J5nhVKKOaZkrJz4Kx7GNDkBY4OFfJryBEmVp3ABiYPzIThtCJGJZD299wMpsPaYovjOg9q3yfT2fi9JXs803iq3hU63yW3beT3nnsLYtyJvZ2H+3jINUKbHJjpIaZ0WiiaSDEDSgzTykTFHBJYfQiRERaAIMmM1KYjMISJEeVP+igC1QqNJkgcKQZxu5KPdFR4ho9AohMgqITwhwJhiNVqL4ldKZcZmxh6TtIDHkQYMyCC8QwRolO6aViFFHzSpxWwu1UQCfAv00batUkpYo1Ml+yv1GKl2JRmA9AwLs8JsNhMDIOkBmJiQZDYkw5ySqDjB2V6nx0kfCbmbcBlJGmBK2ixYv0D/koeYyvRSSj+X0MCJ0k8tBbKGU7a7dBhTPAoA9Djqh8eEcBgncSKzpKO1QuTj6SskRQgQQ3TRDxC9IcyNhZe9rt/3Nv72s4F+hbN+d/JNW0/9Vqzi1P1Jmu5LznBqJNKXU2l20nr4pRHJN1AkCJi+gKPrAQAQgcOIMGRZNjRDSvoRKcUxAsFYpsIvgoOj+lOAKViQrR/VRJTR5y/cZCLKbQbTgnp39IszrVI+k5lF6ck3/dArpUgrnsRkWmvvI4xncwToOSIiTdrZXqzA6MBmWbbf7wFAWgEOh0NR5Km+SIovy7JcLBZt207/XI09cQmrSUcLY6frbrdLqdc4zioIwb9Yk4nBEOw+vjwYOZkWeC02F5RJvjwMgwAsyQxIpJVKdyTr+7rHg4jL5ZKZD4eDWIs8zxGw7/uyrNNO5dbmSUPW0XJPMhBiisSGpYw3M2NkGge7j+cblEZrj7GF9xIioDaKFHoX0w35yosvvplf0wxf7Um8XcO8WwqEV5TS71QmX76d3//933/70yP8ukT//l/9klLZVxY3eVu3ffkLo4Sk/dN34EsBpTfNAXxDhAm1MSbPsmxICg7SKb+2MrKYouZgBDoQIxExAyIOw2AzfWS28S8oMyMExFTbfhxNnLLHiIDIpGRfR6UjYEIIIUBARI1kSIXjzLIJwi6+vyJAAYLStUZmBoz1rKzrcrffMHNZ5WWTd12XUPhUJ6OUOjk5+fTTT3nS3iVqbqr9k4GRpcjzXNprp0ljngyQCeN4RaVUygy/4pQwM47AV3oOZZ0TpBYnA8Jk0YSSUwB38ethTM7D5LYXyfP80HbSjSwwF8KLDPnYlHB07UMIMuJhtFLMHKTcCwCs1cfiXeQYvdA+S+paEXD0TqwFotHWWhvi4Ic2stOaiDKlkDkAMvBLvLPv5P7+hslU9X+9qvabKW8HGXyjCGDq3cNE40/D3uQT8TjH6lskxC+xKaYIgJkZGAklbA95Dq+lknjSL8YTmVrHCVoNME4UQS3MEEfIwlrdOyEZFuRaSc0JjhWQiIqIkKTU8ggvJLREjc2oclQpEBEhIn3kM/oCnyDNgUktBfJPrbUkOWOM1lpJls5ms0kYdNwjjfXv6WTTAcSRPEdaAdQ49TcdZ8okAYBEWimagZfV/fSvYGIAxrjHyzHoceqv/K1cOxw7y6QmNbkp6USQKPUBCE1F13WZzefzed+7FJ3Il733MXpjsqljlA5bWrsTZZuceJFnY+0SpZ6DIrfWGiLygWOMDKy10gYRJT544XP/PmbgdZf5q3mst3rW7zgCSGmq38f9/5LtvGkE8CWOL7yN9Xy7ol/3jG7Lbn/5gb7u0X/5ck/jienSpN+vvPgC+YZ5MF9+GRmPB4xjyxUURQgBgJh5mibgEapGxCMtmtzBGMU6wCSK4tQoFGWzighGbEa8fqmUV8wcIsQYjZgWFBWvASDEGAIkYDqpHiSaIic8gZiMMTiedLpAch2H0EPk9tAUWd73/eZmXZZlVZQxxtlstl6vm6aRfIAMphdO/OldJwaA1EuVmjBOs+n7XlpwpV6IxprRdPA8IifSECDcFWkLMVElEyZzOzVvEgRIZZG0E0vU4nsnFZ8AMOV+SBtMF1drraz13guBtED2aQJPOlqxVWnSQIoFRVL3Q4wx9Scz83GEZ5EDgMLjn6RqYK3JB8cciBAQFQEBjxyfLwKpV1582V39co3Kt0u+ge7/N209X3K6v0zbfmkSeOqm4QRpvU14Mlg11bfInT2tA3ndEf595G0v0e8raccRQfjWkWEyczUyQwQGICYk0toarS0qAsDADFF00BFs0UQqJT8jUELtI8PLbBPT5v6pFw9ACduZ5hWJiFAL/iD4hhgh0goVISkgRFISHHiO06xm0pjGGJlvgC+TFxFR4kqr61oGzTOzDEgRhhxphZXyGKnfT0nOaXGwmnQpj8cJMcY0l4bHSCWMQ7UQMYYQY9Rj+hoRQfIu4jBLCIWvHjmNjXUwlt5L2kDQmxijpFiLohDOfWGSkG7eVI8Pk74Kq4593X5wbdsqpOVyWeT5breLPhCR1Ueya+999EGSx+mpSXcyjY3NRwPJHIMPUjANESAqAkRGiMAOwAOy9wNgTLFLjABMhK+Cvd8QBfSu5Y/kNL+yfEH+6vYluzUHMOayXnrzy0Oq16EPTS9DPXzcIt0W4vGb0Xfcdl632qovwjfGI3vxn7RVRXRsAkMQMJcZAKJCfazIlEoVBlKZKrI+7gP3cQgheGAKgUF4XwAhRohslCbAIXSRWWnFPgBLb2ckRCKIgUMILPoHGAmMMgAQgWOMGlhUPAA4H0IEpbQxRlsZKB/dEADRWhvZHw5tXlpGQtIKGIgjcwjB+ZjnVkw1EllNRCTsA4R4hLXGqyl60Frj3KC1CsHneTafzw6HfVkWCsn1w2qx7Pt+fX2TZVldVvvt7s6dO59+8tvlcnlx9/zx48fe+zIvdrudj4hIRhtEREBmVmTI6sPhALzNsqws6hACImS2QA4cg9aEqHofFYBSSBz7rqmLwnP0fec5YmRAICCODPjCa0lwv7VWHJE0gFNysDHE2Wzmneu7DgAygfK9jzHmWTYMgyKSfINzThHlebnbbZXJCpvlea6Amn2DETWZIssYkT0HiBgZAQRK894TWaV0CNLara1BNwzBO2u0d8Osrg7b7c3V5f2Li7bZm9IqisgDkbeaESEzZDUoRGNywOgcOhcRmCPGGJFS3mz6+9W6lMljgtP/TtNSX/xU3Ko3vqx8HF57AN8WFAOjOhGs6QXidOvh3DIZ5bZk423yu0ONl9afgV9eYT7+/00jFv5i5ObLRX97LeQ3JKZLwi89LxJ1RgBgCDACO4gomVICIG3Qe1BMDBwRETgiMiilNKkwlnYAEIDU8ChgUfWMSgD4F0zxY4nQMduAiEqZlxEPqR096rsYpGBRxwgxRlRKKYOkATEyRo6IqLTGYzDxIvFwjAMwpjs0XYhpeCs2Q420bmEcRCzvxJF1WQYjn5+fe+8vLy/l/bZt9UhNAeNiymmmmp/kdI+uMUh4hIhWaQBQgDFG6X4ghoioGBlByQEjQmQyaoyWIG1WKn/0hI5fliKFJum3+OkJYpLzrarKGBN9UEoZUohIDCxPJ6ICSJWpEKMLPoQASpHRNOJpKQxKF05OgX2I7BERISKyJpApvxgDUlBKIQVBe5gZMWlGqRn7IyU7ey9fLvTNgVDeVG7Do77u43oVY/3CFgcBdtWE9y39iYAzShlENUU/kpfNk/6AZACSekqLkErjeaw9TaDKlG5MUOlXOOZwTFSkJKca5ZWlfn3BRaW6ceSZKH0/jkpHRMFV5JiVUjIbkoh2u51AWH3fI2LiFhU6M4Yggy2NVYDRhyFEh8TClznde+qcmiIzr0BVeGTJp2n3r9gkSbemjAiMkBeM6jiBRUlZJ3InHEmNJD+hJuT7ACD9WcfXxIAx1cWmHPWIi/o0qk8jCe7nvQ/OKzwOz6EJF3dC+fjlGcjjqvxu7T81Ob/zy+/lOyNvUAb6bZe3dWd/eYiaVEN6cdtG8KhQlDAxjKYBUyXhBAUmZkaCGF/shYgAQqpwh4lGRjjWs6c+VSTJo+JEO6BSihFFg2itY/T4MuZOX+T+y+4Q8BXILznL8k/x7iVrKqmdLMuECVnUvcDoy+VyvV6LmpYvy/ZjjEq/VP2ZRFRtsmHHLBEyKSVu71TnEr3ImU+vHQEOIUw3m7T/0T2HF0Hb8cSZ8bWMMYx8nzDaDEGTnHNFlRGqdB1hNE6IL0ju0sLCqP352BDDKb2c6ppkWHwqlIKx8Q0AlKKUAydCwChzjqf3Id6CKbx+i361J+W95fg2ykvNkCLfliDgtr6Er/dG5NcKD6ba58VreDVngohHsPIFWARwfNRNCE6U/HRH070c38GXLITgEqLDmFkOISEnotR4BECGwQGhUooUMAMSM4QQA2DEMQcMMk8coxiApPTTCSZlSpNpZaLChA8HEZfLpVIq0Z/leS5D5GezmdQFibut8Wh+WBLoLEQbIBMfmYEZFKACZIAg9fjBJ70Mo8J9ZZWmEn2QiWaIyCHKaLOyKEII0Y/jWYiQIYQAL1+XFIdJPzCNhDypeZiI8EWVFCf8TXIqUmaqNBIpQh2ZQxBIz4cQtFIco9SAWaVDCIrAu8Q2GkhBjCHGI31WSvLHGJXSMGKDAIBvCmG/lz8meR8BvLXt3FZ3/LqJlc0wH/F9Ok7ERRo9b6kddM4hqgQaJI2TQKT0ToyRR0RCvPOEXRwdQ36hmp33iKhIsSgdOHL9iMqYdl1MlekUWEgByhcqVimjFEagROqZHOGkraQMdLvdLpfLpmnkC8KLID74K3tJJ/6KyUkvFHCY1DHzWAx6m6Mgi5zc8NScRWMXboqExDdXPMnTTa4sj6xqCfBBxMxmPBbev+IKJCJSCby01sCEEFyIADitgzpeUH2MumQ9JaeCk0YBbYRbQlYM8LhOkv6J8oyL+f/CdUi7e3Fr/h5V86/Lbc/Ft8Wh/OOU90ngtymvu/8wMQxTicwkeWNRxopGaFfZLIsRIuPgXGQGRuAYgXF01RPdzehrS3FRjDGCdAiPe0lotfPiDyIACDKjlU5DstKmFBIyxCAacyxQYSBAiAwAHF4wJPuXqyaS7hO0J8uyY+0QYrJS0hHWtq21dj6fiw04HA6LxaLve5kOJiWkZVkiHgvYJfLAI+aEAo4rhcwgHbOy97Q7ObzEJRcndfrpMgGAtVYmswuGI8TXckg44YhOVvD138layPCZOKGPRkQfApE0cACAXAgW31xMm/B1I6JSQEgQAkIUSEjiBwXIkREiR09iyThobVKop5QyVo3ZHUi7gNF4H0/6SFX4e92638DH6r28O3mfBH7L8voCJm+d+UXRThT2diAiTaQVGWka0spam4/Dvs3xjJiSd5/84le81OmOYKKOU+Y2XdwEywiCnLRzIkdL25kmPGGSzYbXCvheUa+SQKZxujqMmWGh8t9sNk3TzGaz1WqllHr27Fld11rrtm1ns1ld18MwIPF048mK0Mu9aTBqOppwlKZTTp9Ob+z0IlEJ0aTdRIj+xdFODDzMrCYtb2lraX2qqpJxx2ncwuC6GP3LmdijhHFADY7MpjFGomPZMb6crE7HjHi0fFObRAokUa+1JIFRaXkEZL/vK3/ey++Qt0AGd/sW3mzLb0tzv2sbcJuNvAXqeUle0ph8ZH0JISKg1kYpQ6i11k3TCESe56UQwpCC4HuAKDgATKY7IaLWmgljjMCklEJ1rMNJU8tDiFmWIR7dVRwnySTKB8FDhr4DAPlC3/fRo7WWgBUCc+TggdlorRQBHDmT01mnFLEU9ogypZHKVOgwhWFfa73dbgFgtVqtVqvtdvv06dO6rk9OTrbbLSLWdd33/byqgY/lnkmYWRFxHPnpmGMIYm98DImj7UiXhi8YkHCsfaKxeKbdH6zSZCg6H503pCKg6/rCZmVeKFKu61H6JGJsmibPBNWB1AwsIdRsNpOSJxr5osUE2qxgZrlQRxscwXtfVUrIGyQNbm3OHJqmV9ZoraLziFjYjJmHvsWRzK5rD3AMsJzQP1uNxqosywT8CSHEGOKRH/s4vBMAIgfgFzfn637eK89L+ihBZ79nZHDbc5Hef2U77xpiuu39L9nO9Ainod53WP6IcgBvKm8d05z6zsw8jHlFIkQgrW1mC9H+AoWPX1aT+/LoCB//yUAjEcJ0LwiglHIufOGhimMbw3HsV6rTF7XFIwuTbDNhOK+szPTN6adijZLjn95UI7+bvC89U5I7Xa1WACAzjYUsCACMzoIf4AWU8VIzcFqQlCpIR5Xs0Cvn/np0O/1DmDz/06AnqcuUmEmFNwCQKmunR4iTGiEiOpJwHK3UcVSZWHGJVFJgJ3tLRVCyizEhkUZHcNqPUpSQHwkvGRLuD8ff+KL/6ZXwBX4/V+lrD6nfyzuV9wbgVnnrBuCVLSilIqIAwd4Pg2cXOMuKKIxxShMxIHOMPLasArxgTBPLIdU7iMLtRjG8gKenjkxyABHRWBtjjAEQUSYUj/QbQSkCQO8dvCjn77XWAJE5qSFC5OnaTMEWGCkZpjYAR8ozaQhAxLIsQwht29Z1PZ/P9/u9FM6/xPAcA3NI25apNTipO5qAJJH5pSL9qQ1IJuSVa0cvV4imQ00VNdOLReMwgETmI+ZThjumDU4NwHjiIFPSiEAbygvbNv0wDCF4a499v3AsYYrSJAggNA/jAUSftL9GMkprpZVGm5GwcQCAgIshvmzyX+D+wqv40gqkE/+S+/kLbfxXk6lNfW9Uvjny3gD8gWSEcV96/Ii0InbAIfjATvIB89lCeC6dc5HHHmAi4iNPJySmMCSttfcBEWHkigkh4AR2P4Ie405l70Sk9YvQQbSecyA6LnEpwzghXbaTaldS5UzyfGGEtnEyjhFeC//FDBCRUDr3fS9DXY5DC0Y+BgBgH5RRPA6ugYmBmWr/qe3Bl2W68vBy+JWOc3ps6UVy6qcXLhmbtHd1TNroV67pdJFfiVSS/ZD+DK21UloiHqVIks88ppHTmo92NBKRIiX7VRqF+O+Vb47tY3Hq+0/X4fVD/Z1QySsv/v7QzXceV/kWyXsDcKvcVj7495R093svUIaMcwFCnedFlhXSJSuaIvqIR57L3PfJEzwi4wySvYSYooSxADyOQ8z5mAo+9gHQyG15RH5iFI2slJJ5XgxAgMfycQYpkwepAooMzPIiwgv9ngzA1MglNxwmSjNp7QTmCE9yWZZElMhBmblvD1ohMSMcy/+PP6LoAZGBEIUBApjh5X6IV5QdTBzedGBqAovDJEjSwgkhyYbjAYCetGUlbtGk1l/ZERyLUEGqvcYriMMwyPwyhnCk40aQoh2UmIm9IjT62MABHGIIzAoAtIxh0OOPeiX3H6cp+okID+hXl7cYBLyXb6C8NwB/OJk6oTzO+xWFpJQCxhB4GAatesGIj0lLVMagMergGngx/Sp478UAEKlhGDxHrbUijDFGOEJMLzx0FGMARORdQDz2HHgfkvpLnv4UAxE7kbaTVDxHVnhky5smGKdKP4UConNFCUpmUlgipOZSykb1OIc9+ctd12mEaTlmnHQhwGuO5OuVP/Cy9scxCoFJCv11SCTp9ClGRGP1kZrM58IxyTzdwtQMpHWQP5dcseTYEV6gZHJBpfDpxUigyTnKv2Q76mXdfwR/QmAQxAwTh8QrMt3g7+ODTzX+9HS+WgQw/atXorH38jXKewNwq9x2g/49A9j05zJ8kRGAECJG5n4Y+mFAUiGwcIMK8H38Bk5HQgrkIuzz5JwDBqUUCYYTZFqWelFxSNIQK+DP0QXmkUoBx+odMTkJ7AYAaW1NGpzHqYT8UrH5S5oiFVZOlS+NVY+SchBH2Frbtq1MBhZURAAoOapuaEgLmxpJaMMQIsfMZvCylic6BlJyDFMwSkAnnAhNCJa/EBWZbPYFzJXOJangFCAmqoZ01knJEsnczDSs2CPycTIPoCysbMQ5Z7UxSo84m2dOyeEoKB0RyRBm+R1jlHrgUfunBr3Xb7oo07+nd+Dvfxvj2wgCpsvylTfyXt66vDcAt8o7MgBJfBg4CuhsjbaIhiPGyEJRM0knppEJioVRgBREZAiICEoRqAjEMcqsyRgjIwjhDDAhAKGQeh47ALSoDfbMrBVpozjEELzoSh5rgdJIrFTbDqNSE5WGKJygComBCVBISSMAIDGhQmJmAowIRAoIVYhOKRvZD8OQF9bobLtbL+yiH9rgOUTHDP3QamWNegEWJRfSey+FpCkbka4UplnKkyIhRYRiHBAlcy0bJUR+rW07bWfaYDF9H0eAfuqhT1/Ti0ltDADOezWSocqRI6LYPGMywOjTGAPGEGJeVURiKmIIhseJniDFP8RIDIRA0qHHkpNnCAxxUvzzihBASEOEXrmH38gTf++wfyflC/oAblNwt/Ly38bJQ19sXb4uF+BNFfqt53XLdl5xHuGLHOSpKEURI7DSmrSyzGro/f+fvf96mmW77gPBtbZJV77q8/746y9wLzxIkIRAQj1Sj1qu9dATM9Mx7kEPE9EPEzER8y/0yzyNYmaiuyVFSy0Nu0VJFEUKJAiCuCDM9eb4cz5fX3mbfu+95mFX1fmOu7gHuBAAkTtOZNTJLytzV+bOZX/rt7IsI0LBHSklMhvctZJFAgsBBBNCSKkp1WQQ0OUBkJaup0wcxkmAzAsKFMeTyYQLV1jEpzFKKaOBMQ7EOIAhQgTGkUjnmeaAjmVeM8wYw8AAgmBgDJHOBQOOBKRJ50SEKBgy4ICGXME556AVABMIXHIkI4RQKtOghWCSY5oqbRQYBAm23IlzZBz6/W4QFNfXV+M4LZeL4/E0nobFYplzjKJIIdjy4DTXDnIpJQJjAjhyTQjIbdSfLEAIGUeWZ4njOIIzrXMkwwVnQFrnpBUK5krXAKks1yoTjPuuYyl3gPHzfJxaawZgSwzAaLDdYxAByJARQtjUKyJxbhUAaJ1bLFCe58ZYhCsplXlewKTItbb1xo7rMII0TYm077tpnGRJ7Pu+UXmW50HgcWbIEEMioiQOGbPpaEQkxhkKxh3BpeCSM84BdZangPO4P3uQ+bABQDKLJPZs+XF4yN05H/s6/yI8/jo8sue8zjuf4/k55czOXfehUr7H5//Y8c+msR75mYurPO08P7FO4uPn+ROn98wG6FP7lzx52PN8Ch7AX5kGP92YPcjFOwyLcLAxaLTWaNCQNoZo1k/GATSMCy4cYYiLDAAQmZDSNWBri2xYWQjhe4VMKaOBrPMwb/RJDw0DABwQgADQNgYw827sCzzl+Vj5IpFrjOaMaesHACyw54zNoCkwWxjWZCbOeZanNuDEuZSSM8byPI2iaA6ksYEjtEKW5qUJC0GzCMHDuSV3Pt+gjc25EgMkRKRZ+tjmtx/kw+EJgZ3z28fjQvbDrMXXuQTJwvM4L/5mFXZSSCkzrSzDxCJqZxMeWZYonQnJGBIgEMd5ykfPT2shP2h9GNvmkzFgDIAhgLGUfHOqjCcIhcUPQWRPFBn47NH8h9bt/PMj3tJftvGrLv1+jgrgr0J9n3wQGNtQhjEmJeeczcSvsTFlgHk+dg7gkbZCFQAWqCGjZ7FmIUQQCDWdknnQWhYelf4PwRyJyKJIFgiiRd3TIjkMcwVAc6g+PWz9LeLjcM4+WgBmTJ7hvGOi7/u2qe90Oq3X6/ZgmyW2WdYFL/8ieWAFq61thrn8On8VrR5gRs8Lblu4ez4xcD56A48pgPPPZXE8InLhcM45f8hpRkQpXaWUMcRtOzZDjKEjPc5lnqRpmjPGBArQoDUxJjzHH4/HROT7PgIYY4RwjFHKzGeIDNissMMqRfs4pORCMIbAwCza4T1iyy9U5uMfFm/kOd3w0+iAJyqAn3ieRyb5rBf91M/zqYzFSvjVVQN/ifQ2PWX8oqfF5rhNhYwYQyn5AunBz1md5z8vev9aw1YIYTvrwlzyziliBDs3YF5GuxBqAEDzJiRwDrBx3vQ+nwtl8zI00LPzLOSpHedl63nzEBEl40Rkk72+75dKJdsqwPouls7BzGGprpAL5gaY285Wmp9/ZOdwrg+1CTs/jfPN4vFcnRf+pLH4defhNwiz5AoA2M8IlqaNSSkd6dljhJjpMHOObRQRbVdk2/HG8uXNUywCiMGD64rFNOyzFjb4xzlHAttLcv4EH7/zj39YjPMHw08ruR6/ysct8Mfesk/yrZ/feT6t8cSb+SunCT4FD+DpOYC/RNrlpxizBU00y1zOG7jbhJ4xj7KwCSGMBrsPcSZitNZZNpOejuNQOm8AC8ZxHIVmIbsX1vECHjqDD87hlULwhXy3Yuu8Qc3mOMjz81/YqWQbVaINlhuYV3DRYieR67ppmuZJKpD5vl8uFEGbiZlkcQLaOI7DpJOmaa60BUoaYyTjHBAMkdKkNRNSMk6gbYt2NMQB0bYEsOHvuSOyiEjYzwso6iOKcCHFHtkuPiwUACIHYkCMbAN2QiBExoBIayKDQkgpXMYsahYBYBb658K2qCQiyYXvetPpFAAcKcU82Q4A0nG4FMSQAzIGjHOrAgDRdhZzBLc9IO39MOeoWPExnOXjYuhxwxl/Wgv6vPWwOOd5WNRfqvEzqtJf+PhLhAJ62nL/BT85NERgDCByBGScIzKbPcJ5HxYzkzjG2P6I5yxZpVSappbQ2LKtWb1yPmK+KBHCuaW8+OELyIr1AxbC8fEE1yIlsNhvo0ALM3mhSBZMCQtBAwBkjHTdfD6sd2IBoFEUGWOsmLPXNcYQaA4PTjLHQc3Otpjhg4gTKQZooyiLONVC882F+Lmexh/zQB42nOc/0J4Q52YoIS66/IKUrhDCmu22FbPOTZqmwB74H4t7aEsBbODOxnYQUUrJuCRExoFzLhkyDhwZIkgpbfQfEQCJSBMZMJoj6aekc+14JAqE52A/52/mT7lsz5/5Y8/z+LUe11ifZHxa5/m0xuMzgV+OwNQzjb9KAv/CxmKhWIltpRZjlv8fiYAxsCEcYzgRIRillNZAhpBZCL9E1JZ2mDHB2JzDgJCAlNYwZxEy5+idrckJD9OXMsYsHRvnbJ5x5YyhEMwYJYSYIWNIG0MABpG0UYwBorAS2EpprWdgf5jDNtgMoKIJNOMgJDOk0iy2fAZ+4CZplOVJrhzP87iw+Bsdx7EvHMBZo5tZzhONIYWMjNbaKADggtsOiEoZBCBLg4wcmYXBEDIgMIDEbb8UBrasGBkQGZrDfQBg8XkeIAJEmOdgEQG0eciOxnlAzPYwYIwtstZWyhtjJJ+xk4Iha+9HUUTGFAsF+yAC13OFBADBuUbbGQKFEJIzLtAqACGEbSaMAGgIiNA8as7DY2KdHs8BPFyn/VPLqYVafaYI6mIaP6O4+LTO8ymOX2kn4FOI0uBTxs9+5r8sAy1+RQMSImmdK50pNSsGXmDeF0VbAIAwTxE+zGewEEyILM8WBQQPMDzWyl7st2ew3AY2On/eqmJzBjR4Ervceav8cYnwuNGtc2VDVTgnRSAiKz1tKBzmRAuImCUp4/DIaR//wBa1V1oDPjQBOOcuLIT1I5baEwc86U0+L3TOewaMMcdxbCN4m8CwZzjvBs3ZfmYKgDHmeR4iKqUcx/F93z5EBgbAThXmRENcOpwxmJXxWT06L7Z4fHpP3PPIn372F5POtbV45L79ZR6/ohJPPLLo8eGwwPn98Ix4efgE2SE4ZwhzfLI24vzB8l8sO5jTnT9+nqc9iU/rCT1trZ/ff/6enG9TBQ/loq0VRvbLAKSU0mCklMaAMWC0znPLJCw552SQMcE5MKaNMbb9LWPMdX2ltKVW9jyfiLIsy7JscX9wXsRrb6Bl4lwEixZTsrAirbUF4djetpah87zOWCRjtdaMQKWZQFbwfJ3lcRxL19MEaRTbkE6W59qQlFLZGLEBILJNxwwBMc4Y913P1ozlaeYIqZSKo2gWu1fKTgPs4zYmjWMpZZ6mlokzjuM4z4Mg8DxvOplwjsKCK0kDWGVmOGe2XNaYB9qIiDhn1nmCGXGeZcUgxmwB2fk8uS3OE3QOd+Q4jhX9ttm9bWUspYzjOIqiPM+LxUCbXGstBZdSMAZA5HsOEaVp7HARuE4ch1prR0iLoHV912a/tck5SWTCGL14iMw2GSbSShtj2ByO9EgkZPFMH/EAcLbQnkCM+vH7H/nwiOP4E9+LT2s88v7+1Jd72hfPy5nzH5422MM5zsdvlB0/tdj5tO7nwtt7RJ7PoHefygWeuP9p03/cJPn4n2rO8UourKqfaqa/mLGQI+Yckf2TDjQACIiGtI23MM6AFjF0mwmwD3J+B+hRlXlenT/tJj1tZTO2CP48QBMuAv2zKc7FHxFZiNFCapwXEIvEwOKvjMCc61S8OInWulKpTKfTKIqSJLFmMmPMd6XKsoXiOX8VIrJVtRYHZb+SZZnlRn5keZy39B8ximmeFDkvMR9xdM7fNMaBjCZinKPjeI5j8bhaKcXYLFKvlFIqQ0THEQtyHkQ6vy0UimkaK6UcV0gptcmNMQzMZDJFRl65HHie5Fw6FtekBEdjjJn3O2MchONKpCRP4Nzr88Qf/sT9ix/7CY9/4v7Hx1PlwK/U2/qXaiDiz1MBPOW5P9FdJXqUvXYxHk9Inj/DecP/l3OpsXM9/Ow472bNdxkAbnWAMQiEiBzRgg4XKdYHDhDRnHMN+Jz8i81TlHT+nsDTbbpHBhdocqONBjSIOKtDJuLz+01EyIjNPhvLSWmMMaTAGEBj6QoQgHGYURfYoDWgIQXIAGxInVmL2hhljPJ9l3MEMMboeQyESS6zJKHzsE5rfmutALRSls7BwpCM1nmWua5cLIzzxg49PBYqAeb8cQs1w87VMZxXpYgIlkiVNBBwIRxHeL6DgAQ6z1NkJBjXJs+yNFcpIndcqVRGZGb0E2TVHwESR+IIgKTzPAyjyWTsOG5N1FxHMgCd5zloYhxI2Ho5KWcde2Y5diIgm6KwNd1PaEN9/r+LDwj4yJ8eWRWf9DzP6GGf94Z/ReMkv9LjvPkPj+n+XwAK6HEB9NMJ7se/9cu5vB4RQwvT+NH5z3WAMWQRQTPSBZihzhdBmPnZHnh2iw9WQdiL4mNNNh/XDXiOz9KmJRcBK3vY+ciPhQlZw9/MG2NZe9y6zwvazkd+sv2uwzmdO7OVaMaYMAwtLZozJ66wJ9da47mZ2wi7MWbeRPeh+gCtc8bchddyXlrhuTJdOtfVYFGhBucqihdxAHjYtrA93DlHxriUnAsk0jYeQ2QYAQEplSmdEWnG2UyfoUEGjDNkBsDSN1EUTVzXZYjD4fCsdRaGYalUEhKZQJ37pALP80hKImf2UHQ2q//gfHEzCYzgSAT4yaQ2nFMAj6+9Ty794ad6y345X8xHxtPkya/E5D/JOG8VLT78HOsAAPknPP7jb/Ejec5HHIJf4UEMHiT0CGCmA2bS7QEvMLOccTADHVoFrh7Ys9pqCG3FOxHMKEbnZvvsao+FJs/by4jIbKHTwyGdhfS0FVs2i2sTnnmaMUDShogsRSUwLhjXWiNZrA2RNogWtW8WJ7cKBomUlcVKgTHcoo6sea61ss+d9GIu1hlYaCwhGCLleWqTFrPytFkzdFr8XCKYY2GJyDpYi542DtjOB7a0CgGR7PVh3n1gfpMMojBGSykdxwKlVJbNsgUAqDVpbfI8AzBCcETQWiEohpbFx5bEkK3hUlpJ4kmc9nqd6XRsyZQG3Vazc1YqlZYay0tLS+Vy2YeAcUDmJEk+q/sTHAAMMpRcIBmdPNGQhye9GjQvqTu/DBb68pnO89T1/JTxqLP7yz3Oa/1foWl//Dhv+Z1/sp9OCOinmI398IgA+unOc/6LT4x4/MLHY8GExQyf9JPRdvB4yGvGGTCRn//6efOfiAAfinXgudDtIwcvFOr5+09EFnyyyLjQHGaz+K71ABZy3MxrqRZ5VCvZ9bk2wg8kPsyi7eexQ3YmrusuDHyaY2YYQ86AiJ2fz+K3LAiZF83fOeda5+e1Gjxp3T9+i867C48/rHODAIlx4JwhI8tNDQaQIQI3pLQ22uSIXEhuNOQqk/JB1zB7l2YNdYzqdtu9Tnc4HHLOfb+UpvF4MhoNeuNBv9s6KxbL5XK5Uq8tr6xW6rVSucoYM2D5WRE5E4IzwcnkOCfl/iT2+/k37Lx0e/w1/EnneeZY//lLPO2YX/h4fG7/aXgAT7zni2f6i0wCP/rhY1FG5w9eCCD4BKHJX/gwjxWdznbC4x4SzYI3M0mkAQXMfzJjxOZc9jNLec4LDABkEIhZz8Ce62kmzGImiw9zgWiBMQtqCs05F4LP2M04s/8YQyKTZSnnzFq7AMQ5Q7R8O7TAzgOADXfZ/3LOtNbGPADL27Mt/lkz3y4cxjjSQ57i+cTyAoRK52qplMoewXraA6ySWDyFheKxP3zBgbFQZovpndd2iGhZ2LTJOSLjAmegNWOIEIlxYAYQwV5fG3AcR4iZw2SnYUlYgcxw0O/2OlrrwPWm41GaplmWBb4bRVGvOzo7O0NEv1hYXllrrKxsbe/6vl8sVRzf48JBwTWhMcZBRHgC+c/itz+y//z7QY+FdJ7lPM+WAzivg5+2Jv9q/FzHeZMRz0E88BebBH5kPT0tC7xQAPgwic1TQ0+/ZOMRg/eBzc7sD2b4EJM7zWK1OLdYLXgGOTICS02MCMAsyy+hsd8BMIZsmEMjATC0VWBPs2vgXHwcEZEREjBAwYQmpeeNyK1Fv4iM2wSAhe270pGCMUQi4uxBlmLxjCz4Hhgyq1gYz40mAkVGgI33MCKTJOmiLeUixD/HLM463Nqbx7m9jtA613qWMRazBoq51gRgGBOIAMBsFxQiy0yhiZAxQuSIs63961zc24gZM2Z25Hksk73DgnFDpPMMUToCmRBgSBlNWnGHM2BEjIwGAM5AcLTS33EcztEYw4DlhAgkmAGTOcJI31FZ2uv3AKBWqYZhzBn5npRKJUkybE/G3fbx/eD+jeuNldWd3b3VzY1KrS7BNwS5ZtKVQHIe9QKYBa8MWQ8SgSxdBCKYRVDL3hdids0YIgQkQ/hgqTyyZp62//GBi6IifOiwv5L4v5xjJn7f/L3/8Rc9k9lYRLo/6fFPWVjP6go87XhD6qebz+O21eP7CcAgI8tXDISzlxMBwOGuAUbIyDACgVxw4QnhGEXGECmdG2VyleRJnqapSl0hU5UiaduaJdOKVA7AjCE2J8mxMZMkSaIo8n1/MWGbVrUh5ixJ520odZ7naZ7hHGqptVZGcc65IxFRKWVyFbgOkiaDGmYoT9t2igCVUrm2vAy2Jw0QUbFYTLI4jbNMpUiW5FJyjkoZrXOc0xNlWUbaIAJQDmjIIKCBWWMZjowYCkPKaAA0DAXjFgpFxWJZKWXVAOcSkYwBrXPGxLwlFjEmGAPL2bCg6LHDGKUBiXSpVCHShLNqrEVemgEJIXzXtah+ZQzpPDdaMk4MODD7XBQZDgicBYFXKBQ8x9E6Zww4Y2kUjSfDcDLWKkuSKA6n0/FoMh1FUZSlCufenmVAIqXTNI2zFEhkuQYhy/Wltc2tjZ29ja2d2tJakjIuXEQiMFJyzxccQenUqAzRMA62ulBrTUYTaQcNIiFRbpnGERgxRcYV0sAiTD/rHU1IxhiDD+EOPnb1s3PW5MKgWWS2Hs5FWSq9x9ApT3xrHn99PuH4ieYhPTwBZM8mT55y+FOHfoqB+7QbO09rPQHG88Tjn/X+2LP8JeICetr4dC2UR6T/x+y3JjzirMKOwSymQKQZgj6nDpHZ+AwH0EZwromIuOFKICeuSBljiAxnTAMYozQZACNxwd/wwONj5zjdFlGUeVJUaE0cjEbknEsjCB9E9gUTjDEOSJaGiIzkSJppZvjCjEZGYC1+TsAMGmKciAwRECmjiZBsYxcAnMVqGGNgDAdS5+IzyBhqpQARGAEgoOXeIQDgAkEzRIKZG4GIQIbleW4zEUS4COxwLo0x87tubzAjIg6oc5tIB9vgnjEmGSMmZmEoAmIPRA8iSiEk52jnQWRbbdluCozQkAZtCLRgKAQXQpRKJc/zBAOljEVzOgIFp1LRMVrlSRhH/rTiRdNCFE2zTPUHYZrmWZwkJnaRu4J7BbdaDNI0j9Mszk007N+P41bz7P7de6XayosvfVl6zHUdxsFozFKDoPI8K5UDbdIsS/M8BaOEEI7jOFIk4cD2UpBSWhI/AOYQ6Sy3XdueYOnPQL9go43P+KY8kP7nT4uINHNCHtv/U3keP+P4hUelnlVwf7rjrxTApzYeF/EfrwNmESCYEXXZmq8ZeGb2J4NIyGwTQIOMzzMESIRcINfcGKU1LELWAMCYsCVjjHE6N/Bcd3J7QQv6BJjnfhkQGk0KOeNM2CZT9pycC4C5fQ8AnAFzmOCEmhTTRhskXMB7LJ09AwDQQESk9QMQJ8450RhjDAjACGZpEJiVrYIxYMAFMpT4pP7mHJnlF4Lzvd0RdZbPDHaasZwyzqWUuTawuL1ACMQYI8vAaogMEpv1wLFE3Forg4YxxoAhGQYICIyhO687s49mjhGalXTMlSizJcqO4xSLRSY4kEbQnHHP8xBd15VGF0krpat5EkfRNI6mURTluS5Vw+l0OhoM43ACmdKAqAlRu67LHMfRmGkzTbJWu9nqtLkMbt28v76+e+HSha3tjVqt4jChjWFA4XjiuKIUFKWsKjJ5nmZZFic5gGv9KQQEglwZYxQRSS4QgGaF03apACDDc0Cy+dL92BDQg8jPQ+lme7tmp52dDQAJzZNzD4/895GcxKc4/qPpmI8fj1QU/0ceT1AAz3ovflEa7NO67lN/71NO/0mu+xN1wHkSfQRigAwBaZ6iAc2QEXICw8hYQYlMIwCQRkaMAzfIORqzyCQby/1ABsjMmsCCpgWs/vzbZakgsiwDAMdxrCDL8zzNU51rQdyyGiyydgvBZ1mIbcicARGA0ZoY2plbDYOcI80KxhjYxl7mfLEVLnI5ZIwx/AFMkOZ4JxSSCaBFVOERLxjmcuEhSBIjQwqIERCgmTF4gp61KUZEnJWnISMGQGSQITCSjHPOUXAhGHLUSjMkjhwZWa+GoQCAOcOd1cEP8jqWFcPOTUjmum4QBNJ1bdLY2HvIkBAYF1y6nHME45A2ru8GhWJSTpJEKVOupVEUTUfjyXgUT6bxZBxOpmmSci65EH5QKnt+SZvhZDqZhrnKju7f7rZPjw6u12q15dXV7Z2tnZ2dWqNqjCEwUZRorXOTA4AQgnPH8wLSsx47xhijUlAaAQxDJG0t8wfSdla3PFtHiwf0sWvephlwfhgCGgCbanhUrMOskRk+tv+hLOXPIv0//muPiP7ZU/15jqdd4FlDOp/uRP/KA/g0xye0/WefYVGiSWilP8D8FUIb22WICAqIoU3vGUIDjAiADJJgtiU7R0NEyIEDAAdO8wTynEjfEDCb7CNgRJQrE0WJpf+UjgfIldFxGk+iSZ7knucUedFxHIaMiDgyxhjnNk84E9AMUGtNDIGjzTQgY5yLmd1MZANaNOtI+QCvZXWJrXMzBsH2RjYIBpHZegaYKRHzkD1owzXz13UBCsC5vAAhbHlajoi2t4GN7DO2gBuA5VVmDBiAQeIMFz12ABGMNqSZJV1iyBkTHPn8t8+VjTkH1iIASwLBGAf72fd9z3O4I3OVa0IAQIbImSYyWpPRDBhH5FwKDsJxjVvwC0qTccKwUM7L1Vo6ncaTyWg4HPS60XQ6Go3SNM208kzGpet5AliQZ0Yy1MqE/dakf3Z6eGf/bmN9fb2xvPT8iy+7vuf5vhASuWus7gRIUqM1ICMpGbP4WmScoyEFwAENEsACeUXWRZtRAc5c0o+TPAaZeVgBgI252RDcLBMw/xMREfDHZdlCHD9x/6c4fknM/1/4+E/QA/i05v8TYawf/9dPogMAgCHZ/NM5EwQRAZE4kAGDwMgoQjRgy3wREJDRggZHKwUww+lbQoi5g0EA2gbE55w3iIhaU5ZlUZSkaRwERSJK0zxJojCdjsfDJEmCIBDzgYjiXHPgGYByBtEhAibEokwBZ+0SGRpjyCARMWSLEjDOZpW3VgHMfycxZIwBCkS04E4NAHPgyoM7tohlLabxIP4zT3QrnYFCZMQ5s5FxbZTgjk0jIyOGM1wSQwIFiJZG21qjiggNGSEF51xKwaSwqs+qE8ZgxuvwoJ6ZYGZfcwK+aMsjBKN5qt/mnDnnBmzhMjEgbbu+MMZAoBCCOwJA+kGep3mSZqVSVi6XSqVyuRxF09Fg2O/3+8PRcDiw6QVi3JHCKQgBkskSII+zPJyMrve6xPj+/cPltfXdvQsrG+tBUCScxfqK5XKmMzCGGGcEuWFIwDgDREAFgAY0IGe0KIzAuUA3iIxIL7BVT9riw185v/Itxwkn0PNHqRFn/Q3gsWjP4j34Gf2Aj/nC4+Y/LIJVTzn4Zx9P+wlPQzM+qwfw083zrzyAT208LuI/XgcgAaCxon+2Wmc8Ozj3SJGRsSyVhixhPYN5dIdzRsQBQKsFZY79qwXX21i/BnigFRhjjGmlkixTSZLlufI8UMqkadrvtw3Tg1E/juNMpUEQOL6HgiMit4zQxl5TMGZJggzjCBwYeyDNZwUKBg0aDXbaC35jnKNciLOZAGVADDgYsgAdREICQrJhJcYYmwUi0F5fAxABn1MgWA8AAIhAA3AGCEwwJNIW7mLLDDjHedTKuiDAGHIEZt0VBswWADMbOmOcoZDcdmZmjAGftYM3BIwB5/Z/D2J4BBoAOXdt217reeS54g43Ft3FGSAayyRKYIubtdGIZg6YZcDA8zwuhJSu52XaDwqFQqFczuJ4ZSXp9/udXnsymURJlmSpUop0XitWVKaVyRCFywE91/d9Ltz79w+OT1s3bt5xC8VCUKo1lpZWVqrVasPINE0Zw6CAkjMi5kohPCdLYwQkyq2ktvEyAGRmYcsTkZlHeJ76b64AHo1o4yxrpRE44DntMtv/SXMAn6Kd/ktl/v/S5QD+so2na9Sf6Ww/yQOgRWz68QPmdhARAZImINCAXBjSiGZREmyteulwYwxZUBEg5xyIMcYUZIwJxNw6BLZ3FSLXWitle8sQERkDURT1hiMvEHEch2HIOc+ybFGyyxjTemaPW/NdgyZDs5WLwuLnHoTjLfrT1l7BQ10BAABxZsITGCRGpAlnwoUxMESgiUAbw1xpG6EIi1c3RiGiMYoxZk1IxoAxPiuqA0Ok5zW3TCmlteHcdlMBS4xhZ8EYQwSGjDvIYIYQYgwQOdgujMTEvAEzIrI58z+Zmddl2+YsnleW6/l+bhMneZ7neer4JZpHVGjBZA7kSm/hzRhEDohMEKNplAAagczxA+kzXSgUCqU0jcejkRP4teWlKJoOBoNm66zX6yVJ0uvnSOg6flB0Hc9liY5Tlee6XCxrFGmix+GgA8N2Z9jpDSvVqv7ollLG85x6vVqtlDxflgpeRRd9V1paQZh1GGNEGgEMEgOwZYI4CyranPzTtnPpTw+/UISAbOZDkFWFD0Te02Txz1tG/zKIfjs+XYv+WYf45Jd51ok+TbM9a9LjWc/ztOOftXDsaef5+PvwNL/18f0WTGkMaK0JLdmXldEP4gwuzmjXcpOBJs6lEByBWVMSgTiyTBvOGHJm+8doZRizjbiYMgBMDMf9arVadP12u12pVKZRMp5Gg9HE933HCzJlhuNpGIbt7qhSLVSr9SiKms2m4zhSugCzPjVcIDJmCMEAMiEdYYwBzhC5BZMQkWV345zbiioNhIYk464vETHJM6016RyMASBmzUDGcp1zbp0gYsgZk8ZwQ0pKrnRmjBKS2R5naEhIZrThAjnjgMZoTaABGOMgpTOD4nDwnVlXYa21fQiMoRB80SNTKyWRSyGAzUJjnHNg3Fa9OY4Q0jLTLVwNhgwWCB/rYCmdWSYix3EcR8AMWJUDgOd5RuuZ3NRGzWQiA4R81pGNzXt/otYE2gAiEFMElOucNEfgrldwvEqllmXJdDodjYdBsVCqV9vts167N+mPBROj0WQSpUGxkis2GEbEhHACrxhIiSXPPz4+lY5unrZa7b50XA1Y9L3JJDwCEhL29nav+QXGTMH3gsA7ax4XCn61Ujo+PgwKvu8K26XHNoSwDXws0MDquSRJAMB1XQBI05SB8P0gSRLpuAztd9lwOFxaqk/DsbX6taZqrSIEazabBa/wRA/gae/ps8qBn2jBnXc4AB7UAZxHHNA56pRHv26eTUCbp8znJ8rDR+b5rPLzacMeL571az+/8cszk59unF8on8QPyPPM4cxxXOSSMUZzXmL71iEiKsgABDIhuRRumuYzqjJ80IwJkKSUSsWGSEqHMVIqtVLMRn6JqFwuM8bG43GapsPhkIiiKFpYuEKINE0n4zBTsec7gSc8x2WMZZlK01QKJ5xGFjYuhOM45AguhMsYi5MQCJHM3L6eMTnDvJUYYwzYg5Zk1jy3CWqb5LAynXMEBAZoqY6RIRoUhiEjNs85W9Qg48QYR4vRZGBru4x5QJS0cDXYg2pkXLw/57wQtIlsYshmzSMRObOqVwghHOnMFYBZVIRxvigNs5fnwHGWgp79Rmsj2/N/PGZmMQjZLKdiI2kEBhizehYA0BBn0i9WHNcvFnKVhfG0UCiUSpVBaYAg++Pr9cZKksI4nDh+YWVt6/ikdXJ8Vl9a5ird3Nw+OT0VQiT5dHlt3Xf8PFet047ny/X11TCM3n3vo6tXLhS3N/u9cbmypFRy/+h0fXWLCxr1OqWyr3PT6bUZ8KWVhmByOB7Yref4lVpZZbo36HIU9UZjNJgQMME9QywK4zjJGrX66tpm+6y1vLqUZ6kmVS8GZ+3T8XC0u7edhMnijaCfA0vEz2hZz5/sr7ZQ+onjF6AAnmrpP6Uj2LNqvE9LQz4tK/S08yxkzePHPGk/FQoFY4zSoHVqDJlZuBsdx7XyxShtSGkiy5LDUAAxMGRsZZUmMEDGcOSkjc615A5HBkarPIcZf6dWSgVBIUmSyWSCyAaD4dHR0Xg8XltbY4z3+wMp5WQyBYA0ydI4C6TvSU9wkcXpdBIWCswyngkhOFjST8GEFEIEnOVGk1r0rYSZmJ21AmbGGODK/hWIXM41A82AZkzWmhgDYAiW4pQA2Uy1MSRANtMpaPkfLJMDY8ycS0cbY2gu0y1gc5Elti8wsYeK4OxnTaAZAUPkYBv+IszSvYQghetIx3V9FBwIbUaGMSalmGWwOQc0nCEay9Sfz6416ykGVhEZMPjoSrS27aKSYBa1W4j+xR6LMzIIjLjSwBhjkvuOGyAVymXfK1RrS73apN0avP7F5Vu37ylDn/3cV4vl2ulJa2XNGYf3h6OJEEKRGfT7nucUS5U0jDkKrXU4mZLxdG5MjirLk1jlOQXFWrlcHI0HQmqlRPPspFZ2wyghDYViWTCZK5ObTEhX56ZUrgomozg1ioqlChILo7RWX8lyHUaTQqlcqRadJBPS08Zs71waTUZxlGtSaToqV+q16lIUTxEXlY8PydmPeb+euP9pgz1z0vWhyTySk3ja8Z98/HJqEvG4g/M0Afqs+vnTUi3Pep5foAI4/+Hxwx7ej0aDMkREyLjgnCwiUYo0zZGII+MSGSHYfoY6k8Inwnn5LhCBZTa2vXwBIEkiAAZotNbReEjAgbM8zx3HsY0VgyDo9/v7+/txHBcKBQtg930/SRLOpcMdylSe5lI6iCxLVRjGAKLIHBQITCB3gEkFDDQoUK50IItTlSulQBsiEoLZHiZWFBIRnGNAWtjOxmgyisiG8pGQARgr/xgioG3RxZkmI2ZGPZEthAbLRG015XmzEeeQEnhY1p+/7YtT2f2coRCC2dJfQiY4F4KQCy6YdJgUcqaJZ86EEA+cCZiXR8ymypgNgC2uzpEpskw7QAhoFQnNWJsAwJJbAFkUzQPpwGhGqkPAAUCjQYJca9IGkQRHxnhQLjtBmft5fQ1PT9tOc/wbv/M1zy1sbOy88b2/qCylXAY3b95EZIeHh4gUhuHy8upkMgENrut6jpPFydlJExFXV5dPT1t37+5vbW3EcRQUvNc+9zrnuCKEZFkUjw0znucRURiGWmvXdbnLpOtlWTaaJEKIaqGqtR71R7meCu6lmvWOWvv7h+1298Lepb29vY2NEjB3a3dNSDw6uh/GeblcQpag0Tgvp3gk+v9M793TxrOj+J6MQP1PVgE8awjolyRn8hPHM1sKT8vCP+U0P6NruRjKGCLgXEjHU4BRmuVpiohSOBaNzgV6nHMhgDOtDaKt7AXbTnemF7SO40QIwQxEUQK2dy6aMAwVsHKlJqRrzXbpeEmaH580J9Moz/Nub2DD2QQsy7VWealQBsp1bnRuJEcNlCYaKEbmOJ7PJBLjBgUSz4i4IoA8itM4TrTWQBoRA+ZxzgXnxjClspmamjfemoFBEbVGw8AYg4SAzBgGYGxLdJhR8yMAgNJEDyimAW2d7YOslTFGazLWdQK+SJ/DuUT6IyGghS6xuQHHdYWQSiljgAnBhIOcIQrGBeOCCcdqCEQEMAz0PPhm5tLFQqNmFdcA1m1BZABIzKABYAQPtjbaBPPvEgCYRZ8WG4JGsoxQbNYFCJnkXJucQBMYRQjGCJTcc1eKVeDBt/78nVe++LW//jf//j//5/+T9KPXv/Rr77793ua222x3BoMeByyVK8NRv3PWNAYlMIehyfNpOAkn0yRJBt3eaDrpdDoXL1+qVEpLS0vF8j4iIjOSZ2srdd93JpOJ1rpYbCDiZDLxfX88ToioUllFxOk0AYBqbc11/Far/c67H9y7u3/v3uF0Evb70WSa/tvf/6NarVKtVV544erzL1zp9dunp8eNegVVzIA+iej/6d6vn3EsxMKvitz76cYzoICeVbA+s8X9lPv8aV33mT2Dn8ES+SSxICFEmimlCTSR4EI6rue7vgcGlcryPAPSGogRIUOBYsarcI4Typr/eZ4jotZaKdtEV+R5pnUepbpQLBcKBStAsyw7PT1tt9tRFG1vbxcKBSsHm81mlmWFwPM9QYojoFFkFAnJQEOaaR4lxKSjDVdAaJAANTFGyGhBJmE7U1o0KpMPWGVgLnYXprf9vzZApBkIxskYBWgYPZD+jAECmPwBU7+lC2WMOY6z+Pm2M/B8AsxWISwcDjjXogAXBWjzJLAl/PE8TwiZaaVyAww5l0BMSodJwYTDORfCYYzNmi/q5IkLaOHSAcC8dHamcri9NQ9v9aKqFmnmBwDMW20iACAxAhsAAwDItCZEzl0mEChXKs8ICLC+vPKv/vW3VncuXX7+1X//p9/rjuLj5tv/+d/4m9z1CyVaWV67fv3DrY1VP5CC15rNliN8k2fheDKNJgBQLJfGw9H+/r7je54bDPrja8+9CGB+79/8+2KxiMyUAn7pws6lS5eKxbIgyhUgoutV4yR13YpdPCpXXBTtAx1Nkus37/75Gz8cDiau6zeW15OM3nnv+s2bNxEhV/Ha2vJv/85v/eZv/drlqy8M+2eAHOFBy/vFwv60IgdPSwI/VT48/NefOI3/RDyAx8XipxZCeep1nyZYP50cwKc1n59CAXwSub/YmSujtWbCka7HpaMJGOeO7436IyFEoeAAGZ3HKs+YJsEEANgmYghAM44dbWEn43FkA5vaqMlwrHLNBTexTpKkVCrZYEUURScnJ67rrq+vv/zyy9PpNAgCz/Nu3boVRREHQoNSuIwxBDQaQDKcodchy1QYhlGSGYBcW9QNuRxUlnBkhULgui5DyaTgjrSF/9bqtzh+axbbfjKIQEScEMBwZFwAgAFbOYDEgBifCe48ycHMgjx5nucsZ4y5rmt1idY6R8YA1UzycikcZssU5phLqzPsTGz+VkppT6hJERk38B3HzfI8y5QxBoAZYF4QMMY4k8z2aWTMpmb1nMDMOgT2IwDMa4OtwjuX1XzolSeYixg256lEssXOND+JsI7CuS8xQtBG20pxIobEDWnOUbrBh7fvv/vRnf/6v/4/HB+dvPHGj4p+cTycHhw3tcK93Yue4542D8tF33M5kHKkNBnkuR4P+mESFwqFeaZGFAvlcrmaqfxg/8gYaJ0NnO3i5tb6ZNBqd0Z+0KvXKQzD4XBYLpd3dnakI5U2h0enR0dHjuNsbm5mWXZwcHD79u0kScIoFdIlEHGS80mcZdn6xo4QTEg8OLj7//pH/9+jk+N/8A/+frW6NOoeP7FN8af1Xj8tB/B0i/7RCXz8TH7eCuA/jufx868DWMQ6P34LgOzTCa18WiEa+/o94fzzeO6j+xkCmHndo6WrfFAt+dh+AELpu64fOI7XG/Rv3Lx9//7BYDT68pe/3Gg01laWPM/TALkGJCAumAYDRNbGnJEraNtXfTweEmGxWNRaj0YjrXWl2uCcJ0mS57kxkOZ6NAkHo7CxvH756pXdnb0f/vCHq9Xlz3/xC7WVrRs3bty6/iFHVvJ97jrGWCZpQVwC8sygyvI412mmpnGSJIk2hiHF4ZgzqFeqW1tby8tuIXD9oFAqlifTEQOyICNmOSaNLYeadYQHMMYIACMkm/VgtwoAABkwBoJxRGQmpTlHNAEzhJxzIV1LXYdMG0JtgNEsGcCl4Hwm38GSwVkFYOuZhZDClVIuIjaKjOcHjuNwkSNkSilb6up5HgCAzT2jmbda0zNa0nP2/nxdWWJQW2j2oOXDIzYAwCwbMC+VMgCMERAyRmbGmoA0j4MJ21QTEByXWx49yIlAI/LA84PK0v/wL373i1/+WhLr99+7/rWv/ea//Of/06XdvTROJtPR88//5qXLF0rl4MaNDzxftlrNcq2hI33vzt0oDAEgT/Juu+cVgrWV1SSLwWSNeuXO7Zuu66+vrCRhpHLz4qufr1bLcRx/9423Du7fK5fLLz7/gucOXnrhxe/82be//e1vDwaDtbW1+3cP+v3+8fFhMXBJm3QydV2vWAwYE6SSUadTrVal76pcL1dqEsx3/ujblOb/l//T/94GyRigBsNmWlPP78wTx+KGPnLA+VfxCUi8BSPp7OinwcEJ5m/rg6/brnHnrsjObR/Z+cjn81c51/b1Ew22sCqeNtEn/+EReUVPMqnP8bMCgHhckT3dIn4W3D0hLbDPDxeOL0Thw9unqtQZzconHk8U9EggxFM0zBNPAgCMP3mlENGTJjuvpkFkNoBrEBggGA3SkZxJbXKjAZE4k8iZAZFmarm2dPv23X/6T//pG2+8MRqOi8XyH/7ht37tq1/bvbDnBv723vaXf+2rw+EwSzNIUw5a20YyBLlWSmdpFqss5mimSRzHIZeOX/CiMDlrtVY3LvQGk0yZcrmajydHp+2tnUt7ly4DMi2LP3z39sruc3/yxntf+MKXsLiaoX//ozeZF1S9gkryUrVCgKet9tbO7nAyHg7GhVK5WC4jCOn43JjhcMgxYIzd3W/duX/6lS9/8Quf+ywi9YdDybnjOzqP0yRzBZcOUypHYgzJEcI2byFhcaJARFIKRFyUxZl5dbRXdO3NzvMchCM8Y2M4WmvSWhsgLlEi59Lef7fgmznp3BwHyhljwvEsWwMCRyGk63IuiGage6WZkIGHWZqmEkBKLrh80KiZMrMgJMVFmxoCeBCyYIwDIswLnWa2PxEiy/Nca20JmbnAPNNpGlsvBOcds22HNEPkOlwZrXUGAIzlnHGOaBDSNHOkVymW2u1uISiNRqO9rb2337/bbQ2/8dtXvvdn39tYXj87OEgmw+mg/cKVv5FO+++9+9YLL71YW176z6797YOT49NBxBAckywtLWepHk2mWap0nhsdaZVpyssFoTO2vV51pBdGEyFcnentCy9Ix3vp5d1pgkdHnctXXv7wg+tgoHl4+v/73X8RTsZXrlypFAvt5mmv1/vMSy8Mzo4O795zDRUczIetUqnkSC+EqIj+UrGEiMfH/dWg2E+SP/u3f+hq9X/7f/w3/WH39OTI8SQAaJPXapVut+s4QinFkYQQxkCe55xJz/PiLM/znHOOSLb7m5Bs1iYTcZ6rnwfbEPM0FbNlNnMZDSkiKgb+YDCoVCppmmpFxWJxMpkYNH4hSNNUa8VRInKlc8HRcWQUT6TkDEyWKTIopceQa62RQ5YlWpPgjuv6jAmttdFkJ8mFALAMuAoZcY4AxCWfdbwgchwHYTZ/x3EsYttxHGOMUtoRPFfpIy0HrGGRZ5mN39rz2CqNMIn9gm8Ra2RsPQohcCGEUjapZuZcvAsohBY2x/V0fo+HtsaYBabhJ29/yQaheVhR/zRjwf+yONFCJxKCpbqxu9EyHQDZAkgia7shMkuJpclAlERb2xfu3r3/j//7f/yjH/2oUalf3L7EOa81lk6PTj+6fru+vMS/L0/bg5deebXser7w4mhQcDxDeZZkRucqzUBrBANEJldZlkEcG2B5rrXW4/FYKZ3nehJOb96+c2HvUrFSbXe6hHI4vX/h8rWj0w4w/m/+4A8/+/rnr734ysnh7TBTBYOas9wAImQGlQGlaTie9Iejar1eKBSDYgEMxTJiTFRL5TRRWZb8+Xff6LU7f+fv/i2jcjJ5FieGcsaAQNtlRzoXTEpGnNEcbs8ZR0M0Y9lks6pZvlAG8wICYoiC05yUlNvyLsGZUlw/QF4KRxijLTJqngMQiCicB7lcxgUKgUySAdcJuFJEZAvdLLLUcZxZI61FZ+a5xUSkyQbo0SAxsLXMaLJMERoG3G6BERIjJCEEciAtCQ0RKW0Q0XFdjsKAJg2aFAOOHDmTyIGIgDGBghhxm0QGQABHgKEsmk44x4LvEyEHdu/2HaP0/t07eTS5eXp4fLA/6bcbL1w52r/pO5Bnk9u3PkDpMM4vX712cNJsHx1ripIknkwm02nIUEgpGQcy2vdFOB0pHdfrS8BFMp0gT0kbRP7yZ3dNBp/5zOf+/E+/m4SxYPxP/sO3ht1uGI3q1cqo3wGTF4t+KNnNj97jecJAuYKTTpgGnXFtMsnNcjVYX6t/+QtfVAb+4o033n43icej3/9X//ozr73yW7/zm4ZOpfCNUQjQ7fZLpVIURQBAyLUtIeZggCW5IoOO9CwGFxG1zlVuACxVH7epGjKotYUGaCGkAUpzm2Sb1fohw0kYAxPARJpHea4LjDt+kGWZ0sS4ZFzYcCvngshorRCRcUDkDjCjkaEwGlVOfuAwD4CEpVrJ0twYMMY4TmCMUrmy68pxBGNAjJI4si2NpONaGUkGjf2FyAHIkCHDlaY802TQD4oAhjQok+vcEBrBHSGZARGmGRJDDgy4VlowWSxVwng649UCRsSBMS4cLoSmnAsLm7YQBova1mkUc84FIodZDfdP2NpTAD66nVn0T9jPnujNPWPI/ZnH0wqEcU5J+EkGAiDqp5QAAixE/yNznvsY534LISMEDcYw6xsQARkkaJTL4WDwrX/37370vTccx1mt1gqFYqbMsN0NHK+4UhKO/M73vvfjH/zov/wH/+D/+g//oZmG03ZLeoVc5XmcIOo8SkArk2qT5jpOkyjSmmx1LgOuleJc3L57xyL9X3nlgjLAB4yQCgVXCvjxD7//1a/++vWbtxjQ137ty1evPnf/3q1cGyYd4Tqu6/JeN4qnQBpRJ0k46OVJNM7ySuB6jkAh+HQy9D25VC3uH4zf/NEPV5arX/+tXx8NunE0ZQxcyZRSYFAIoWzsSiAKJoEhknC4jcZwjjYDyq3HPfu4eJrExIz12uZy0zRFG5shmLUcZgwRrfVkNFhjylrZiOj6AeecoVUhggtLf22kxyG3lBi5AYXccMmZhDy3lbrm/GpBAg0aADiCQcMAbM8AQhION4gcZltixIgZxCgOgSMHpsmAzomBZIJJnmeZQUKrPiwXBWgiVEoBQ462hY4mMra1p+CSAUtTxbhMskwZHWfpBx98kEZKYGby6Q/f+PZqo765VpuM2revv3/5ysVpPLnx4R1C+PGP8svPPV8vOsWLG4c3JlwyLpnrSildLqXSSZomwIQhBozSNOXS84sl1wkc4bzx59/du3BhZZM/f221fXp4/Z0frC7V+t2zPIkZQ0YZKJ2FQDqMp4MkCgVohkSMeb7DUUzDMDSmXKkBh42tDcd3N1dW19ZX1rc3/sMf/dF33/jeP/6n/+y1L3xxbXW73+8WCoU4iZTKAB3GzYLkFQAFA5WbNM2NAd8XSpMhI4QHKI0xnudZhWEplgCQiBMRIBfSs8CERXWeXSe2chnAcxwwJktT1FoAwzxTwDkQVxkBoHXs8lwx5illAIC0ISMZk0SCkEVJKiTjTNoYpwFmibG4dEhxIgQ0jHNCSvNca+35VQ3EAIEzRpAbDQDSYSZXwBwATWAAHWRGSl+4YjQJmUQOwlguLNBaC0QQjp/FE1LgOg6CSPKYEQuER2A4coYMgBkAIlQZ5SkJ4eqcFNkIpjW/OEdnqV5P09RC3Oz79hO3NBd4D+1/+hkMIADRI1uER/fAzIibCdFP6JE8fYtP3G9jek8U6U8ctg7TNjt8ZAtPOhPNqPxnmAYbSiMAzlAbgzSzVfTsGLPWaPzev/q3f/atb9WLxa9+9as7O3tRFN25fZdr0sYMOr1SpfzrX/zy6VnzT//oW198+dXf+drX2sgYGMqUSjNXCpMrnWfJNMyTRCeZSjOtCRmT0hWOjOOYe4Wjo6N6vf7a658DYB99+EG9tuQXioFfIKN0HrfOjknF7771o6212nPPPXdycjSJkxIPLKslAPT7fc6xUi4GvjOZTNqt0+Gwvba21qgvF7zCZBzWqo3RaHDt8qU7d27+L//yX7z8whVH8DxJkREnV+mcOOMoODADmlAhcmDEGBOCcc40aLSqmYCQrA9vgZCLgh3bO97e1/lNJQBCBJtUmNG2MYZWPiPOme8YoqXusfwZZgE0ICKlEq2VNrk2mkCxGT4oe9jwn2OucMbRp8GAhecjGvtGMGTADRHA7K8GNQDIwLUT5vOkNCACQxLI2ayiGGZgVm0MCenijGLIGHqQw1BK+V4AmAvhpEkOyICL4WQouL9UcfmVre/9SeYI5TuUTnpTj333T28rYxgTlcbS8Wmz3Tmp1OppFIfDYZRNGSfhWdWbx0k0CYclE6yUlguFQpZlGKXVyrLvl8IwvHf7zu3bt//+3/3bjXplc225c7qPlBc8p9SoDPud6WRQKngkQUVp0Xca1QIj4wdeqVje3t6WUr799ttHRyeFUhBlSZSEd/fvO7539cUXi5USlzwD88YPf/QH/+5b/9v/3f/mrNkJfKkVq1VXBoOBlBIFBwCtNedCSskAkDKXMS54mqZKGSFcZJqMIuCFYkVrUrntAsQ4Z5xJznmuUgPC8qrYJ55prbUuFArxJNOgfL/koI6zHEBwLh2PM8FAsyxTAExKKZjROiPIDeVGaUPEmMeYI7hHDiVJ35ABDdoAGGRcMOCaTJZqQhTcZwIZgiYFBNqAMjLNMtLEJTHgBlBy4Ug3SmPUUhuljc6Vo43RShkU6JS5ELYzhy2rtJA/x/dLTtlaPESEcZznearJcRxHSCGcmfQitDBx2x+CMRCCIaI2OcyaUPE8ywU+MVHwhGGsbnn8D0/JGZh5Fgsf2eJjewBn9ZYz/kHEn2lrnrTfegCfeCCQmEE7LNftQ9vHBwEQGaseCHGxNQgCmQHDLQMwkQEjkEnphKPh97/znWQ8/q2v/dY3fv3XX3vtc0mc/ds/+IP/+Xf/lV8oXtzaiZJ4GsYsN73jVjgYC4SSF1CmVJKiJkAN2mRJliWZyhQQcbD5UmOUJlSTbCqJr22sb25uXr125Y3vfb/XblVLZTLZyXF3d3OdGfXm22+Wy+VyqfLeO2/+9je/6fqFyWRCwJI0n0ynWZYRaSRTqZTQF2k8MXmY5KTTUtFfq5aC7Y21QqHw3ntDV/KtjZX9uzf+wx/8u69//Te1UqSVzjIAA46QnEvJjdGKlAABCMiQmPWAwYChOf5xJtfJLiBzDl9v4TJEAMgBATgwmJPQcc4ZE0YjIdrGYgzFfD9HxpFx68USgAECIk0qzvJZdA4J+SyVpUz+CJkxwMzdwydRfQBAmmWP7LQfHFcSkbGRLYZGG5XnljuIyBi1qB+2fXvBdRzSM81HFg5LgIbCaaY015o8hFyD5wWD0eSs1bx29QUG07/x138jHjX/4s//XGDy8ouv1Gq1P/iDPzhrt7a2dpZXqpcvbjQ7rSTs379/nxsWJzkI43AuheTCcXzmlySBsrFyTRjHMcNxmkGam4t7F45Ojv/i+9/73Gdfff7aldbpQTGQRoWTcdd1gKPwPSEZSYnlcs31vdWtjZ3d3UZjaW1tLQiCte3NN99827IGMZevba831pZOTg4cx/lrf/0birO7+6f/7J/9y29843c2N3Z7gy4Xrh9UB5OIUNiCR61QETc2OucIz/XIaG4El4ZLrnSWqTwcTIvFIhEBMUIEFAbAaMiM5tyd5wPndgNqApXlzPOrYNurCscPKpzz4bCfpoTaNtUQAGAMz7TWhruuA5QLBpxzBIeMMIprkxaKNU15nmVK5xw54y5pyFUuGOdCCC6Q20ZJxnUYMpZqYoLQIArkwBUZgQw5F0J6fiALHDhzhRslSTiZaISNrY1cKUuuZe0AHcdGx6kWrl9ijNkKULdQcAFUnkuieZtrlFL6XiClJDCj0UjrHMAwDlrrPInyPEPEMMuShMQc0/YTLWt82pHzUM+jxwMiPOAHf7BFfHSPRTvQzMwDAPyZtjO4xiP7rd/xqC3/tK2txrcwoPOwj6fpEAQwyHCeiLcxDWNzMoyh5c5kwhhDZFBK3/fv3b7/wXvvPn/l6t/5239rfW3TcUQcJp50nr927dade6Q0A5wORmtLy/Ek+u6ffuc3v/rFIAim42GSZog8jBNjIM2U0TasxBA5otHGpCpVWgeVFQ3s2rVrruveuXPn+ORoeWWJcxwP+tF0urS0IpjZWluWUq6tLXf7w1ar3VheNgCFUiVV6fHhIWfgug5H5kqRZjFSViw4SBp0HE8GBemi75mMvf7qK8cnh73WySsvvfDeO28/d+1SMSgYlWVZVigEOWACqVMOFJAAZhBmQU/kwIAsoBWRIVniNSKw4o8YN8ZYrKRAZhDQkCJDhMQ4m22BGDJkhIxzoQmZIYPAgaHggnHgjKEAxpntjUBzwA2AUorzWeNM+44ZY/LcPBHUYBBQ4CK3Zc7xhTHXhbl3cn7EcWgPtgSi0nG4McYYm7Wztpn9mnQclwmOniIwRnGQjM+MViKqNIpaa1IGhAwqQblUvX379mmzee3alULAvLXqf/G3vnn18mYeJRtr66urq+++9+NOt5nl09PmYblaybPYQRN4cjKZAkPpckPM82SpVPI8h5iZjoeD8WAShdXKUp7BZBIqLfxC5Wtf+9qFSxff+N53dra3x8NOoeAXAilFLXF54IlGvXrpwoVpOL5x40aexuVq5cLFS1eef45zmSRJyfU+/+WvbO5ejOM4TdOlpSXBneE0TJLE981qufKf/Y3/1f5B87/77/6H73znu//V//n/2Ol1vUIwjeJKteG6bqryLMtyZbJMTeOMMeYIOUgmSZIEnuMGXpIqBWQIB5NpkubSc0tBySsGLnc1gM7yXJPjOMrMHClbzzGv/2DLy8txHHe73SzPK6Wq53knrXap7AMAQ8dxPASuTQ5aSeb0By0G5PmOL1xEGcdqOppGaVSvuRoynWlFJnClcHxGTGNW8HyDANqkeW5yRYx8R0jPJ02uI4goTdM4y7Isi+M0SRJjTL1eL5eqxWIgZCAVQ6ZJqygyYZJGYZxmidGUqyyOkjRLXMcrFAMgjOKQDFRrlXKpwlEGrs/IpGmaxBnnxhSl46AxhqE7GI273fY0nCRJpHXu+U6pVDKK0iQXP5Hme/GPWRv6CdLblrQ8tn0WNk0EIPZI0vsnjqdI46fCPdnsj/gJthZnOQ9Gn89qzzzKx0NA+hylyfyDhfUBs82ohNa5JsaE6walW7duEenf+mu/9ernPtdrdbqD/q2P7tzdv+8FQa1RHw6HbuAjojFQCEo//vGPb9y8+fJLLySDPDVKMBxNQyDIlFGGEqUTpVNttC0YJZ1mZrVUNExGadQf9TudTpiE1VI5V4lWme/Js+Zhv9N8/urFLMuE4IEn+sPB8sracDTxCwWMsNfrlUuFJA1r5VKukjiaGJWUi54UXAimVTIe9lSaOo5z7dq1YuA6kheXlwbdzt3bd567clXpLJxMfdclIdMwNcUikxKZy7jDOOdCMC4ZB0sTBAg0U6D2/hoA4FygBgLDGTJkiGBIIxhAZPPOtjZKbi0KKTw+LwFAYsgZWC5n7jBhuw4wMMQEnzVfM0TMkG0hSYjICVGTQpSPrzEEQilwLpTBkvsjWOQGzPcbIiAgQ0TkeOWFja8slbTgkvM0TREFl0ye46swBMqAMUBg29FIKynSNF1aKsVx7HBI09x1wfG8wWjkl3zGdRSPbv/4jVq1/MpnXsySdDKcIAfHk+vbG6sb69pQqtJ6vRrGUb1eXV9fz5TOYpVkynG8YrHoOMKArjfK4c1pnEZ+nhEJLp3ALwZBqVFf3lhv9LqDu/fuffb115ROmkf3jY4KnsPAFHzvpReeDyfjLM+RWKVezwyetQZhGI5Go5WV/tramh8Ui6VKs3nGuHPWbnc6nd3d3ShJrt+8+bnXv/D1r3/9e9/73l/8xRvf/OZfI6LhcJhliet7QamYZCkBQ8EVUJRkXArXL7TPzvr9bq1adn2302o7niyXCoPRkNWqpCBVDsuty4Uqz3OtB5MB59xxvCAIuBQAoHKdphnnMk6y4Wg0GA5H48FwPGg0GqPJcP/ozmQyyRPtugWGQps88NxKtaBNxoE8zyuXq5x5UZiNB1GSpa321PWFIyQTXBcEk77knID1h1NNRuc6y3OjNSExQGR8MJ64npfnejgcpmnKOc8yNZlMXNdtdwae6/u+XygUtNZxnCJnTm+kgVRucpUmcZZmcZYqbXIpXMcdMRRZnmhFw+G0Uc9qlRI5xhHSGExz0Ek2CftxHE8mo0LR73Y73W47iqdZFhtShYJfK1f2di4FPhezzhzwk7YID8VGf9LWYuUNssftaw74RLv7mQL056b3+HiKAiBm8JNmEgCYhoeCRvRAts+s+0eHeFAFev4DERkwnHPgIteYI3rC425w8+693UuXv/jVr6RZctbrPPfCS8dnnUkcHR01G0srb775dqlccRyv2+1GaZZk6u7B4QuvvpgaypEI2SiJfelkgHGu0syEeZ7nihAQQTEwBJNwWltau3//PmNMSlkqle7du7eysrS+utbrd3rdXrkSdNunxWKxUKo1W6lSuVcIkiRRWjuOE2cpm9Jo0DVrS0aVsjjSeVYslIu+53qyXi3FkSoEXhzHf/adb1er5e3tzdbZ2crKytnJ6d72DpCO49jayEmeaQOS+cg9FA4yhlwQF2TbrhtDaAk5EQCQzWBkXHiAGtAQQz5rT6K00a7nEsOZ7U9gSacNgsMdRQa0yY22K8rSwzHBUXA0hAbQEArOCAhB5wpBzDvIA0NuDGrFpBCPLS1GaBAlIaAhA4aMISQwZIDSlDQZo3Sulc5VrpVRWpNZXV4xYPI0G08nk9E4zTPJhXSdyWjseG6pUPQCnyPLVJ7GSZpnWlOuDQeUnus7riITTabjcForV1KVFzy/Pxp60rl45fLB4aF0nPpS7YPr7925c+PixYtnzWa92liuN27eu/O5r37pUn8UlEphFMVp9tnXX282m0I4ru/lmQ7DKJymRAic5Uk8jadpPO30Gq1WdzDoMfQbtQ3HcaZRPBxN33r39mgyfeMHP/zGb//mYNA5Or63d/GSw6BWLYbT8SgMi6XS17/5Tdfxjk+bp51BszvM89zzPNPtHzVbRFStVu/d3VdKbWxsCCGOTtuIOJ1OCd9eWa2/9PJz169f/9a3//Di5cuHRwfScUbTiRf4uVZ+obi0tALINSnXCcrV0vGhGk+G2mRa59evXy8U/d3d7dFoiDN+Dtvp2uR5nmdaGe34XiEo1ev1paXlQOV5ng8H48lkYvMxw+GQC+z1OtPpdG9vz3Fkmobt9mm/P2YoOQrOcWV1yS9uJvFEG+WEMssy1ynkGShjGIPjk2alWigWi5zJPEOlSUpXKbV//wAROZeO40gpAVie50mW9QZ93/ezLBsMBoyxlZW1UqkkpQyCAIFFUTQYDGwEn4hcL3ASVSiWKqUyYyxJkjAMbcwnjmM0KKXwgkocx8k0nfJJ0fObvUG1XCkWy54XKKXCMOx2+83mCZEm0EHgby/ViPRo3I+i6WA8OvvhDzbXN4XjzVpY2EJNSxBmKbesmvJ9HwDSNFVKeb4bhmEQBGmaJkmyvLw8HA5d17VxzBnf75w0PFNaGx0Uisrofrd34dLFTqttiBzHGQ0HlVJZqZwjc1x3NBiWqxXO5XA8LpVKtuyFMRaGYa1WC8OQiIIgAIDJZGI52aMoSpJ4aWnJ1jrVarU8z8fjcRAESRx7nmd/iG1sYmPEnAvf95IojsKpKx3pOkZpAqjUaq1OmwG6vqeyXDqO57hhnOSKGJe+7w8Gg2KxGBSCVqtVr9cJcTQaIWeWzjPPcw2U5zkHVq1Wx+OxMcb3fftLbd/dcDIRKIpOUUpiWivGzwbTs97gM1/4/M7lS81WJ6jXW4PBxWvXfuObv/PH3/q2lO7e1cu37tzlPBZCjMajHMzB2Ul5Zfms34/DccGVfq16dG+/Wq3qLEPOhUCVJEprQMryPM6UGo9TYsBoMOpnSZokSZ6nZ63TNImq5bIreFDwB72+0Wo6Ga+uNuI4tiwRtXr54N7dWq0yGQzW11eHg54UWC56rlPxHWdjfb3X6wghlEp6vU6hUKhUShbdXCwGxWJgjJnGkecI6Tppnjuel+Z5tz9A4Urfq9VqUspqLbhz98D3/QsXLkzDca2xFMexlCJN0/F0Ui6X4zjOMyOlY7RmyG/duRfG0XNXr02jtNfpxmmyu73DBO91urlWHJl0nSicFMvFJIql6yDBaDL2HNf1PVc6p2fN3e2dOE2OD48KpWLBD0qlkmScSFmim2q16rrGrqXJNHUcTylrR+o0TRmKUrV09+C+G/hoaDgZ6yyXngvaTKJQZ3m1Ue+ctYqVcjSZbmxvrTSWRtOwefpRpV4jpadxFI4nN27fGg+GG9tbeZJ2B/1SUHB8T+CMUXVpdaXZbCZpyhnzfF8r1R8MsjR1PW80HE7DsFqpjMbjy5cunbTa777zjl8uTtNYEsQq+/DWjeXl1Uhlolh0cuO63vaVq4I7vUEfkQ+m09SYcrXse97x8fEkCsvVihTuWbt1eHJ/NBkhGBCwvLa8f/+01WxfuvwSoFiq1KuNpQ+vf+T4pdF0FGU6qNYnSfbRnTv1Wumoc+pwIRjmSd5utb7+W9+4eO1FLY9v3r67tLSqtb6/33RdV0qZ5WNFUKrWwiQtFmWjVg/DMDd0dHx8enz/s6+98P5Hb47G7TCuh9Gg6tb8gE+jAePyBz98b6mx8tnXXwfOur328eG9OJoGRW8yHQ5H/cZKtVwu9Qado+ODs85JGE6KxfJnP/vZ27fujkajRmN5dXU1ybNx2EtVdHB8L47SS5cunZ6eWS6Q4XBYq1WKxXIhl25QSvJRtz/yHLGyWtvYXEUQxoCUslwqFAoel9kPfvBWpVTd27uY6axSXvY8MR5Pa0u1O3fuXL16tVIpHJ4c+31/d+fC1atXK7V6q9UCYFmq6vX68vJqq9VK07RSK0dJXK1Woyi6d+8eMOKSdU87l+uXr1597u233x52hhcvXEqSZGdnRylz1myH2jiMGWPa7TYiBkGQJAknKhYKo9GoUqnsXbli2eM55161mufpSfN4a2vLlc54OlpdXzGge73OZDr0wNGkOp32cNQHMHmapVF8794d0RuOCoUCF1JrkytNjDPGozRjjPnFkjFmMJ7keW6T0VGSBsUS5zyQjuP50yguVappmnLB0zySXAghkiQBQ9NpVK010ijODB+Pw8bq1p17x0KI1dVVY0yxzA0iITOMKSOcoGLACaexdILJJEbGioWC5/u+X+r2eqVi0fP9LE3TLKtUGkrrPM8r1aVl4bQ6bd/1/Eqp3eoiZ0v1ZWW0Z1iSppNxxKUoBgXpOjpXcZopZcJozDlfW93yPK/T6SRpVqvVWu2+EJ7VxtPpNM9yMgqZ4wWeMtAfxdwt5OCMOkPD/HGiwigpFovS9QaTURyn5VpZCGc67Zk8FR5o9IUrNPLBcDAed/r9fr1et6qxM4gdx/F9Pwg87gm3VFnb3e1No5NOb2dnZzINE4Iv/NqvFWtLvd4g/JNvf+PypVKxsr+/7wg3TqPG2vp7N24eHx9nSRJlOtMwUXrS7jLGJpNJkkTIGSIRmmKlvFqrD4eJlJyjWyqVsFjSOs/T1Bjjuy4i5kaNx+NcZ2nOSqUCOl6aqiSJhsN+pVy4eHHPlTgZja5e3gunY8Fh2O24Lnc5f+HF527fvOF5wcb6rpBunqreoOu73vr6utZ6MOwh4nvvvbe1sbmxuTkYDKIkqdVqXlDojeNkHLW7o0zljVqtN+gj4o3b+/V6Nc9vhNGkWq+PRqPbt287jhMEwclhU3IRBIGtWwnD8N/+mz+SUkZRtLS09H71ZqVS6XQ6Fy9e7PV6BLrdPisUfGPM5ubm1tYW5yKM0qOTE875rVs333//fc/zptOpZYZI0+zyhWu9dmcwGNRqtd3dXSllGMZE1O/3gyDI83w6naZpPp2OwzAmRm5QaLabSpnl5UYQFKfTcZYp33fL5er+4Wkcp77vttvdtY2d5dXtDz76tjHm6KSjlOKce563t3u1X+ofHh4yxsIwIyN5rBcNBvKMSuX6iu+ORqN+f1gul19++bP2bRoOh71e59q1a2maHhzcb7fblWp1MOpUGtWV1YbOctf1dG7uHh1t7l1a2t781h/98frG1vb2ruf5/eGg0+l0+4MfvfPui89fazZPWq0eY6xSrhJRp9c5OTmq1StREmqFRNr15Gg0KBbE5atXxuPp6cnZZDJ1XL/d616/dbM96G2ur9w92C+VioKx6x9+FE2j9ZXVf/MHfziehPWlNeScENvt9mQyWV9fN2E4PT5yXff4pOm6bqVSuX7j1ngyLBUrmxtL0aTre2xltdYZnO3l27Wl0tJK/e7duyury1GcLjcqrc7p7/9+89LVK+sra2+9/ePRsFevlEvlAiIYk4fRKMsS33c2NlYJlpqnrcGg+/wLV+7fv4+IH11/TxMZIEe4q2sb7Vbz/v7tpfoyMCwXCyur9elkePvOoeuISTiZjkeVailNeJapRn15d/dipVwjonA67g1OAcyLL1199513onhSrTQa9fGvf/m3tIY43X3llZeSJAuC4NVXX/3ud7/77T/94/WN1XK59M4776yurq+srHQ6HSIsFIpEBNzTkEfxxHGdjc01ABASHEfEcdjpNBuNWhhOtMmieHLr9nXScOP63b2dC5tr6/V6nZQ+ODjI4qReryuldre21dp6kiQOFxura0EQdHrtk5MjL/CLxWASjiV3VtfWHCkNaM7JDaQrhQGVpmmaZa4jHE/6vn/x4kW8/d1vW9fbYoYAZkzuiLggThFCOK6MoiiKoiAILCMg57zdbu/t7aVpOplMVlZWer2eUqper4/H46WV1eF44kivWCyGYeg4jq2+G41GnU5naWnJUlGmaRrHseu6WuuNzbXhaCSFOD45ydK0sbRktK43Glop1/Oap6famAt7e3GS9Hu91bW1aBpPwqhSKgtHdtsd5KzgB6PJ+MLunjLaKG23hMAAkbNwGvl+wVp2rjtjFOCc93o96y4sKvHSNAVgqQI3CLSi9Y3V/mB0796dpZVVY1Sc5kkaIRMEejQJiXSxWJZSTkdTzvn+/n673c7zXAixu7u7vLzcarUcx9nf37eibXNzc2NjY2ttuXN6GI0HtVrjzv170nG6g2HgFx3He/XVV09Pm/fv319b3ahX6oeHh0kcIwfNySBNJpN4GppcB67XbLYkFxcu7GZZxjh6vu+4QpEyRjEmwmkqpeUyQ4GMiNI4yZI4DEOjdBhNkKBcLkspL+7uMcd75/r9lz/zumBc63wyHnqOYAAqi1xHjIfDnY31za311smxlPz46PDg8Gh373KpUpNMDsaD6XhsnTalskuXLvV6neXl5SRJut3u5uamH7inZ92t3cv9wcQY0+l1XSmU0UEQDCfjMJxsbW1Nw8nxyUmSJI1Go9Fo9Pv9PMoRsVwuK6XW1tYA4Ojo6Nq1a4PBwHGcPM/jOM7zvFqtnp6eApqtrXVA02q1LPF1uVxsNJbzPN3Y2Lh793av1ysWi0mSWJ+s1+lLFkynIRGtrq6Wy+XBYBBFUaVSqdWqzWaz2+0WCoVKpZokcZblxXKRS9npdwO/cPnKJSmc/YP7vW7f9ZzlpZX+oBeF8aXLF1WutVFAGMex4zidTsfzvCAIrJPBGLt3795gMKjX60EQ3L9/PwzDzc3NIAgcx1GUvfLKK0EQDAdj+60kSbIs6/V6SmdKKcagXC5qrY+ODzqdM2Dh2vryxYuXG/UlAPbmm28XgvLKyprDfWW0lM7W1lYURXmel0vVm7eul4p+qVTIUnN8fNzr9RBRMJOrNMtSpVSW6mia5alwRGmpsf0P/+F/895HN/7oj7/l+fLacxf+5v/6r//gh3/+4zffuHBx6/pHH0wmo6V63REycIO1tY3myZnr+GEYKaNd182yLM+zNE2n02m1Wo3jOM/TLMsKhUKxWJyGY5Wb5eXy1npFCNPpdJIk2t3dzbXa2ds7Pj4djSfXnn8hz3Sz3en3RuNJWCqUS+XC6dFhFE/39nYrlVKr3SwWg1I5uHfvTqlUsjznw+HwlVc+kyRJuVSVUrZarSTPJsPxcy+8pDN9d//+5197vTvot5onqxurOk+m8bhcDJI8TuOwUilx5vb7QzJMStd3g7W1Nc9z2p0zjnDh4t7tGzeV0ghuHKnPvPL5en2ledqWUo5GEwCzvr5+69att9565/Lly89de6HZbPlesV5fKhRKcZQeHBxO48nqRoNxOD09ZYx5bmBRanfv3iuXy0KI1ZX109NTrfVkMlFKeV6gE6pW6pcuXbpy5QoiHhwcKKW2t7fDMCwWi1mWTafTbrfruu6LL75Yqlba/bN7B/uloLCyvkaKesOBSrNqo57F0TQOkXSUTs9OT0bTke9KKWUynXbOOgJ5EMaRUdr1PceTyug0TsrVGhgajIYMsFguJVl+1Gw2anWvUI+iuD9KKsbRlLfa4yQ/vHzxUqHsJSlypyQd1OA6bmU8yVZWdq7fvH3zuz+8cuWKtcvizPzgx+/v7e1lWvTbo2Kx6DgOk8VipTYaD95664PhaDAajba2tjzP++CDG1rrPM9XVlZardb9+/er1ep0miDi8fHxe+/dYEzs7u6OR7Examdnz/fdwWDkSP/3/91/cBzh+wXOUSmjVCaE47puo74cJaZz1rl3cI8USU/mST6JJmvLa42VBgeuQZcL5SiNeu1eptXS8lqnd6/X6xHCYDAAxGvXrnFHRlF0eHwUx7H03CRJ4iSxHZpuXr9JRCeHJ5nOin6RSXbW7PlFv+gX68v11ln/zr2Dol9MMt3tjI4Ojk8PbsfhZGdnh0upGQ3HUbPV6/X6rW632WytLq988OEfM+AbGxunR8cb2xulRu2s19FZ3jw5rRQrtb2VoJiWy+XROHJdFxnXAMSFQN4bTNrttgCHMW6Fi+XrV3kWx7EQwgB5foEzqNYak+koTDMVJ2kadzvNzc3No8OjP/+zP93Z2vrsqy+PRhPQinMkwps37oaTUa/TbjQaV6+8wByfgDPHuXTl6nA4PDk5qVarm5vrd+/ebfcH+8cnyKhQKPz43bdHo8HuhSuTG7eYkBcvXg4qpXgadgd9DZhrVSxX+sNBt9tt93pxHMdZCpxXarWv/M6Xs0w5XEzjSGd5bzjY3Nxe29wqlSr90fDSpc3RdHL10uU///4baZpPoonjSL/oI8hM5ZOzTrvbbbe7/eHwuatTRSpJstyM8iQlhktLS1oTI69eX3Zdt1QqAUAYxnGcaq3H44m1hJIkKRTyYrHoeV6tUT84Otze3m40Gq7rhmEohPB8Vyl1cLi/vr7uOM7R0ZHVgq7rVqtVzgQR2TKl4XB49+5dKaUQolqtViqV5eVlaxU5joOIvu+XKiu2n3Oj0bBU/icnJ77v37lzZ2trczwZMgZpWu8PumEYLq80Es1v37+ZmzxJ1ObGFpfy1t070yi5evUFx/Enk0mnN2g2m61W6/XXX9/e3d0/uDuJozRKh+MRITgOVyoPk2ipVgWAOM6qVUdiaf9+0xi1tbn6+7//+8f79za3Vhu1sicx8GWpHMRJ+JVf+9KNGzfSJLl29TkOznQaTcO43ljRZIxRruvu7W0j4g9++P2Dw7tKbzYajedfuNRsNs/OzhpLJS4K7XY7SfHmrSPErFFfLpa8k+Zht9sdh+Nqtdrrtm5eh8kklMJfWV01uRr2u+Vi8M1vfnM8GU6nkzCcLC8v1+tVbbJKpZIkCWNw4cKFGzdu7O/fKxQKaZpeu3atXLoohDg5aQauWN3eYUjbWxubGyvfG3W7Z8era43La1vTcFAWQaHYmEwm0zBa32j4Xqnb7ne7LcdllUppOGg///y1/uBse2c1nKad9jBNo7ff+fHLL32mPxhMJ9Hdu3f7/f7ehZ319fVr1y4TkdLJ9vbm2Vn7ww/fX15edV0/SWIwJpxM1zaX8zwdDoe1WiMIAhd9RAjDqVIqCIKg4KVp6mRiY3NNMm+5vlarNorFsjFmPJ52Oh3X9YMgiKJkOp36fmFnZycIimE40ZrG43GpVHr++eeWl1e63W6owt3d3X6/H0XRyspyOa/keT4Nx1qT4/naKDR6ebuBBkWzOWKCI+E0ipFi4cjJaJrmwhHSGM91PcaCJBkNh3m/e3rpyqXRKBeiXKms51ptbQXD8ejwsLuytvrhR9cvX71SqVRbnfbK0vKP33rrvd/991ZNbW1f9v3g3fduKqW2d66cnJ612qPRaLS5ubm6uhrH8f395gcfvNdpNy/sbn/44Yfeb5QcJ37rzfdfe+21Zqf7g794CwBqtVoS62/9h+8kSVKpVOr1+vPPvZylcHZ2ludZFOooCo+OjolMmmaDQX80GhMZIaQQXAgphC3+zlSmS5XiUn3ZJBlpCIpVJnzHLYaT6PbdO912bxpNOIpavT4ZJzdv3QnDsN3rAsCFixffe+f9JEu9QjCeTsIwjJKEMVapVdN0eOPGrZJXMsaUi5Wtnc2drd3heNA8Obt94/ZkNH3hpeeR2N723nJjRbqifdZpnRyPB73PvPIS4zKM4lp91XVHSaY/89rn7t69G6ep47mIOBmPpuOg22mNwzFJDlIW/aDV6i3X16qVRq89MhqF9JQBkxORTtIJkUYmNza2kmmilPI814ZNhBSNypIxJgyjPM0YY64UxXJ5PJ2EcZxkqt1pcc6Lge9Kvry8dHp66gi2u7v78kuvfOnLXzg9OHr33XdLRb66spHneaPR2Nq7cNbunrVOlcFiuVZPs6WlpVKl5haDYl7xSgUAQKQoSytL9YuXL/34zfcGo0mz3UrzJI0TTeall17a2t0qFAp5nhUrpYzU2dlZlISHx4de1zO5ybJMMF6pVU+Ojm/fveM57h//2Z88d/XaWbu1ub5hgFxXhvHUL/qlejlLYkgy4bgbSw3XcYKi70rn3v7du/fvr22sEsPReBpOp1wIzvnp6VnZq5PB6XTKGFtZXQqCQLpiNBk1Go3nX3pOa31wcBDHITcAuT5tThk3iHow6IzHY6tHg8ABcIbDrNU6uXz5cr1e3t/fd11/b28LAKIoKZYKg8HAceXnv/A525StVCpxzlutFuP4hS9+3hqq3W53ZWXlN37ra++///4H73+EiNVqLYoipYz1fkajkTYqCLzT01Nt8mq1kiSTa89fqFYkGQjHkyyJfde/cGEPAG/c+Mj3C2cnzcuXLxcKhXAy+vD9dyu1WhiNc60Y8KBUFIIZlWUZcadCTCNwx5G+VyoGy6fNrue5QLrfOvZRFxwGWXRw73qvfRRP++32OPDZ6kr9xkcf3b17h6NkKIIgmEzG0sFisRSGYZyMVldXX/3MCxcvbW9urjPGKpXK+kb9+nV2fHyMiOub9eWl2p3bvcCTlVp578LO/fv3kzTqtVuedDbW1nqDMRILp9NOq7Oysvbic88TAEdxYe/SD3/4w48+unnp0l6SZO12k3OpVESEWtNXvvJrR0dHSimG4v7dfZ1n1Wo1DuPmyemoP3n//fc/+vD9r3zlyxtrq/f3x8NBFzEJowGgjmM3yzJtpHFczkwhcMeSDQfdPAuR9Js/+sHh4cHuzs7e7qXAd8vFGhnRbp2NRuNCUCqX3SBY3tvdJKIkTivlqhQYhgPP5ZVyoXV2sr6+8cLz19rdFnehVCiuLq8V/GIQBEopycWlCxfDMEREz3GXlpayLGu1Wp/5zGtxlNaqa2man561sjwtBMVKvaFyfdw8U7lGBnGqNJAXFFbW13wvuHP/Vm/cdTxnMBodHR1pRVevPpek+XgSMi4ZA621Iba8srG0vJqr1Kh82Gt/6atfEf/oH/2TV1/77IWd3VTlnnSW11YBgnv3W2kUC9fhgNM4yuLEIHz5C19cWt6MpibJs+lUp0oFXo1HptXq7R91OODv/s9/0DptJnnWOWtpoM996Yu/883/3Pf9KIp29/Zu3T7Isuz1z32lPwillKt+JSiUx5O01ep0u90w1teuvsARPv+5L581u5zzl178TJaa5aX1QX/iuu7Ozk4QBCcnJ2marq2tlUrl99798MMPrwdBcPXq1X7vju12m+f5/v5+tVrd2txbXl7Osuz4+Pjk5GQcTivVeqlUdl2fM8/zi9Vq1eaTb9++PRhOOp3OrVu3RqNRoVCoVqs4nISjqcvZ3vMvrHRbSZo36rXTVjtOozRNe71Opk1Q9F3XS5MoCpPJaCw0d7hgBFkYt06b3W47jtOSF0gQTBNjWHR9gYxpkow7wv38577kSnF4ctzudA4PTglhdWMduVhZWdNZPuiPLl++bLJ82B9cuHDh+PRkGIYvvvzKc889F7jF5cYKgvT9ghBCpVmURr4rWTEIw7A36Far5YuXLoRsOp1OrdUJAFLKer3OOQfAMAyjKJJSKqUTpWAyAcYZmY21ZcGo3W6uLq+MR4N33nknjZNLuxdaZ71ub7S5ufu9P/vu3/t7f+/wcP+f/I//7Bt//Zs56YP7+0zcA0NhPK3X60kaFQpBmITXrl3J8/zDj94HgEIhePej93701o8NwYULWbVarS/VesPBcfPorNNcWlra2tnc2tnsDbpKJeVqZTwed9u9N5qteBoS0ZUrV6bTaRyHQeB1Tlq1WmUw6N+9e5uI3n77zYsXLzLGNqubUnKlVKbyMIxGo3HD1Bt7y7u7FwDY5uYWEY1GgzRNETGKp2QQObquE4Y4ngyXlusXL16o1WpKZ0HgDYfDbre9slpFrI3H4zCcup7XqFb7o6HNIviBZIxxDo7juF6j1WopndTr9c99/jOnp6edbrPRaEymg3q9HAROtVp97rnLnuf1ej0hxOnpab+Pp6eHnU5za2treXk5zwu9XuvmzZs3b960SYLRaCyl9H0/TVPXdcNw2mn3tEnX1laCwO90WsDSg/3k0uUdzuWlCxezzJy1es9fe/HWzXuu5CbPJpNx++zswoULtUrFKEVacS6BoecGjuMMB71m88SotFItGJ0DgMM8zhzlZp7nNZZq/UFn2Guv1AtLZW866HzwVrM9PAOVgE4+/OCtnZ0dIs1QLy+vCpRS+HESvvTytfG4f/369WmUyqHp9lqMMcB8Z3fv3XffbjQaL71y5ax9QETbOysqz65eu1wuehZdEgTB3u7Ffr+fZRkZvlSrr65s5rke9sZxmulEXbl67fbtu2EcaZ37XuH99z/a29teXVs+OTkig55b/OD9j77+9a8bDePR9Atf+EK71UomYRImLhdFv7C2tBxduPDRBx/mSepKtraydO/ujdbZ/vpaDXg+ziabW1ulykqz2Ts82HekXyj4k8kkjWBza02pRrHkD3pDKTlnfpaS4zj/6n/5143G8u7u7uXLl3zftTMvFLzjk4NavZKmWa83qpTrn7v0mu8XGEqCOjBIkqxWqzUaDc5kt9vNsmxvb49zYSy7IudEaAzUarVSERynvH90/d133+cCX3/t8y+8/HIcpZ1ua3VjLUmjNMmZlIPx5N7hfrVSd1yRZer0rHlwcEgGPS9otTqlUml5ae3s7Mzz3SzLtM4rlYrruloDMIyjtNlsiavXPlsqrY4nut3t5WlWPOkbpfvDAQNcXV+rV2vVanX50tLG1nq1XEmyFFlxMGhe/3C/2+8xQC4FGBpNxq++/Mp4rMYTvb17QWXy+Refi9L4o+t3m83mm2+++Y1vfGNjY8MYc3B49upnvtDpdKIoanf6g8FAKVWuLL/66mfbzcOPPvrg4sWLg6PTtbW1K9de+L3f+73xePzVr3612WzeuHW3Xq9fuXKlUCicnJx88NGt8Wgap3mhJKdR0mw2O52OTfGrOftxpkwcx0qZ5154aXNzq9Pt7+1dVErdvXv33t1DooPxeDwYDI6OjjzP833fcZylxtrm5iYits5OKwW/Vi3qNHEZ464TT8ae4AW/0ukN+p02ISv4q/F43Oq28ly7rjsdDqrVqudKR/IkDifjoZTuUqN25cq1NI3H4+lkYrI05hyXGjV/Y73bap+cnDAOF3YvTKPQLwQ7e3uHRweba5udTqt1drZUq5fLgcvExtr66up6ezRaWV5baaw0qo3xcIKau8IdDAZxGAFDnagkzgiU5/g6N8eHx8bo0WhQLpcLhYKNBXMu0jR9/fXXHd+LjjNC3uq0mq0OGON53sbmmhRM5emd2zfTKHUcZ3V5JQzDP/mTP/2jP/pjUnp1dfWtH7959bnn6/WlwXDynT/7Xqleno7G61sby0tLdb68tbURhpN6o/Ynf/rHB0eHly5dWlldvX///mDULxUrV65d9r1CvV5XZOr1qhs4Ukom8PD4/v7h3a3tjULJW+OrYRgi0gsvXVuqrkxHU5tAYmwdAIQQFy7sjcdjxrBcLpXL5ePj4ygKu91ur9e9cOEiACsUiuVysdPpdLtdzvlw1B+Px/1+f21trV5f4hw5591ut1yopVFeLBYrtepwOFhdX26sVKvVSp6nAObs1snh0cHKytLKykqu40xhqeyNJ4NBr5OmabVadYST51mWGyTFGLuwuzWdTr799o+/+MUvbm2stlqtPI04GqC0VHTIJO+8/QObfmCMFYtFzlQSjz784O7x0d3XXnstTdOjk9Obt2+1Wh3PDWq1WrfbtYjAdrs9Hg93d3cqlcrR8X0CnefU7/e/9KVX4rg5Gfb2LlzMUjMeTAu+Vwi8Rr2aZ6ZYLK+vrYTjsNNqCoYrS8vLqytOqXTcPB0MhshZuVohNKNhJ8kTwVBr7UgvTEKteo4jVtdX+p12Ho6W6xUPdRr2NaW+pGClVk5EUCw4vnfxwk7RL21tbh8dnNy5fTPNwvsHHwDowWBw8dKekFUhdZ4np837yLKz9gGXant7+4UXL41GozSbjkcDozRArd08Gw7Ga2trwncKfjGO06PDU45yNBhXq7Wvfumrx6etH//gxwxlmuenx2dXrl5aW1l95923fLewvbGnMo1InucEXnDvzr0kSfI0T6KkWq52pkmWZYwzyR1G7Auf+zxl6uz0rFIKuMMKnp+OxxwpKBbQaKN1kiRSCBuj297Y7na77XabiApBAI2lUXfY73ZLhSXBg43Vta//5m8eHR2Fk0G/KxDxvffeqdfrn//8F/vdtsriRq1+/879eBpduXiFIQ0HPRR8Mpn0+33f96fTKWdCCBFNwmgSVqt1BCwFpdFoNBpNpqPpwb2DQqkaxgMD7NoLL+Z52huOzJ17tVqjWK6ikB4vNpZLW7vVw/v9H731plL3Xnjx6vLK2srqarPZ7Hb7AKxWra+vbx4fH1+9+pwNlE2nY9d1szxNEpUmSblUO2ue4H//3/7ucDjsdDoWtW2B247j+F7B8zxE1ECedDzfcRyn3+3YoM3+/n63251Mws3NzUuXLm3v7hwfHtWXGoyxbrdbr9dv3PhoeW2p021Z3Ouw1//iF79oX8XLly9/+OGHWZYppRzfsxHVtbWV1snRhYu7NjE7GAwGg8H29raFuKysLI1GoziO19bW0jzrtjtBUBwOxpcvX0nT9ODgIIrCOI4RcXV1lXPuum69Xq/VajYIi4hBUDg4PN65cHF1aTk3unPWunnnZuesZRAa1ZpFjk+ikJTeubC3VKv3e+3JoOu58vSsubm5ube31xv0u/3+6VlrdXU1TlNNJkri4XAIxCw6sOAXda6n0+nGxka9Xu/1ekmSEJHv+zZiYFFGaZr6vu+7bqfd8zwvy7Kt3R2l1PHpCePcGNNYqqVxsr21eWnvQuC7jKDbbd87OKwur7z9/vuCsVs375CGy5cu1Sv1N954Y2Njo1AoRNF0OOyvra+88PKLSqnbt28m6XQ6Gq2uri0vL4/HY50rRN7pdGq1mlKq3W6vrq+dnZ2Nx2OGot6oqizv9Xp/97/421EUvf/++4VC4eLepcPDQ98NqtVqr9cf9vrXrl0zxqyvr/dHw5Oz5nAyPj09+epXv/r5L7xeKPh7eztJkkym4z9/47tvvfVWlEYXLlxwXbd5dlYsFFzu7+7ulcvl01azUCiMRgMAQM7CcFIsBaurq63OWRzHjUYjz3Pf92ulBiMwBo6Pj23Svt1ub29vK6UODg7sTT49Pb1///5wOCwEJSQ+HI49z9vb2yPSiOS67r39e9tbW5Vq9eKlvSzLbGFqt9tdX11bqi0RQa/TTbJkb3d7eXWpfda6e/+O7zmN5YZR+Wgydh3h+X4cTSfhlDTESWIUCYd7ju94slIulyuVcqn0/gcflEulJE3XVlezPO/3eoPhUEp5eHhYLBYbjcbZ2Vm/3y8Wi54XbGxsTKdTx3GUUpafLk3TYqHUWFl98613OJcbGxtxNOuFcHp6ura2lqTRysrKZDJaWa3v7u6022f1enB0+NE77/zw7/6dv79/cDwcTq9eef70pD2dxlrRdBrZKPPKysqrL7+SJMk777171GqleWbTGypPjFGlolOrVZIkyrOsWCiPB2GeMsGLv/kb31ypNP7J/+f/vdqoOD4PSp5XcIKKh8L0J/1isRgnieP4nfbg1Zc/m8TZ++9/mGZhUGJr68sHBweTyWR5eXlpaUlKeffubcdxLl686HkeIkkp9/f3T05OarWazvK1tbVoEpXL5ZdeeuX+vQPGuIUeVcr1CxeuDAdjrdj6+mar1Tk8OdSklldqeZ5LKZaWq/1+NwzDy5cvNZvNyXS0urraarVeeP4lx3H39/cb9Vo07S83llyn0G63ifC3f/u379278/2/+C4XBpkKijyMesNRZ3mlyjlev3mrWltdXtmcThLJvZdeelmgODo6AjCSC53nruOD4VqxXncUTrPLl65lmUrT9PT0eHVtRQh269aNoFjY2dk5PT17+aVXheNrjVmqjQHO3Nt37zQajdFoUCyW33vvPcdxXnvttX5vYNE0pVLl0qUr3W530B+dnp66rluuNghkqVy9eu1ytVppdTtJEhUKJWS81xu4rp9nenmlkSTJD//i+6PxYGmpsbGxdvfe7Ts37tSXl3y/kOf5+vqGXWN7e3ue5wJAuVxWKmu1Wmk8EdyUSwX8b//v/8+VlZW1tY1SqXR0ctxsNq/fvLm/v1+r1ev1+vr6en2psbu9MxgMCq6UjJ+dnR0cHHzlK1956aWXms0W5/z73/9+fXnp4u6ecJ3Dw8Ozs7PBYNDttjMdReFoc3NzOhqPhyMESJKkFBTG43Gm1Wg02tndRc5yo69evdrvDxmKpXo9iiLP85I8yfP82rUrdlauK7vdbq/Xq9WqlXqt1+7s7x9sb1wcDielUsEYvbK6tLq6ev36h/fv3zdGVavVUqmys7NzdtaeTqe9Xi8olF546eVWpz0ZjwjAc13Hk77rBcXC7Zs3oiRWeTqZTo3W6xsbe7u7lUq5dXK4trJCRJqo0Vj+8PpHb/747cvXrm1sbLTa3TiOATkiFsoVY0y7eXbn1p1SqTQcDjc2NnZ2dgBAMN7r9WydRL/fj+O4UirV63VEbLfb9XotKBXv39v/8MPrWuvRZHL50rU8z40xguOVK5dee+21jbUVY3S/3211O4PxZBxOPc/rnLVPTk44CsdxlpaWrn944ytf+UqSRAcHBxcuXNje3QnDMEtiydnB/r3maYu0RgKjdMF3a7UaY6zdbgNjpUp5Eo4r9dry8vIHH3xQCgpRlDRq9Y2NjUqlZN2jzc3NV199tdlsCiFOjo+Xl5dfeOGFe/fuTabTe/sH3JFf/dIXEdH15N27dzqd1ubmZq/XG07GxXKpWC6HYRynCTKWxumkP11dXrt06VKUhM1mk+D/z9N/xliW5+mZ2PHe3nO9v+FN2khXVd1luqu7Z3qazZ4VZ5pDDgliBQnCQiuAEsAFqeVqAS20XGgFLSVKoobUrrgzoBHJ0TjO9Ex3ue5ymZWVJjIyfMT1/t5z7vHe6MNpzfdMZNy8iHP+/9/vfZ8nAoA4gQDD0FR9xfGMKIqmqQdBwHEshuGWYd/Y3bu+7mials/nfd9PV0ppokYUpeVyCUHQaDRCEARKEHmuaYqRyYphGGI4miRRsZi3XCubyZSrVRAEJ5OJZTkoiqIYgaHoVqtlWVYaMp6Mh1ES9TrdUrW4sdZ6cfhc4NlKrepYlut76WsAhiAIhuWFUm/WgBjsDbrlUgmC4awk8qLw7OnXummYumY5trxYYgQuCLxuqEEQsCy7s733/Pnz+XxRLlcJnMrlckEQMQwDAMB0Osvlchubm73h4Ozi3Pf9lIBfq9UEQcAwDEEQ0zRpmsZxXNO0Yik/nU4xDM7l2JPXr9rX3Vt3D8IgOT4+rddaGEbcvHF7tdI6nc7e3p6qqiSGoxj85ZMnQRTDGAzGEU6gnmf7gd1s1CuVUrt9FfnR3t4NGETPTq8hkNhY395YWz968Wwxm/AZVswIpm3wPC3mhJWmBEGA4yiC4QiMYRhhGEaxWHp19Gw8ub55a4dl+efPn5MkRVMsAADX1521tTUQBJfL5dbWFgiC6aFnPB7HQbi/v79cKDwvSlJ2pZqiIAEA7Pmx6wQoTuM4uVxoPCfyovD0qy9evvh8rVWtVquHr17QNL221my329lslmV5giCABGIYzvP8JAZLpUoQ2gwDhJHne4mum7dv3TFNs9vroFjy+vgpCPsH9/ans97R6+ettQbDUNP5DIQIP4wiPxEFyTKcUr66Wq663Z7ASffvPCBxZtSfxkFCkRwIQhjKmJrPscJKlTNZXtNXg3Ff1eU7B3dWqxXDc/lCuVCuHL58bdnunTsHh4eHp8cnDw7ugSDouq6maYZh8LzoOA5BUDhG3L17r9XcPD09e/r0GYYSjUbLNm3PcyE0unlrz/bMbr9rWu7O3m3LDGwr2N+7DQAxRWMIlDx7/qXAczAIH748evLll/s3b4IgSDNkrVabzWYwCk+nU9e1q9UyQZEIgvA8r65kyzAJggD/27//f5pMJvfvP4RgOEmSfD4fg9Cnn36K4/je3l65UktP4o169frkZNDr2rZ9fX19enouiqKu65PZ9Oz04ubNm3t7e7dv396/dXOxWHz00UeXV6fVWqHbuwaipNVoEBhh6hpDMRzHjvpDnCKurts4RdSbzXK1DMLIT3/6wWy8CPwQhACCINY213Z2dlAUdRxL1TXD0GzbzmalxloLQRBVVT3P712PozC5f+/ezt42RWIojoyHo6PjV9mMtNLUwPO9IATiZKXqIADACNbaWO/1+8pqubOzE4b+xcWFIHApBLHeqPX7/UxG2NnZabfbi8Usn8shIECRJARB89kyAYEkAYeDseN7PC9QNIvjJAhBSQLatm1ZNgAAOIqlYgdd19P4rKkbAADwPB8Ewa1btyzLSqIIw7Dnz5/DMFSulUmSDMNYXiqTyUxRVMf2stlsuVxptZrDUX86He/v72Zz0nw+jZJ4NJ66gU9i+N27dyeT6Z/+6Z9mMpm7t+9wnJDSfs7Pz1N1BgAAHEtDQJyTspEfrGSlWCjcu3MXx9B+pwsA8XW3gxG4kMnMl7NiubR7Y//y8vLVi1d3b98plUqXl5eGoaUn8SRJKpXKZDoql6rZXAZF0e3tbZIkT85OozCBMbRzfbm3t1stVz75+UdnZycEQbAsq5sGCKOilEFxaqWqnV5/PJzsbuzGYZLJCPl83nIsRVniOE5S6Hg2WSxmURJyPINhGIYhDMPQJPXVl18Vi8VcrpAuMFAU1TTNNE1N02q1BsuyJycnKIryPM8wzLA3FqisoZkYgSdJZDuWaeq1RrVardI0jWGYauiTyQSCkHyuiGCYqesEAsMgNBgMOJ5RlGUQBBiGQjCQ7gAoihAzvKZpuq6TJAGCYKvViqJoOBwKguC67mAwKFeKGIZFUbC1taXrumEYpqn/0lEMg1vbG4aheZ7n+yFBEJbpRFEcx8DO9t7Tp09t283lcgRBrq2tMTT35OlXNEejOEpR1HA41DQtl8shCBrHcTabXS6XEIi0Wq35fN7r9UAQzOUlzzV4nve8IInBSqU6Gs4kKed5wXfe/y6CIF999RUIgoPBQFGUjCRyHOcHoW1bYeABYIiiUJz4hrayLHNtbc11vYwgGboznSwYRqiWarVa7fz0aDYfgQhUq1domlRVRdXVKPaCILh58yYn8Ofn5yAAMwzT7XZzeeH88mW+IDAMh6FEWqUOgjCVpQRB0O/3OY4TRalUKmAY0W5fVUtly7La191Go7W1vZfJZMVM7vKig2PU7bsPVM1y3aBSbrh+YJo2gYE/+4t/1+td8jy/vt5arRTTNLO5TBzHpmnOpotcLqeqmihKN2/cns+XCRCQdELT5HAwMw33V37lV589e/bkqy++8c3703kHRsIotlEsiWJfN1QMw3hBGE1nIACXy5XADQiUdu1QZCXL9F07lPiCqdmN2trZ8Xm3M/z2e9+eTpaeBWTE7Pvf+VamVe2cHP6L3/sfGI7K5Pi1zTVZlkvlqqLpS3nFcrzjeAAAmKpumyaO4yRJpvNJhuaur69BEM7niywj0BRPUWzgRxhGlItlx/SuLk+D2MqXpOZ63fQseamiKJsr1CkiY1seQWK6Ko8nXYZGAt+hcOrs9DSOY93UptPp7ds3ZVkejEeCIIShH4YhxVBpo7ZUKhmGwXG8ZVmIbljVWsN2vE8//fThw4c/+Ks/+h//xe995/3vbe/uhGFYrvMADAQWcHbafnn06uL05Orqiud5UcrUarVOp1PDar/xG78xXcwPDw9jKK63mqvVarlcSlLO88N333kvcAMYAmzTYUgKgpCnT5/QJHNrfS2XL1muNZsvr9qf0ixPkiRBELkce/PmTcuyJpPJzz/6uDcccByXLxQomojjeDabxyCYKiNMwyVplqKY4WhC81ylVHj8yZPJcFBv1WeLpeN5JI5zQoalaF5yPdtxfE83DIomNB22LEtRlqZptlot33d3dnbEjEBR1GAwODw8DMNQ0wx1tYISQFVW29vbtVoDBEGCIgv5kqIocZwkIKxpRhCFNE2HgRf6Ps/zb73x1qeffirLchp5TuOAjx49gmF4OBzGYagslyn6A4bhRqNue7bv+yiKcxxHENSjR8WjoyOKohr1xmQ60jSNZdnlcjmZjl3XBoDY9QMMx3EMWS5mSRS1Gg0IggSeWy4WQRCQOHbv7h1ZXnW73SAIYAggMIRhmGqpDMQJAsM4jsMQmC3k8/lsmMSGZYZhqKoqThIgCJZKpY8/+BCAEoqhURyDXYygaMB1DcO4vG6Xy8UgikmKWV9fB0HQ88NataEoShzHs8lUW62AOKFoolIqm6YJAWBOyiorbdDrM0ImTpIkilEUDcOAJmmCIBqNhuVYtm2CILhaaTs7u/l8frlcJklEUCQAxBCI0TS/v3/T0PRsJuc4jqZpTI7NSXi1XON5vtcbGJqZESQMw2iazmazLMEev7q4f3AfhKDzizNfczc31xmOtR1zOhu7rhsDAAQhEIQsljMYwVzbMbQVjiK2bTueDYCxKGUAIAlCLwaSYrmk66phma7vBVFQEAowDC8V2bbtdrcDw7Bp6rIs267Fsqxp6ZmsVKvVOIG3bdO2bYZhNE1NkiSbK3AcFwTR6ekpRhCZTAZDCc3QYRSTsmyt3tjY2KpUKqPRJJPJmI5ZrVaLxSJDMaqqxnEsy3IURbPJHAAA2zMm43EcxxAIVqtV2zbz+SLDUJPJ7OtnzyAI9v1wPB5blvP06dN3331XEDKj0YjjuPTIqSfGaDJttVrNrZ3LqzNVW3IcvZivut2u58Ysy5IYh8B4JpNPYigIYp4XVFV9++23IRQ+OX09nY4BMDJtw3EsFEXPz08RDO12u/P58v3335ckCYKSN998c6UuJuOZKIqW5dA0DQBgoSB6boDj6P7+LoZhAAD1+10UxcPQRxBI01aOZ8ur5cvDZwIvFfKVw1fH+Xy5Xm8qqmnbLkszsqKuVlq9Vjg4OECQWBR5BIFr9RIIJr1+t1zOB5F643at2+3mSzxBBFfdx2trG8uldnrWYWiu1dqkKHc2H6+t10x769///r/667/160KGvLx67bgmgiAITMQR8PTJ8+/+ynd6vcGg2zN1p1ZtgjGmJ5auOQJbKJca2b1iEkECV719O0BAOJ9ba7e72YyUyWWuXh2Gkfebv/nXrzsXw/EQgYlctnR11cYIKiOI8mrleZ6iKALHK5rCMAyCI8VKURCEMIgxkohjgMAp1w0YnqnVGqPhZLXSGthagmEEJraqG5k8v7HRWmpKEg7DCJLEynQi0xQ3ncx6nSs/sHqWAsPBrRtbd+/vnp6e0mKW5jFFkyEUrDerNE1DEIzjuChldF3XNA3DqRzDIQhUW2uA//GP/ucEQdi263lerdkYDoe3b91991vvPXx4M0mAKAL+7M8++LOf/OT05Pgf/L3/zXfe/xaGobbtHL865kTh+uLS8T2SJAeDwRdffIEgyKOHb9q2PR6PG80aw1Fx4hMYudaof/HZl59/9ouslD+4dycrZnEKXylaNi8xHH92eXZ13VkuFo/uP0gx7t1uN81HG7YBQVA2l5Mkyff96XRquU4cx67r+n6YEQvlUnU2m+ULWZalf/7zj2Vl2Wo1yuVykiSmacMwbBoWx3EkSWcyghd4s/kkHdHQNJnWTS8uLqIo6PV6URxeXl5Wq9Uf/vAHDMM0643ZZDKfzprNtXw+n77VBoPBbL6gSUZRV5pqpF05AABompakHM1yJycnnudxHEcQxHw+l2V5Y2NjOp3GcTybTLBfqqmgra0tmqbKtfJsNomipFyu8pwAQdDl5TVN0zdu3Pjoo49UVa3VKn7gyfKCpslsNus4juM4PC9++eWXgiBsb+++fPlybW2tWiq/OHxlGQbNsoamzRYLHME5nhF5oVKp7G5tl8vlyA9UVUVAkOe44bBvObbjeRACT6fjpSIzPOf7/nw+930/CRPdMlmKFrMShRPFStnSjW+8/e5oMHhxeHj75s3t3d3lfD6ZjEAQHA365UpxMho/f/7s1371e/V6fTabXF1d3bl34AXhdbsLoiiIwJ4bMAw3HUxyubxt25mMqKir2WzSaDQMU9MMAyfQKIpwHGd51vO8KAoKuby2WnmOm8sV4jg0TTuOQ8fx0tZlu93O5XLlcnk8Hl9eXqawngyfk8TsZDbVdXU+n0ZxIK8UQeBLpdJ4PAYRuJAvhmGsaUYQhhAIAlGYRPHBwYGmr3Ac39zcOHp9iONoqVTKZIRev0PTNAgCq9Wq1WqlIhrHcYbDIQAAnud4nler1XieX6lyo9GoVqumabqune7AJpOJoio0x9IESbPcxdlZECUczTTW1oe9oRcE9+/eu3H7FoESveHg+NWxZhhfPX1MEBhFUSAISpJEkmQQBOVyOUlA3/ctyzIMQ5IkGIbz+fz19aVpaTAMJzE4ny9arXXX8ZdLFYKgewf3JUn6+OOfD4fDWq2Sbp7iGHBcv9Fo3Lq5//Ll8+GoV60VwTgqFovz+RyGYYETSZIFAWQ0nARe+I1vvnny+hlFoyAKAkAMQYAfeI5ng2AUx7GmaTCKPHr06OqqPRqNtre3c7mMZsxc13JdN5PJUBRTLpeTBPB9v9vt2rYdhYlt26IoKoqSHo9gCEgiwHY8HMc9L0JgNJ8vK7I2nymFQonAaYJgHNc3DBNFcM93trda/UHbceyVusjlBVFkp7NRuZIHwMB1TY7jADCJosDzHMdxyuU6DFKffPz5m29+QxSlTrvLC0w2J3z8yZ9r+nx3b2Nru6koys9+9jMEwW7euNvv96u1oiBwUQRKQi7wQUGQVgvTc0BDdW7fenjv9kPXiUU+B0HY0avXDENlRM409T/5kz+ZzsZrG2vZbOazLz6NokAzjVqtMp3P8vmc7/sLRX7rrbc4jmu3O+n41zTNra0tkiR7vd7G+hYEIZeX15PxfH//5t07D3q9/vNnL2EAs1fhcqk8ePPg1t3dTE50fWc0nubzJc+Hz04vq9XmaiXLi0lGYhfzkeuvCgX2G998+JOf/ASEYRInXh0dR1GytrGezeR0w6Ioav/mLUu3nnz9FAThXCE7Hg/cwAVvVe8/ePDACyIIgkiSnM1mCIal12rLdn3ff/HiRavV+us//o2/+eO/+q/+1b9VZPk3fvM3T46PB8PhbDoFIUjXdRRFLctKDywYhjEMw7Isy1EbG2sAAL188WzQHfyVX/t+NpuP47DX6ZcqxTCMwzhw/fCqfdnvDy1Tv3/3gCap88uLfr9P0+zm5mYmm2232wRB6Lpuuw5JkkmSzOfzJAFKlRoCk54fAmAMAMnp6TEEAxsbG6enx6vVqlwura2tp0imOI4r5ZogcsevD2ezSbPZZFl2Oh33+/1+v49hGMNSs9lsOp3evHnjt3/7twEAeP36dbPZ7F63RUHAUDwNF+M4PhqNNM14eO++4zhpGe/ly5e9Xg9FUQjFlvLq1q3b6dbatm3XdREEMQyDoqh6vR6GYS6Xoygqna0lSby51Xr+/Hm73c6IWZIknz9/WSyWbty48ZOf/EQUhdls5nnO1tYWTqCmaUqS2Ov1JpMJw3Cnp6eNRmNne+/FixcbGxtvvfnmn/3kL64uLkmaogiSZhmKoBzHSY/GFE54noeAEE3Tnm3P5/Nvv/9esVhcKkoMJAgCnZ6fzZaL1DJ6fnmxnC8ACMxnCwRJJhFQrlYCz7/udEqFYhCFs8kcRpBWs/n97/+Kb5s//+Sjer0qzxe9frdWKReLxclkwrLs9371Vyq1hmlb0/n8088/v7pq12qNlaLhKNrudtMlv6op6xsbhmGMx2OGpWAUzWQyxWIxCALdNGiKkARR4LnlQk41I+PJyPcChmGCIKjX61tbW6ZpPn78OAgCjuNs08zwkqHr1+12RhI4jqUZUtW0XC7H87yiKG4Q4hgBQVAUJQkIIBA8n0xBIL59+/ZkMgZBMF/IdrtdiiJAEGRZejafVKtVHMf6/X7qj00xzunXmmKmaJpEUbTZqqegLtu2MQzRdT2fz6801Q9DBEPHwxHNciROQDAqL5eFYplnud5g8O333t/Z3f3sF59fta+jIO52257vpIcSBEHy+TyO47quS5KUnjxSdW2pVGJZFkEQ2zYNQ2dZtlwu87ww6E8QBINhtFat//jHv/UXf/EXH330EYIgHMekudJyuToazwEAfPjgAASTxXK6WsmjQW99vbW7uzufL4f9kW25lXI9joGVrK2vNy/OX8jKNJPPlEoFz3NgBKBZynGscrlsO9aroyOO4w4O7vX7fV3XZXnZWi8lSSwIQtq0Tz/LfD73PC+TyZAkdXV1hSCIZVnpdR9MIIIgppO567osK8IQgqMEhlG+FxmGRVNcVsovl4rjeAzN9Xr9fKGEIMhg2P3Od9+zHe3i8ujRG/eePf8Cw8EgtAgSBaGI4xgQBBbLmcDnEFCcTmRJygVBYBjGxeVJvsB/45sPj14/Oz55ube3U683+72x70cEzsEwHAZWLifBMC5yYhRCjfqGtvLkpW7oPgSQklg4uPuGurL6vZEoSqNRv1HPbm22fuef/zMURSVJgiAoW8h5nrNcLkfjQT6fjeNQVpYojiRJhGHE+uZ2uVx2Xff4+FgQBJIkR6NRq7VmW66umzhGVyrVQr4Cw+hyKY/7c9sIgyDK5fm9GzuKtmyuNXTTKJQrYQA6dtBut0EQnI77jqtvbTYvro40fXr34EYYRlft6yQCsrlCt9uv1hvVUnUyWwRBsn/jJgwiL18dhkEs5SVWoF+9eg7+9//t7zEMc3Zx5TiOruue51mOY1nWYqn4vn9wcOD7vm3bCAyGgSsJvCRJb7/9tuM4cRxPp9PpdPr+++8/e/ZstVpBMDAaTlaqzNAcRRP37t2bTiee55XL5Zv7N97+1bcf/+yLDz/8MCdlj09POp0Ow3GFUtF1XdM0URhxbZNj2CAKW60WgmCz2SyXywEQZBjmYrFQdU3gM2lXwvdDiuEm00Wn0wPBRMqKiiJjGLK9vR0noWmaKYbh8PBQFKTBYLC7uw+CyfX1KYrCzWbz6Ojo/Pw0SRLd0Hd3duMkZBhmPp//+Mc/vnnz5osXz13X63a7hqIWi2XP87rdLknSCAItZ3Oe533fx1GsXC6TBNHv9+fzeRzHYZSQLNdcW5uMxo7n0iQlZMT93b0oicMwZFk2k8lMp9PFYgGCYBzHHMfyAm0YWr8/TJKkWq32e8NSqeS6bnoRcV13NB4gCIIg0Hw+X8zmxWKRwDBZlh3PkwQJIwkCxSiWS8egPCfm83kMw3Acj+N4sVjgOCFJEo6gnueJvLC5sSGKgud5nmPlCoWTkxPDMvPF3HQ6VTQ1n893+z0Mw2AYVlUVQwkMw6bTued5z549J3Bqe3t7OBwDAHDz5m0YhtdatZzIa+ry8uwchsHvvP9tDMNomjw+PhZ5HsGwhawsFWUhy89ePCcJ+kc/+o8eP35sGMZKM6q1MgzDpmlmJMn3fZZlZXk1XcwxDKvVaplMBkFRHEMalbIo8oeHRxiGFIvl8XgIQZAgCK9evSqXy2koaLFYHBwcFAoFVVEMTfddT1FXDEPn8hLPswt5mXavtre3YRTvdvuKooRBBEAwjmKeY4k8b9t2qhc3TfPWrRswDC8WsyRJ0mAJBIGyLHMcF0VRum3+S1ea4ziWZbmuHUWRaemGYfA8XyqVgsCjKMpxfZKhq7VGGvcuFEpxHF9eXoIgRFEUCMA8z+M4eXJyYtvuzs5OFEUkjmWzWZqmR+OBbbkoBi/msuc7YRimDIDZbEaS5Pr6ehzHYRg6jpXJZDAMKxbLL54fFQolgRez2azjeM+ePXMcJ63gXFycpTfUtfXtMAwpEu922yt1yTBUHPppUg4AgOl4NhyMK+V6uVwNvDCXF68uD8PIESTBsozBsN9s1nf2tnVd9Xy3UCjU6vVPPvkkSQBJknieZxj6yVefhpG/ubkJAEkcx5Zlra+vwzAMw7DruinuBUWxq6ur2WxWqzZ2tnYJgmq32+PxlKFZCEJgECkWy64TJGFiGk42k2NZXtf1MIj9IDZMYG1987p9XixJUexetV9XqvnB8KpckQrFzPMXXwFgkM0JABC3Wq0wgK4vJ/lcNW1BttZqn3/+i27v4nu/+i5JYmfnrxmGoSkegWl1ZSmydefWbcdSJ9MRAqG6YRfylWKhms/Vri57PJe1zSiJUS+IIx/ACApFSBgKBAElKWRvb++rp1+PBuNsNlupVFaqXC6Xh8NBnPgsS1u2Hsd+EgXX3c7m7g3bcgEAGI/Huq7XG1WG5nRdh2HEsb1qtdlqrkcRYFuu74e6bkyH83w+b1oqKzAf/+KDnb0dEIEJnHz06M0giNrtdrvdPj89iuNgd3fN9x0+Q6fAZoKg2u1OvljO54u+F3Icb1rOaDShGC6XyTm+h6IYgiGOYw3HA/Af/b3/bjab9QYDWZYbjebNmzcXSwUEQZKm4jgGQfj58+cAAKw1G6WSdHBwZ7FYpNicbrdrGVqxWLy8vHzx4gWKopubG7ZpdzrtOE4YjmVZ9v7Dh9986639/f0PPvhg2B+MRqNCoUBi+IeffKyq6u7+3vr6eorBLhcLWYH/4rPPx+Px2tpaEESPv3qiqXqhUIgA0HGc1WoVBjFBkZ7nLZeKaTuOGwZRmMlk7ty5tb29OV/MNG117969r7/+OiXkKYrCcYLruoEfTifDSiVHkrgsy0enR1trG++++25aC0oho77vUxR1eHjoB+6bb3xjMpkcvXiVRi+iKJIECQBi27TSbEZOyjqu5TsuRVG6rhuazouZnRs3J4u5qii5QqFSKvlhiCEIL4op0SVF+g3Ho8ViIcsyBAGWqebyWQRGSZLc2toiCOrq6uqrr77CMCylLUEQYBiGKIq5XM71nEImm75FLMcOvCAGkmxGUjUDw7BCoVAuV9OPHEURgmNhEDumDUEQQRA4joMJAEFQRhLz+Xy/22E4djabIQiSzUspwN2wrSDyaY5FEXw4HFqWA0GQ43gUSYdh3O/3Nc3IiNm33noLBKFPPvnE1LV7t3a2t9Yuz87jKLh765ZhGN1e++LiIg4jUcrEAJSAAAwhk/kChJAbt27quh6GPkFQmUwGwTGSJLNSHsfx8XTS7w9msxkAALwoNZvNer1O0+RqOYOSeLXSQDAhSToNAqRrdhiGLcuSJInjmWazOZlMer2etlIXs1lzrfXGmw8Fgbu+vgyiUBCEbDb78OEbMQBcXl4vl8p4NFnIisDxrm3yPLdYLEqlAk3TnU7ne7/yHQzDrq8vHceJ49B13XQ8UiwWEQSZz+cpMRcEQRzHYQSyLCuN9mcygqZp2WxGkqQU2OtH4eGrk0K5xLKs53kETqqq6jgOBCG6rq+tbbTbbYpkMAyT5dX+/n4pX5iMh0AUx3Hc7lyZht1aa4iChGIwAADpOGg0GimKUq1WkyRSFMULg1qt5vv+3u4Nx/E8L4jCOEnAk5OzNMw+m01Sjp4gcEmSmJa3trbGsfR4PPQDp1jM4yiq6+rZ2ZkgZAgMl+VVEkMwhEIA3FqrUWRycXlq2IYo8hRNiiJfLBdomnz+4tnJyeuD+/cqlcpyodi2DUFwLpddzMdxEm5vb2ezmfRoCACJaZoPHjx48uTJ+fl5Pp+/d+8+QRDHx6cZMWvZPkkyEADquh4EEY6RDMVkxayiqBRBz2cLSZDq9eZqtQrDOCNVCqUdlpXOzo8//ezDbI4PQrvbP3/vW29iONDtXfqBpazm9XpFyorD4fDmjduiUOx2+ymk9uDeravr0/OL11KW5Th6pcrj0cwyg421m1ubNy0jXswWmjJzPevRvYcwhs9niusEm1t7mmaaVsgwPM9lP/7ks2wmd+fu/fPz89Za9erq5U/+/I//zt/5j3GMNFQdBGFV1TOZTE7KbG1vtK/OXdc8vzi5vDp9eP9eBAF+DKqals6NTdPM5aVKudbv95vNtePjE9Owd3f3q5XmdDrrdvqB7+azEs+zs/mo2qh++eRzmqWyhWwQhQAA4Tgu8sLV1YW8mEoZDkVgISOWy003CJ89e7a3uz8ej7v9Xr3eNHSL53kARrrdbhQnOSkLISiCICm/Wdd1sMntoCi6v7+/d+PGwcG9drs9my0Wy2UcxwRFbmxspbytbEa0bDWJw9PT016vN51OVVXlWTp1eN68eWNjY8Nz3H6/nzZ3EASp1Gr5fD5l+BwfH/M8D0GQruscw3qBX61WRVGM4zg9sdq2LTDM86+frlYrVVXjGIjjeDZf8DwPQchK1yAQKZVKEIJeX18brpmXynECIijeaNZQFM5khIwkqqpCUdSbb77Zbrd/7/d+D0GQ+Xz59ttvX11eW6YmivTm5rplWa7rbm9vchxnWRaKouPxuN/v7+zsTCaT6+vrlMf05sM3Dc0URRHH8fF4jMJwo9FIotj3XRRG3njjjdlk0u22y8WSoiimrj968xtO4C+VFcMwKe3dD4PRaJTP52maXirKL37xi2KxyHCsrus7Ozu+58xmo8urC2Uh4ySJoygviv1ut1SpoDBcrdfBJPGCQBJFLwgcyxQEYdDppUMAhmNTuEVKpKFIBkYR3w9T9AeKojCGxnE8G83TiRzHcTiOh2EYBn4CAsV8zrQtUzcohmYYShAEHMevux0ASizXYRkehmFFUa+vrw3d3tnZsSxnMBhImcLm5ma/PxiNRhwneI4pUBiBI9mMEAVh++oiCPyVrjy4e49hmHv37iEo3un3wyCGUUTVTcuxS6XC2sb65ubmdDo9P780bEuRVUVRQBi2LAtF8CRJFE3HcTyXy2EwtL+3fXF2EoZhWhsslUoEgYmi2Gw2U3YbisFRFBEEcXh42Ot1wSjhBfaNt97keTaKAlmWpVwmjuPpdI7j+GA0wTBid3dfXiqdXr9cLvq2E0UhxzHpaO74+LhSLaWUkTRJfH19+ezZC4LAMpls+tYxDMPzvHTolM9nU4+Yqqpr663r6+tU9ARBkKZpMIZiONXtDzmOI0mSJGnDMBqNBsuyruMrinJ1dfXmm98IguDw8LBWq/XanVKxKM8XgiAQBAFBUKGQSwm12Wx2Mh29ePFCkqTZbOY4DkURAACESVwp1waDQbVapyjm66fPSJKuVusEQdA0zfO8LMulUsEwDE1bua7rBX4cRyAA5HISCCaL5Sz03CAIIAgyTVPkM4KQSRJwMZchALz/4ODi7NXu3haIgJPJCMWQbDYDo1AUBfPFLJMRXhy+lCSJYwUYhufzxWg0jMLQtk2KIuqN6nK5zGQE27ZHo5EkSZubm5ZldbtdluXv33vYbrfjGFqtrCgCWo0mSZK6buIYCcXJStEgAIrj2LO9fL7IULRhWDzPi2IJpYqybISRVyrngtD+4MOfjCfdR28cECR8dv6617/6wQ9+5d333nnx4sXr168QBLt756BWq+m6/tnnnz56dO/O3f2j18/+9M/+8OatXZZlwwBSV85iZt+9/eb9g7c///SL0LXGw0GtVtvZ2f34558GQUSQtGU5nCCiGJXLFVAE0zQDQXGWZU175XorFAEGg9Ff+bUfogg+mUwN1fr6669d27pxc08SBMvWWIYwLa3fb/OiQAoCywmKotAMCUHQYjFDEMy2bQKneF6czxfqSheETBjGMIRubq2vtSqvjl48e/b03W+9o+rqbDkrlgurlXx1ffn222/HYZDLS3ASj8cDmiKurvumAbXWdyaTSRTHjWbNNM0PPvhAlKQUwD5bzEmSZFl2sVi4roui+Lvf/JbvuuB37nz/zW+89c1vvmPb9uHh4WyxIEnK87zFQr59587+/v5isbAsK05C27YAIG5fX7quS5KkYRgQEGMYJnCcruskSWYzwsXFBQRBu7u7pxfnV5cdjhfTqncmk0nLWTv7e5ZupHjkTqfz+vXrdGKoqUrkeRxDB0HAMEwQxTRNx1GSyUqeF7iui5M0juMwjM7n835/wPGiZtkMy2dzGVlexHHYaNYPD1/U6/V//I//zx988MHv/M4/N02zUCjZts3QLM/R9XqxVJDCMFQUhSTolFOYPjQ3NjZAEEwn8sVi8caNG4VCYTycoiiKgNB0Og08v16vi4LQ7/conIBgwNB0FEXzUjZ9ZOAUGcbReDpNkqRSq3IM++Lwpe/7J2en9+/f9zzv9elJNpu9d+9eSqpAEKR9dRaG4eb6+sbW5unxCctzKIyk5Pr1zY1uu3N6fkZg+Hg6mU/nGxsbIs+PBgNBEEAYxjA8lR/Ml4uslI/j2PF827Ztz01JrjAMb61tZ7NZQRB8318ul4ZtQUACwrCuKmESh55fr9eHw34ul6tUKt1B/6p9iRI4iuCO48jyyjAMBMZpmg7DuFAoUCTn+77juK7rAgDEULhnrOq1cqmQk8QMhkCTyTjw/VqtxjFsGEePv3wCo4iQyUZJTBDU8ekpSRO8wKorPYjCcrlqmmZ/OCYIwvcD0zT9IIqiyHX9KIqSBPR9t1EvIxBoWRaO42trTYIgNE0Lw5Dn2VqtJmb46+trAABs2+I4LkmSyPd83yVpqtVqLJfLJ199CYBgo9EwTdOynHpzrdvtd7v9SrlKs1y5XMRhBAASGIYpigLBJD0N5HK5xWJRLOURBJHlxWIhK8rS90Mcx3EcBwAgpYoGQSCKfJpoGo1GABBfXl5mJDHtfAEAEMYJCGE4RaZyC1GQWJZNbw8oiqfqhXy+MBgMUuWApqxEXigXi+mqGYZhgsCDILi6uoBhuFqtnpycxHGcL2SHwyFFUbu7u/PlMgzjOI4hCIFAGIZRkqQpkjFNc39/v7XW+LM/+7PFYtZoNDiOefb8a06gVVXRNW1/f1fXtXq93mrUJpMJz/MEQcwmc5qmgyAcDsa2ab333nvaarlS5TAJURTWdJWmScsx9/Z2BsN+NpsVRPHy8tIwzPS3e7FYjIcjBEHyhVylUhqNBtVaGUXRxWKB47jjOKIgGYYFgjBNMcvlkmEEBGG2tnbABEzPKBfnV2evjwv5EoaimUxmMpx4nlerVDudXiaTyeaKz4+uKJqVsqJlaTRD8AKNYtDu7ubV9flPf/ZnaV/6b/72b7Xb7Vqtdnp6+vnnn7/55pvPnz+3bb1YyrEcubZeOzk9JAgsn8/TlEAR0kr2cVRca96cjmfdq0schdNyhmFZMAxjBB7HMUrgCIrWarXJfExTLEFTGIbNFxOOQeqNmqGbF2eXEIRMp/OsmIcB8OjVq0wmU8zlWmu1xXw8HA7KpYIf+5f97q07tx3HQRAojuNcLrtaqYPBYD6f37v3ICvlTdNeLmUMJRiGGw77nm8GoRMEwf/yf/Wf2rb1b/7dv2muNSbT4WolS1l+a2N9Np/6tnX79u0Xz742zTiIOF33BYGzbRvFYARHX79+pWkrXmDlley6Nk6gOEG4nh1FEQxgIpXNcBL4D/6n/1C3zCiKSJKmaZqgSEEQ+r3B0dERzbE8Ly4WM8fxTNvwfS+Xk5I4zGazpVIJhmGRZwWOM01zc73Fcdyrl4evX79OP95CVkbDaWNtvV6vwwii67rrugzP5fP5NCP//OnXR0dHSZK4jhMEQb1ShiEwmxHT9pm8UkEQRBGsWCz+7MOP1tbWAADo9AYpQLTT6flB6AQxCEPNZn047Bumns1mAAAgCAzDsFxeUmTV930cJ0mSzOeLUeDnJc601CiKisViuVRNB1npTP/w8HAwGKRrK4IgMIwAAMBzvG63T2Joo9HwXW84HIqCsLOzo69W6+vrOzs7pmFMJpO7d+82a/XPvvyiXC4Ox6OzszNV1+/dvQvC8NHRUbff8zyvWC5FUZQt5EVR/OyzzwRByEtZnmU832FZ1nFs0zRFUXRd95NPPsnlcs1mc7VazedzhmFc10MQ5M6t27VyxfPd0WiUyWRAGEmSpNfroRgxHA4dzwVBOFvIpzEDQRBazfX5ZBZFkeu6uq5HQEIQhCwvT85Of+37v5LeAWVZXi0Xoihms9nTi/PxdOSFQRKDDMNkMlkcxy3L0TUDACAMw0iSBgHYNE3LspMkwRBYXU5q5TLL0hmBazXrDEnpmuo4TjFf+N3f/V0ExRiOJUmapNnReFqqlmbzies7tuViGJYvlnieD4LIsKzRaMwwzHwh4zi+u7vvOI5pmjtb22cnrwSRT2GZFEWkiw1ZXuTzeZajwzCkKNK27Y2NNUnKFfLZrx5/OZ/PwzgwDMN2zNVqtVguK5WK53nN5tqNW3eOjo4Xc+X+/YcwiliWhSGwbRqGYViWlRaLIAi5urqIY0AQuFRxw/M8TdOmaa5Wq1QSAoJgLpdzHIum6SAIcAKVZVmSJILAXr16JYriN77xDdu2V5ohr9RCqeK6brvddl1PFEWGYRAEYRiGJMnRcGI7Jk2xQegpstqs182VtlqtptM5TZMkSYaRT9N0ksQ8z9u26XkeTdMwAqZiENu2WV50XX86nSrySpJym5vbJEGrqvrq1au1tTXDMMLIv76+LBQKtVoliv3xdMCwZOC7hUKhVCpJkjjqDxAE0XVdFMX5bBZHAIIgJEmuZJXjuFa9cXV1xQjM3bu3S6XChx99cHT88t1333Zdt9vrmJZNUVShUPA8bzwe375913eD6+tL13X9wCkWi65rUxTh+z4EIblcodfrQSCKYcRsuuB5gWMza63tcrU27I+ur683Nzdv3rxp6saw19c0DYURnhcNVaNp2vMdCEQiIGn3e9l8Ll/I0jQ+m080TcFw5G/+zd/6+OOPPvv8FxzHzOdzjuMsy0l344PBoFQqqari+65lmzgOR7EriExrra5rBs/l5KWdy7QatT1DC27uHww67dl4FMcxK7BRHOqG4QduBER7N3YRBJ7OJ7zAXl5f+4GLEwQIxAJHX11dbG/vlkqV9lWbJOhhf1St1j3bUZYyxzCiyLuONZmMFotFlEQgCXEC67ouTVO7u7u8wCqy+uzZs0wm8+abb3U6vSePn8YxwHE8TbEglPR67QQEfvVXf+3t738fSJI//nf/5i9++pONjdZsPrBsneeora0NIIwgCHEsu9ncCSJOli2KImfziaIs/chXVotsNiNk2CgOHdcAgHipLBeLWbtzpS4MPKYFTgIfNR5N5zMAAIqFMo7jc3kpCIJhWI7jZLISSVAJEBM4adhmFAeFQgFBIEEQaIK0bZumCJIkKIK4ffMGDMOfffpzQRBarcb5+bnr+uPJAkExSZIAGGp3O6PRCATBdDq0XC5d14VhGAJACicEQWAoWhT46XSMoujDhw9ZlmdZdqWpuq67jsfy3HK5PD09TyH+o8lMyIgwSsgrJYoix7Hv3bubhkFleUlR1Gq10nWDZVkQhOM4LhUrJIUHjoGhcJqNQRAsTQGFYTgeTeM4rtfr9Xo9jmPHcQzDnM1mnu2QJFnI5XO53GAw6HQ6a2trv/7rvy7w/NOnT6vV6psPH3me5/s+TVKmaZqWcXl5/tlnn03nszu3bqM49uTp0/2bNwRB4AQ+VT8zPPf555+DIIgjaOC5jm3zPK9pKxRFLMvieGa1WrmuSxCE6/gYhmWzOdf1bdvOZIQkjMIgsB0HRVE/it9//30ERV+/PpnNZo7nxjFQrdc3NjZM25rP5ziO+5YbeD6KYxAEeWGAk4TrOtfdzmw8ajQaBwcHV5eXy9nUsiyB423X2d7bhRA4DEPHcaIwwXEcRfEkSSzLhiEUAIDZbDEajWAYjaJoMOjd2Nksl4oCx9IkzjIUlACe60AQ1O/3t7e3S8Xyf////h/CMN7dv3l2fnn/0f3Xx68KpXzaJBgNJ0EUIgi2Wq28IGIYxnHcQqGwvbM3HA4Hg8Faq6XKS4okAACYTCaDQS+KIgxDgiAgSAzHMUmSNrfWFUUhCMwwLNs2WZrxPEfIiJPJhOMZlmWffPUVhmH37j344osvUJwkSVpTzfQW//Dhw+GgM5/PM5lMo9GAIAgAExhCHNdGEaxaq6QZh1QtkCSJ7/uKvEoV3hRFmaaZy+Vw4pfGN8exCoWCaZooCrdarSRJKIoZjqYgCC+Xy9VqlZbRFotFOsMxDKNWbaSPNoLE4ghgGGa90Qz9QFFUlqUrlUqxmC8UCkHo2baFIMh4Mux0OjRNQhA0mUwQFC+UKxzLR1G0XCqeF4iCJAgCDCOLxUIQ+G63e/vOTcsy5vN5kkSL5TRb4HACNjT9+vqaYZidna35dJrL5VIeqrxYGobVbrdRFM1mpJ2dPQIh9vb2dvb3XM8mCOTf/H/+9fOXzzY31/P5/HDYD6I4nXft7e09efIkDOK15noYBEEQGMaqVqstljPPc0EQNAzz1s07rhvynIAgxMnxeRKDnCAWCqUkBpMkcV1XEIRKpcKznK7rtmNqyorjuJPXx61W6/3vfCvwoydffzZedEuV7O7ezmg0ePXqJQQDkiSmY43hcJgqnlAUlzI5WZZN097fvzkajXZ39tqda5om19aal1end+7edF07ny9+9eTZbKLf2HuURNRoIOMoI3L8bDoGACCbzZAknkARBAERENmuvX9jezofFYr56WIKQQBJkkdHhziKYhj28ccfb2/tVsrlMIhBAIjCBIPRTqeHISgAQALL4Tiu62Zro9Gfti/a5/P5nKKovb2dlSpjKLFYLI6Ojr73ve9JUs62Hd8L4xjIZLI0xViWd/jy6Ic//PWD+w+ZgjAfzP7rf/RfWbZ2cO8mRUDqapnPZz3LJXCqmC9mpfJoorp+srGxhmCwYegrddEfdbM5SRTZ+WL68tVzEIqSJC5XitfXl4PuJM+UCJQGf+vd3wyCYKVoKI6lEa5Op0eQZLFYpFjG1MwIiCiKMW2D47hMLktRRDGXh2F4pSyDIPBdZ2tj3Xc9z3cQEGAY5uz09OLi4u7B/cFoBiOobduWY0MoAiGwaZppS9Z13UajUS6WHNPCEJRlWdPQGYZRVaVUKj18+FCWV7Isn5ydttvtW7duqarqBb4sy5ZlQRAUA2A2V2j3+qpmvPvu2998+63r6+vj41eVSqXduSIIzHXdSqVWr9fVla7req1Wr5RLf/Fnf8pzjCAIDMOEYTwej03TZFl2d2d/PB7bth2GIQCAadJusVjI80W1XIEgKBXXYBgmiuKdO3ccx2k210ReGI+n6dzAsqwkCq6vzkPPPT8/d3wvdTktFfmHP/rR5ubmcDx6+uzr6XSayWV1Xc9ms2CcFHJ5FIHSK4jnOb1eF4IghqXCMPQ8L4lBmmZAEE6zQ0kYYRjG0OT6xhYIgo21VrlUTUDgo08+bjabxXLVsqyr9rUsy6ZjUyS93mpZqq4qKymXzeSys9lstpjHYBLHcRyH/X6fpWhVVXmagmHYc1yKofujIYpjBIYzHFvMl1iOswx7Op/BIGQ5Dk1SfhgsZkucIGiKms1mW1sb662myHOmbjiWAUMAjqAIDGEYduPGjfOzi8dfPc3miziOjyczmiFZgb1152aj0RgMBk8eP10ulyRNoSjuR6GmGgzDVKtVCEFkWdY0LfB8GAQkMbO2toZhSL/ft20Tx/Ew8kEQMC19fX0dRWEQBG3bJEm6223TJBXHcRCFV1dXNEPSNH30+jUIwn/jb/yN589f2q4Pw2gUApbluF5QrVaj0G00ajTNrlZy6nVKv7V+v1+v10EQTN0+KYo8n8/jOJmWPEiS1DSN4xgIggaDwaNHD9rttuu69+/fV7XV06dPM5kMTTG27YdRlEQATmJADI6nI101CArPiOLJ6enW5man27VMUxBFgedpin304AFD0WEYpv8cxzEkSSrK8t/+u3/TajXDMHx9/CqbzUqSuFgsavWmqhqW4/E8v76+ydDcdDpdLJZpc9hxHE1TRVHMF7KHhy+iKOh0r8LEFjN0uVgZj8eLxWJ3d5chKVVVaZpeLBa2ZaVrAwxDoiAGACB0k7feeotimZOT44zEIQg0W8zmiynHcUHgvfHmN2zb/qM/+qNyuSxJ0ny+9O2g0WgkSUTRJIqi6+st09Qdx0sScDQcp2CcRn29XKoPhxMQBFmeyedzjUZjOBzOZjOKJliaOT09vnXr1snJCcMwcRwiCKJqCkVRtXp+rnQ++uQn9+8fsCytaVqcRA8e3Lu6uqJptlQqLRfydDrFMKJYLJeKlSdPnpyfX2xv725t7hiGUSgURuMBAESnZ8cwDLZa668Oj0WhtL159/pyHPpoIVca9vrZbLZerTEcg2IwyeBxHC2Ws8lsnJE4RV2ORgNWYHEcLxTzv/jFJydHJ7dv3y4Ucv1+f3NjQ5ZlebFstdYZgpZlLXAjluVv3TyQpPxytsQZ3ArkIHb6/f7x8ZFuqL7vC4KQ7kiiKNrbvbGzs3d5eSUvV7Vaw7Y83wNcP/kbv/W39x/uhyaA0MBqZvz0Z3/6yS/+4ptvPxIYEgRBZSbTNGfI5nVncPPOgayuarUKw9IkSVqO/vLlc8d3bt66QVHY2fmJoioXF2c7u1sQBHAkbyk2BpPgf/W/+C9kWW63OxGQ5PN5FEWnkzlBkbVaDScJ3w2EDC/wmSiKji/O0hZrPptLgGg5m+q6PptOSoX8d779bUVZ/vyTj0ajUSGb3dzcBABwPJdv3r4bx3G33/PDwHKcVInJsmw+n7cM07XtnJSNw0jXdZai9/b25vN5yoY9PjsFQRAAYt/3V5qqqmqhVDRNczAYFItFjuPmS6VQKn3/Bz8cDvudbrvf79u2juM4gkLZbLbZbKIoenR05Hvh7du3J5PZv/7X/3p3ezMKwnw+f+vWLZblR6NRen65vuoMh0MAALPZbGpwTpIk9NxmvXFxfnZycvLgwYNHb7wpSdLR0bFt241G4403v+HY9v/1n/zfO53OG2+8AUHQcNAzlPnWWsPzvGw+BwCAkMlgBB4BCcuyruf1Bv2zszOMJGAYzuVynu3NRpNapQIAAEniLEsLIp+GSlEUpWk6nyuwLGsYlmnaPM8Xi0UYhjmOkeUVhmHf/s53Pvzw46+fP9va2QZBEMHwpSIvFQVFUQiBfT+EQSDL8sP+AIShTC7r+76qa0Ecxkmysbl2enyir1QAAKA44jhuMhoLggBAYBBHvuP7UciQFCcKBIp5YeBa9mgyK+bz9WbT1HXdNFmaTkAwDKNCLgvDoK5qDE1ub6zjGDYZjnAcHw6Hk8ksk8n4YZzNZu8/eDSZTIbT/q1bN1ICvuO5q9VqtphDIBLH8WqleWFAEASOkQzDMAwDw/D56XEUhM1mc319Pe1ehZFvWSaGYYapZTLCaiUDAEAzZK3aGAwGy/mCYTjHs9NAV5IkQRSiKOo4HoYSEQDKSwVFyVKxgpMkhmE72xsMQz179uLJky9RFE9F0wRBhGGYjsh+mfaBYYZh8rmioqwsy+J5LkmSdOlFkuRoPCiXy47jWJZRqVTSuFo2m10uFQhEDMOwDQvGEBRCdMuAEjBbyMEgGESRJIpHx8elQiFKkpUsb2xsmJrpui4EQZtbGyiK9nqdMAxhGNzcWscwdGNjYzQepJEKz3M03URRQjOcQqFw9849GIafP39xenqe1k0mkxFJEr7vEyS2XM4lSeQFJogtQWQYik0teIvFAoOR8Xhcr9cxDINBiKbpKIr2b+x6jn98fPzG/W/ouj4cj/3A1XSlUMjxIgcAiaIoj5980Wytv/POO+12++jo6N13381kpNcvT1aKpqyWBIF5nvfo0QOKosbjse+HgZ+0mhvzmaoo2o39u+VSneOpFy8fzxeTTFbyPAcAgDD0s9nsdDZGEATD0CiKeJ4tlktHR4cURdWbhf39+i8+/SABYp5nLcuiKKJWr/T7/VevXlWrVZ4TAQAql6ur1cp1vN///d9HMWR/78a7735rMpktFwoIgspq6XlOv9/9wQ9+UC7X/9W//HeOBX33/b8S+FAYACkbB4EgWZVt28xkMgxDmY6h69p8PgVhYLGcpVZ3kiRUVUVgEMOw73zn2zRDAACwWMziMEqSRFWNNx69QyC0Ihu97uT8rA3GKEEjTjxPIA8AgGqtLMuy77tpIS6bzT579oIgiDff+AaOkxAE8zzfaY8OX12sre/86K/+xt7BzqxvkyTJFcAnnz77t//2d4slIStyCIL4lt+oryceiFO0lBNfHD6fzWaD8YBhmHwhOxgMXM/r9TvVeh2CwdQmVqtVrq+vV0uZo1jf9cDffud/4jgewzBr6+sMwyjKyvM8Pwp5ng/CGEwAiqEdx3E8l+EEeaUsZnMAAHzXDjyXpmnT0NeadYFjZ/MJTZA8z4mC0Gg0Vooqa2an259Op6VqpVQpX3faC1ne2NpsNBpxGKmKYuoGTVIczSRJkmrsWZYlSRJF0U6/xzC/9LIWSsWrq4tytQIjYLvdZhiG53lVN8uVRqla+ef/z99ZKIv7B3eqjWocBBvbGwgELWSZoSjHCy7Pzi/b7TgI6/UmDELpL60oigzDpdcRCIJ+9tMPM5kMTTOe56mqHkVRPp9vVGuDfufm/o1isVir1c4vLg3DsG13fXPjjUdv/dEf/REMo24QXF5eYjjOUCxD4VmOQIDIcZz9/X2KomAU0Qzjpx/8bDKfSZIkiOJKU3meR3AMw7DZeHZj5wYMgNPplOVoGAaz2cx0NgnDEMMwQRAK+SLPiyAIJzEoimI6YfAD98svv+RFMZvNX1xdHh2//vZ3vrNYLBV1paiqYZmmaVMUtbe3t7ez+/Of/jQOI9O23MCnGJrleZImEQRRVksMw2iSonCi3+tIghgFIcMwnMCvVqteb3B5eblYLGiaXl9fr9frtm3jOJrJZCEISGn4YRiOx1M/jCeTKQAkxXxW5DmOZVmKhEAQjJMgCCqVGi+K5XK12Vx7+vWz3/u936V5cnd3Ow0m1hp10zTPLs7DMEzxQRdXbUVR1tfXUyvn9sZm6EcnJyfz+ZzjmEKhwHJ0ksSOawVBQJJ4EHhxEqbPryiKlstlXiqQJA0hYLreT28YIAhrqoGieJQAnheYhmuaVkbK7d/YxVHUca2zszNd1zmOG4+m0+m0XC5vbGzYtu15PsexHMfbtuW6Hk3Tk8lM13UMwzRN8zwPQaBSqeT7nuf56SJ6Kc9pit2/ses6vud5PPPLfnWKOGVZ1nVd27Ydx8FwtNVqpR0ICIJmsxkMwzTBJkni+y7P82EYzhezJImCwKtUKggKcRzruq4fuDRNB4Fn264sGzhF85yIYZiuG+Px2DTtdMq6WCxqtcrt27eW8hwA4slkguGgKHEUjV9fXuVyuZs3bz1//jz0/FRZCsMwCAAEQei61mq1CAzXNL2Uq3Q6HUVT19dbr45e2I7J8gxFEYVCwbLMTq+7sbHx8OGjV69e5XI5MIFogj86OuJ5HgQBz3fSvp6iKJbpkARDEvz21o2MWJCkgsDnvvjy57PF1edffATCUDaXabVa4/Foba3ZXGtUKpWN7Y1PP/30y8dfbG1t4SSWJMnx6xc4Ft2+tX99fY3j6Gw2qdWrsryAIODFixdXV1f7+zdZlr179x6G4qqqqtqqP7iIooimeI7LHL8+2d+/aRja/v4+CAGWZSEwalvhbKqqKweI8Xy+mCTRZDKZTiayLKezgXyhQFJ4uqOWslmCxBZzuVwu246JYVghL+E4+vr4cGNjDcMhQWARGH7x/KUkFQIf+OrzF44NZDOVXLa6sb5v+5rlj1RjGsXBgwcPFGXpea7ruo7j5POFdO5CUdT62mYQRJPJdDie2lZg2wmG0iQtSJkCy7KGrbqelsuxCBqxJIaiqGf6Wank6D7L89PFqN291HW93+/TNL2+tRmGMUVRju2JUsa2XctxTk5OWJZnGKZZr9IMupzPwf/mP/nP5eXKcZwYBNLqLARBIASxLGs6DhgnfhQOBgMAhFXNUA3d0g2CIEAgLhRy9+/d4xkmIwkYAmsrmWe5+w/uCRz/xRef/emf/sSPEs2wqvVaqVKZzKaWY99/9PCdd955+vSpoiiSIGII2ut0gThmaWa10uIk2dvbj+Po6urq5dHL1NSKYrCYyczmk3w+z/Oc47me57mui+NEpzf6oz/+44cP7v1nf//vaerq/PKsXCxRDHl+egZAIBAn7W7P0PQwSqaTCQTC9+7dq9frqqq/fPnS84JisQgkkCzLpmnRNJ16adILPgJj2YywvbF268YeL4qiKJ6cndMUc93pLhaLKEyePn/xzjvv7u3vK4rqhYFt2AQC3NxuTftdx3G8wDdNc75cyKvV65PjW3fvmKaJoKhm6IVCIZvNClLGsz0Ko33HRRCWG7aHAABHwklEQVQ4IwlxHEIQUCwVNjc3j4+PYRj2vSBJQIKgojBxXQ+GYRRFbNsO4qharc7nC9OyeoO+6diCkJnN5xTLZPO5MIhRHGMYxvec5XhcLZRUXev0e0EUwijKi3xzrTWdjhfzuee4Asu5jpXLSGvNlu/7iqLOZjPbtiUpJXZhruumHqtCMQeByFKeIwhSqVSCIGh3euV6q9frkzheq5Q8x7ZMs5jLlsvlQj6PYRgMoZeXl0kCLpbKV189bTYbk8WIZekUA85wbNqnJQjCcmye5yaTqeM4xXJZVVVVVbc2NhiSNXR9Mpm4riuKIknilmWalt5qNQgCM00TJ1DXdcvlUpo0Gw4miqIWSkVRFG3bJAgik81RFPXs6xc7O3sQgsryStdsXTf8IEIQZDob1+u1TCbjeV4URQRBOo4zm8329vaCILAtFwBjGEJVTTF0C0XR6XSeVi583wdBcLmcMwwDI2AhXxqNBxRFgSBAUXQcR6PROJ/N4QjarLcYhkkZ4GEY+r4fx6HneakmGsfxxXJeLBbTIUyGzwqCYFmW41pxHEMQCILJeDKkKIphqMVijqJorV5JkgSCAF7MYBijm+5kMl2tVizLl8tlGEJVVUUxWNM0UeQfPLi/UmWGoWaz2Wef/3xrZ10UeUWWXdc9uHv/+vp6PBizLJvNZnu9nrycVyoVGAYJgljM5rpugjGYJEkMxnt7O4ViDsNQ3VodHr5oNpu//uu/3u52zs7O0jBFHMcQACch7Nr25uYmxzEAkMxms0qlwrKcLK/KpbrvJZVyU+ALK8WAIUI3Fo+f/wVOxqalP3nypN5o+IFbKOVJkigW8wmULJVFu3ONYZhmaunScTlZ8iy3UpVyuXh+fjoYdqIoLJby6Yh4a2sjipLZbKbIqmVZlVq2WGYZFv/pX3z813/8N+WldnJydv/+/X6/P5mMoigaDse3bx0IfP7stEMSnGU54/GQpAlJzP4lPAOCIN8L19bWarU6CMIYhimy2mq1aJq1Hf3rp48pGsFxpN25MC3t1q2984tTimSy2WLgQQyd21i7kZOavgtPxsp1+0R3O9t7dQgGut3udDq+cWNfEISPPv7AdfxKpdLt9gzDKhUrEAQBAISRRBIDnh/bbqSpDoGzJE0hCNBolhkW8APr5NVLwzCWE4XAWRplYxAolvMJEDQajTBKQBCmadbQTV7Mua6/Ug3H8aRMDoZR3w/k5cqPnUyWjBIP/N1/9M9SXfh4PE6SZG1tTVEUkqRJkuz1+4qyWq6U4XBYKJY13YQxlKOZjCjatslQ9N3bNxmGpinC9/3ZeNLrdzY3NyVJev36NQRBFEVBCMay7MnZaafX++EPf7i2sf7v//2/932/0Whks1kURlRVPz8/Db1wc2u9XC7nctLFxcXZ2UkYhjfv3LYMvT8cZjKZ/Ru7hUJB0zSCwh3Hefz48WS86PaG9x+9sbu7vVjMOI6LkwgAgNVKRhBkNBpFURRFSRRFs9nMdbx3vvnNJEm2t7eTGDw+Pk5LrTCMAgDAsXy/3z8+PmVZdmdnx7ZtFMHf+sYbOSkDI1D60w6HQ54Tvvrqq5cvX5mmGSdgqVQCYOidd9575713j46OOhcX+QxdymWLxeIf/uEfDsfjfD5fqVUpltE0bTKd4jiu6hoMw1EUMTyHQigCoMVicW9727CtJAq80GvW6iACfvzxxzhOKoqiaybPixzH0zSdy+VkeSnLC4ZjCYJAMPyjjz46Pb9YrVZBEGVzuQdvvMnz/HAwZji2UCgsFzMoCEqFoqKuJvNZFMcLZYGTxMOHD1AUbbfbJEFkeG48Gl1fXD569AgEwdlsFsdxNpvf2trIZDKKovT7fVVVq9Vy6tshSVIQuSiKQBAUBanfH/M8z9KMoiwNXW3VG4VCTpHlNFdu6JZhGCAIe17geV65WkqQ2LRNHMdxHA2CIA3Rm6YZRn4qYisUCmEcm6aJ47jI87tbN6rVmqqqJycnmqY5jr1SZcdxIAiAIEAURRiGG82aqqqu61iWvZgqg+7grW++w7DUYrHASWI2XbiuS1F0NlfQdTMIIoEXEZxI27y2a/V63WKxWCyWZrMZBCL5fN40zXQOaZomCILZXCYtYcURMB3PCIISRdGyDIIgZvNJNpvJ5XJBEIRh4Hne22+/LYrip59+6lhWRpRevzqiCJogiNQqrKrqfD4PQi+dI3U6XYoiGYbJZATH8VAUDaM4/T9pNBqSJEVxiKKw53nXVxe2bZIkubu7G0UhAAA7u1um5WSlkmaYZ6fnL168WK4UQRAkSYIQOJ/PLZfL2WQ6X0yTJNnf3/3BD37wB3/w+91eJ5eTWvXGixcvMplMvd5Mb06VUjmKg36/v1rJuq63Wi2apFAUjdxwd3cXQkDPd9bXW47vhpF/ePTyzp1bJEleXl/5vk+SpChJtmlWyo1irkoRtCzLKbIlm81CINZoNH0/pEguiaHVUmOZzNVl96uvnt492JvIlxgJjAb9n3/28fb25njSx0k0X8go2kpWZrfv3kIQKFXi9IZ9QzXXa9tXF9eVWlVVFVleIijw1378H3397GmhkENR+PryXBAyy4WSyxXWW2sIGq9tZn/x6YcPHjzSVDObKcxncpKAHCuMx+MgiGiaQVA8I+YNw75ud1ut9U8++vju3Xs7OzuWaS/nMk2zDMOZhtXp9FCMIElya2unUCicn18UCoVerz2d9i/Pj/L5HMNSo1HPtPR33nlbUVa7W7deHZ1VShutxo4olBGIbndHlq1cdB+zIlwqlfr97osXz8eT4Y29fcuyzs8vCYIgCapSqZEkjWNkoVAEAGAmL4ulGssKGM51On3DMPJ56er6JIltFAMuzk8fHNxLIkhZqAWpEgSBmGdiINrY2PCDaDpZjMfTbmcgZnP3Dh5dXXd03RL4DEEQg/FkPpnanpnA1vpGHfyH/8l/WcxlOZYhcWyt3ghDX14sytX6eDz+/IvHs9k8TGLbcv0warZaa5sbo0HP1I1ivsDSNI7jlqFfXFzkcjkv8JtrG2EcAQBw8/aty8vz64szBAJ4lkuZ17quf/XVV1EUfetb7/tB0O/35/KSYblMLlNvtm7u75wcPu33rlEU5Tgmn88DEKgsV5VadTabpbCEi4sLHMcJgiiVSn/wR3+aJGi+WAGA+C+xWenfvby8bLVahmFcXl6Px+NcLocgyJ1bN09eHZEkzjDMs2fPCIJyXffo+Phv//bfrjVaJycnnuc3m02KZGRZXshLy7K292/cv3+/2WwuZpPL8wvfc85PTnLZLIqihqXrui5KUqPVDMNwpakkiYd+YDtmuVwGQZDn+e3t7YW8vLy87Ha7zWaz2+3evns39YNHUXRydMKzme9973tAnFy1rzOCKGRE13ZgFDk/Py8UCsvl0jTNRr2JIMhqtaJYCkEAGIOHw7Gu64uFrGkaDKFXV9emad+5fRDHgOM4AADSNN1srAFgDMbx0dGhKIqNRuPi+ur0/CSda3McR9FESihaW1uzTXM4HCZJguLYbDajKJph6NlslrqXYRje29ubTqfpctJ13evr68ViQaJINV+MvcCyLFVTwjAUBCFJkslkUigUfvnedV2GYXwvZBlm99aOBXhn16cQBD14cC+O4yRJ5MU8CAKeZxEYZhgKQRDXslMmeaFQCkKkWm2ura1pmvbFF1+021dxHAdBwHCs5zkMw6Q9uCAIVqvVrd2baIyUi5VOp3d1dcXyXBiGtm0Xy2UcJy3LiqKY43nH8WIgEQRB0zRWYJfLpW3bEIRAEAQkUApqj+N4c3NTVhaj0WBvb1dRFD9wgQRiSUFVtCD01taauq6GUeD7bi6XazXrrVZrMBjAMLyYy51Op1QoDAaD2XRpGEalUlFVNcUcjUaj/f09GIZdz27UW9s7m6Zpsix9dHR8cnbWWl8bjMYoiqZrMJalV6sVwzCe42raCsMwlmU3NjZStt1iPj87vQqC0DB0EIaCyBckQVFlKZ+zbSuXy6nyisQJhuEmw9H9+/e1lXpxeYYhKE7iadX8xz/+ca/XOzo6QmAwjeoTBLa5uTkaDer1+u72dmC7F+fnfhBYtpHN5+Mk6vTatw9uG5auKDKCoXEcBnG0kOcszSiyYetBsVgtV5uGbh4dnbpOcGvvzv7+Ld8NTo7P+v0hDEIMRSVJEocRSWO7t3bXt5px5I5n/UazEAPO/+6//AcAGBSKYqNRtX3z5s2b6S7H8zzX8TGILhRKK83wAh8Ek96oo5sqL1D9QTuKPde2Qy8gCf7Rgzc3W9uvj18WyvR41EUQhMBw23B2d26qih4GEBDjJMnACKabNi9yp+cnCZSsN9cFUmpf9obD8d27ByhGrFbavYOHDMN1u93xdD4cDhEEgiAoCIIwCeazMRB7GAq+ePHi7bfevn37dj5byOcKKErCIKIb9pdfPr+8bKM4Xas2cYK67Jw8f/1hAtiPHj1aqcrLly8bjVq5WPJ9P5PJFoslUzMhENnZ3ve8YDyc8IKk6NZSXmWzeVU3+v2+HwY4ju3sbo1HvSQMHj64j8JIMZcncRIBkSDxvcSaK1PfC13XH49mmmm5jr9UlPls6bquZVkkQ2ez2av2Jc9yQWijSLizuwke//yiWi5Ox6PnTx87lu1YBs9yr0+O29fdu/fvESQzHA7PLzv1ZqNSrSq6AgPgg3v3eZbrXF+rymq5XOZyuUqtaljOeDZ1XZfkuGq1iiCQqS1Leemzn/9iZ2ubIKj/1+/8M1EU33nnnZOTs/5ouJSV+lrr1p3bCIljBLGxXpv2LkSBAhPg5atDXdWyuQIMQYIo4hiG4UTnus0JfOhHlmNfX14xrAihlKpbLMumcTQMw9JCSqfTKRQKPM+3220cx7e3tzVNOz56lQS+59qr1erBgweeG8xms/fe+zaMIjvbe4qiJEkCw8h4PL5sXyuy6vre+u7+u9/6VqvRqJZLQBgEvjvsdl3LrNUrg9Ho5PS1rCh8RuBFIQgCx3Nb6xs8z9dqtYuLi1evXsEwnCRJHMccx6XHunSwSBDEYDDgeXHYGd25c+fzz7549uzZd7/73Z2dnTQgVCgVZ7PZq1evVFUVBMG2bV3XxWyGE8nj49cIgkqS1OsNoijKZYrX120YgBv11tnZBYqid27dWSwWluWsra1dXJ3Ztum6PggmFMvwPB/HcRo/KBQKOEEgKEQQRCrMAQAgiKI4jhEEKRaL9Xo93XdFUaQoymw28zyP5/l0hTsajVzTrOfzvm3RNJ1yykzb5nlekqTxeLxcLne3tyuVSq/XQxCkVqnqrqmGOoAms9kMx7E4jquVUrVanYwGw+HQscxGo9GoVTVNt20rk8nQFPeLnz9579vfSzHd6VM+VYrfuHEj5YC6rptC2W7cuFEv1RIXuDq9PDs7S5Ikny/QLJPJZlut1uPHjwEIBEEYgKDpdOq6bqVSAWFIUWVBygRBxLJsPlc8OzvrdHqNRsOyDAAAMBxJRxnKasnzbORHmmJlBMk0dQxHisUCQWD9QdeyDDCJRVFcKerV1VUUxFtbW5ubmwiCzedLTdVT/ivDMAcHB7V6VVVVgsC+/vrrW7duMQzzyScfLRYLlmXllbKyrFqzkcvlUBT1PM80TUs3lsulKIo0TVdK5RT6tFqtOp2ObVpgDHIsW6oUgzgAEMDx3TAOCuWCoiiGYXA0F4dJ5IembrA012g0Op0OTdM4jlYqlaOjo/v37/u+B8NwFAfHx8eCwKWho9VqxXJ0hhcSP86IIgyDURI/ffoVRmJBFJbLeU4UCIqYL6bdfoegqE6vTVHUzta+vNQjD4AQIggSy/RJgkEAYjqdVUuNYrGoaxoAxBAQMxT17fffu3HzZgKj4+mEIGGCBL9+/qmqzebLHgj5K3UOQhGCggRB5PN5TdMmkwmK4IZmDfqTu/fu5QqFQqm4MpSffvCTje0mw+I0hWEIrK/0nFTKCkVTc2u1iqyNxpNeEoU8xxmq0apvABFsGWGp2JzOVRjBMYKaLycQjmQkBgZgLCGBCJHnMkZQUQhEUVIq1mzbLpYr3/jWt/75P/2nh69ekCRp2+bm9sZo2PM9rVmvISBi2042U5DELApi0+m80x5QLIsTDM1w8/n8utPlBD6T5w1nDEAOTdM8z3IsqyiKpqnr6+uhF82mC1XVry47i5ly+9YdjhM++fgzScqRJEVSFCcKxWJxfXM9V8hrpjabza6uLpr1Os+zG2vrkpiBYdi0tJ/89I/2bm7nc0VZXvlhks8Xl/Lq8ePHJyenuq5rmirlpSgKADDOZqUgdDAoXltvgj/93Q96nfbJ61emqmRE0XVtyzArlYpp2kJGnC8UlmXb3SEEwwAOMTyzubZezBemk0kURRuttSiKgiCYz+eT2UKzDJ7ndduZz+dbWxvfe/+9gzu3//AP/7DX6V5fXmor9fvf/8Hx8TEIQPVmozcaPn/5IpPL37x1KwKS6bj3w++/12yUERA6fH0UB2GpWvVsRzON2XiCEZSuquVqddgblqqVUX/ghRFFCQCEapr2+PHjnZ2d6+vrdJ1oWRbP841G4+XLl6IoHhwcWJb1e//jv/jW228FoW9ZVr1eV1daJpP5wQ9+2B30HdvTdd1xHNt2TdMEAADDcD8KLS/c2tnTVbWYz8FJnMQhEEWaqjSb9fl8vlJlPwhgDOVFgWHoMI7klUrTrCRJk8lkPB6nfR8URZfLZRzHjx49Go1GOzs7CIKcnZ01m2scwTUajZcvX52cvL5z506z2Vwqcloc1XV9PBmtVivLcVarVRRFGUlYyHPPc1JP5y/TSiGUz+efPv06DOPQ89fXNvP5Yr/flxdyFIXVeqVULsAoHsUBDMO2bQMAUCjkCIKI43i+XBiGLklSJpNJg6cYhmEY1u12ZVkulUqpbMt13Ww2G4ZhisFJK9xhGEZBWMxKCPxLwZOqqgRJlstlnudNw/hLI8JyNv+lfT4J2TwLwPFqtSqVSnEct68us9lsr9uGIKhaKoqiOJ2MLi+vcRzN5XJADL94drKzfSMMwyAI9vf306lUHMez2axer+u6zjBMNpNJkoQgiOV82bvolXOl9fV1lucwFGcFfr5cPHnyZLaY53I5SZJwkpxO54ZlNhoNimFm8qzaaqwUbbValcvV1BWcCkpt2zZNPV/I+r4XBB5J4RAAR04icOJoNFA15dGjhwSBXbcvZXmBwhBJkmut9cFgQBDUwcGB4zgUxeAYybLcdDrN5XIMw8RxTJLEkydPPN8xDANF0adPnxqGliRJrVbjM6Lt+YVyiSCINKDZ6/V0Xb+8vKQoKggCgiAsy3IsO45jz/NYmhFZzvfdjCQoqiLmM/PlTJYXjv9LvFUhmxM4MfQjDCWAKKlWq1N5gWHYxcUFwzCquvprf+2vZbNZRVE++vBnKchvuVxq2gpBEFPXb9y4QSJYkiS6oQIA0O/3aI5OQOD5868evvlGpVbR9NX55dmtW7cYnjEMQ9f1DCt6XkDgtO/FmmrnciWaYLudIY7ghUKh3+vlchIKJ2dnp4LIQQh+1Z5OZvNGo3L/4c3DV19JOeY3f/xXypXcF1/+fDYfTWejw8PDH/3oR5ubm7/4xS8+//zzjbV1z3ZcP0IwtLW+Vm1UbdeUlQmKQSSFrmTl/t37LCWulmYhW37+8mW1UTQs1XUsjmVcy6lW6hTBX5x3kgirlNdQjGqurcMoEoLhxcVZkiTqXM1wkmt784VsWa7nBo7jua6flXL37h9YjhPFAQAAl5fnPM+/9Y2Hx0dfa7oq8kK/00NhwrE9U7en0/m9g0cYTsAwmpFyEQDqhiGKIsFgvISOJ73xeEySOAiCy+XCdRzP8zTVtG13Y32L5zJfffnV9XWvXmus1RuQHzZqNYph8qXcaDZt93v5SikEQjcMbM++9+A+gsGpmrdYLOZzGUNezKeTMAxrtTrN8t1ufzKe4TihqmoQBIah54u5yXSUzWYYhnYdgyYxCAbAG5l9HIXr5fLd23fyOWk2m2ytb4Rh2O8PDdtRVxon8EkCoiQhFKW5vDx9fXx2dsbSzF/94Q/ffvttz/M++/kvOv2eHwTlaqXaaK5Wq16/n81lJFHEcARKAM9x4zB666231tY2/vzP/zybzQ1Ho+cvXzi+t3/jVq5YUHXNtvS1WsZzTcswYyCplMqlclXgeFHKOJYbA4nA8YdHr18+fxElMUPRK1Xv9SeFQgkEwVevXlUqlU6nUywWd3d3V6tVt9ut1WqiKAIAMJvNgiBAYUgUmPX1tZTFFsdJHMe5XI6kmBv7+wiKIhCq6tp4OJot5t1u/+ziXLf8h2++IbAcSeKDTpci8Bv7+zubm4Vi7tmzp/P5HERAwzK9wOc4liDI8XRu23bqNJYkqVgsgiBo2zZJkhzH6bqO4/jBwcFisVBVFYZRbaEJQiaXyymK0ul0SBIHIPDs7IxlWZqhoiiSVyvXdREUisLEdi2KJizLWCxk13Xfeeedcqn67OuvAz8iCKLfHyxnc9/3HccTRXF7c4flGYqioigAYIRlaRRFFUXRdR1FkdSsK2REx7FSEkbKjAuCIJ8vqqra6XQgCGJZNn27syzLsiwMwyn4LCULRVFAkFiKnQg8P45jlmXT2cJ0NN7Z2UkzhQgEz2YzwzBK1eLmzsbZxfFiPqdpEobRJ0++pAkyisNCLv/d775//Pr1Rx99VCqVwjCcTsfb67v3D964uuzatp1WN3Actw2z3++DAIDjeDabnU6noR+IoqiqKkPS3/vWr6iKxnHc+sZGNpuzPffk9PTZyxcvXrzIZCWapmmWsSzLtO1sNo+TmGwbxXIpI2bH4/FiIW9ublYqlclkcnh4uLbWPL845Ti2VqskQHR+fg6DCA6SGIKSFA6CwPp6S1YWURRQFIVA4Gw2K+SLpmmSJC1JUrfbpSim2VhrtdY++eSTIAiq1aosy9vbWwcHB//k//Z/4ThO07SLi4t79+5ubm6iKMoK/MV1u1gpp6jR+WQ6mUxSRreiKCmB0fM8GITSoCrLUALNOpYRxOFCnrc2WkKGVzVFVhSSJKvVar874BjWtdxsNl+vNoIovHHnzqeff/b48eObN29iGKqrmuu6q9VquZhtb2+jKCxJEorCrusuZrP7B/dM01wulxgCPX/5kiDxKAkPDg4sS/vZRx8Wivmtnc3JZAQAAC9yEARdXl5KgggAwFp9A8eo4XBKkez25h6OkYKQQSH4xYsXlqmLGTYFWS9l3XJgihNgKAKRaDRsW94ql2VxCtzcaOIUSuLYdD5haHq+WAAxeO/+nYuTo3wh2+uOev0hTpE7O1s0S338iw9kZV6vVkzdKJUq7YuebXp/5Vd/dHR6BhNYrVGlKTxJoqvLcxIjtzZ35zN1b/sgl6vMFioE4xAC93qdr198zbJsTsjalqXMldF0GnlJEEQ4Tu7t7QEJCEHQ5s42SRKLxWI0HrTb7TB033v3zX6/zVAsTdNZMc/SbK3WgCHUshzLdkejcRAlAATbrhtFkaLK3/2V9wxjNRz10+aQ6zp3b98pFkuHL4+6/UEcJo3mek7Kh1FCknQxK9WK2cVsulwuSZpQDK03GsI46viOaVnj2bhSq9I0fXz8utvtEjiOI/B33v+Wa5v93lBVVYyk4ggAQSiXywFRnC3kgDgEwUTTVziOBYEXRr6qrILAA/+P/+l/jaPw61evhoNBLiftbm37rueHAUFQumUyNAtBUD5fjBFIttTrfuf1q6PA8/b29nJSdjweK4ry+vVRqVQuFAoszwVRLAhCqVLWNDWtOHEMK4rig3v3bt26FQYRBEH/4T/8h8v29XS2qNRr9WZjsVxaltOol1DQN7SFbVokTQFxoupGs954+MYjmmSu220IBHv9IUszf/7Tv2hfXYuSZOiObdv37t1jWfbx48cIgjx48CBJkuvr6ziOGYap1Woper7X67VaDQJH9vZ3nj17ViqVBD7z4YcfZrPZrZ0dXdUKpWIuk19p6vXl1WQ2nc+Xg/GoVG2VKuWdre1cRlJkGYOhyWiMYyiOo8NRn6Ko1toazZAgDIEgYLve9XUHhtGUroVhGARBKIqmVQOKov74j/9YEIR8Pj+ZTIIgABJof2vf8wJJknRdffHiBYIgoiQMBgOaY1KFkO2YmUwmm5dsyx1PhjhGyqpcrdYBAADjJI2f27YtL5e5bCH0/XRqb5qmZVmtVqvT6RiWhWF4HEeu65ZKpUwmM1+koRE6m82mzvHBYJDCZ1hOKJfLhUJB13VVVQuFQnrodhxHFEUMw2zbTo+iAABYroMRqLxa8jy/3lpLo4fz2UzXdYak0mp3HMeWYaS6CFEURZFbqTIQJ0dHh4KQKRRy2YzE8YzjOF9++SWOoK1WM0kSkiQBALg8v+QZaTyYggCQWlDiOA5cT1GUZr3RaDTu3z1ot9svX74kSXJ9be3dd75FwGQUxedXl4vFYnNzs95oXF5fPX761cXVBZ8RKYqq1moMw8grxTDMpark6pWrXgfHiFarVSiUcrncYiF/+umnDx7cQxDkj/7oD2RlKQgcw1BRFK23WgRAjocTMcOHYWBZhmnpDx/ebzab19dXw+HQMEwYhkVRIknSNOwgCCAIeeONN33fl2XZ87yTkxMURb773e+qqpKCnXO5XBB6HMfJsuw4TgQkoigWi0VZlg3DQBBEUZS/nMKlVA8EQViWBUGQZ7lWtSxwzFJRzi5ONVNb31pLrZayLLdaLU3TSYyaT+YEjkuCFIEQyXO6aSZATBCEoiif/+LTZrMuiuLV5SUMwxmB/zt/5+/Yhnl1dYVjWBzHz549BWHo0YP73X6vVCpOl1NRFO/cufHBBx90uu1msw7DoOu60/kEwzApk9nb3jk+PvWdiCDI5UIFEnh7Y7tSafi+f+vGTZ5nn339VRQFm1sbtm26XhgDDM1nECiWtTlNwsNp74vPP5wuRndv7zM8s5zPStUSQxGKqkIJVKkWbHM2HY/q9VZ/MLIcr1KpjKcjjmf6/Q7LsqIgvHh+6Nlho74hcvl33//uF0+/dkLX1Fc8R8VxaBpGsVC1TLdaXL/ujGCQ8vxosVRHoxFBE3ESZjgWQRCaYEAY8d2gfd2dTqfVak1V9UKh4Fp2q9WIomi+mLVaLUWZsyLFcrSlG6VCWdf1rCjduX2QJMnFxRWKkyTNlKs1PwzanV4KJwaSSOSFZ8+e+b4XROHPf/7zjY2Nv/t3/26xWPr9/+8fnh6f8YK0vblzcO9BkiS/+OKT6npJ0eZJkqjKCkGQfCE7m82G/cGw1x902jAAbjSbYJyQGJ7hhRBIHDB4+OYbGEZ0Oh0URauVWnpWuL663NzegkHg6vqCZWnTNDzfEQTh8MVLeaWA//v/2T/0XVdeLFAUzUpiuVxWFsu1tbVyrf7pp5/CCMowjCBkvvjqywBJQiDRNM3UjWw2G4dhyqWJw4ikKYIgoijqDroMw9y4edOyrPOr62q1CsMwz/MMSdVqtTt37pqm+Qd/8Ad37twBIOTk7FRZrVAUpVhOElk4dmEo8mwPxlB9pbZ73VxGam1s7m3vfP3iuSRkYgBoX121u904iPf395METOcJrVbr448/zuVyrVYLQRAcxymKSplcgiAUCoXXr18TBBZDkaatFEWhKIrjhCAIWIpuNBoAAKZhx+l0ulwuKYrKSnkIRSbz1WQ2r5TKOzs7xXy2Wq588elng8GgtdZstRprzVYYB5PpaD6fj6bjfm+QJKAoSq7rhmFoGEZK8pEk6fz8HMfx+XzearXK5XI2mw2CYGdzh8To6XTe6XRWq1Ucx0HgBZGPIAjNMUEQmJaOoGg2l0mL0zAMYwTV7/fTwShNkH+ZVCEJQtNWGIwgCJKOejRNEwTh7PJKVdU0LTMajXI5aXt7OwxDjuN6vY7neVI2Q5F0AsSe5xm6yXFCnIA0Teu6PhwOUwzOYDAoFAqSJKXT/8lkkvojs4XscDEGYUjkBZZlQ893bUfXdUWW/9bf+lvyfHFychJ4frVaTQWfDEVBcYJicF7Kfv75pwAAbW1tYCi6ttZcrTTLMhbTGcuym5ubsiwfHR15XvDWG29Xy1V5vkiVO47j2KZVKBQIBN3a2uJZjiCI4XBoWdb9uwc0zRq64zhuWsNeLBYvDw9xknjnW++VKiUAhhRFISmKYZiVplqWpTrWP/mdf1qsVRAYdRwnHan5vk8QRLlc1rSV49rNZt33XT9wa7VarVyjYOrxF48dx4ZhEEbAVquxv7+v67ph6L7vn59f6LoOAFAYhmEQdzqdMEwIgmi1Wp7nWZZFUVSKRqjXqzRNoygKw/BkOmIYZrVaSdlsPp//+OefpH8yZeVqmlYsFg3DWK1WSZKkVLhULgQk0f72Ns+zw+Hw5dHLs7OTYrlk2YYgCOVy2fO87a3dwAtH/VEYhqqi3Xtw/8PPPwNhKIpCRVF2trdZli1kpV6vR1PU+vp6t32dyWS61+2vvvqK57jFYqGbGi+K9w/ulGtVnudMS//www+3t9cLhcJkOvZ9NyXNzeaTyWRya/+Wabij4RQGsXqtwfMiGMMERrIMl9IvSuVip3MNgsndg9sYhtTqawwnXbe7FI3DcCJmWMNUOt0LWZlNpsNbt/Zm84nw/weohGHY617sbpfnizGKkLKiTadLdaW7gb+9vSlm+CgK1pvrAADZhh/4iWl4+UIFJKnnR4ftq9NsTtjZXhuPx0kEMLQ4n2m66hGk4HsAz2XG0wlJkiiKSJLI0KTneZbleG7gui4CITiOLxZyo9FYTGdJkmxsrAVBEIR+uVwsVvJRHBy9PGy1WlcXl1dXVynr+/vf/z5OUH4UZ7ISx4teGBiG0ev2j1+ehH7QbndhGCRpqt1uwzB8cHDwq7/2AxTBHMcb9EeKouIUGcfJeDF8cvgZTqI7OzuKoizmU4ZhIj8QeaGUy3IUDQNJtVCCwjifzbYaTV7KLAx1riqdTk9V1ZRWm8/lRFH8D//hT4rFfBzHT7/6IpvNOq4NA0mpWvnzn/zM9Rzw//G//cfqakXT9HvvvbfRWqMoCkDRl0+fdjrd09NTCMHSxN7Z9blYzMA4RlGUpRuZTLZSKqc3gBt7e+eXl5ZteJ7nunYQBKapIxi+sbOLoUQUReVy+eunTy8vL2/euHVxcYHimCiKqqovlktRFLOFPMcJGYFxLAWIg/FwgmIYyzBxkhTyeYblPvrgw0qt+vf/s38AIfB/8Z//Q8MyWZpLV740TacYH1mWeZ5HEGRra2t3d/fZs2f9fh8AgFTc4ThOq9VwPKvduWJZNhWB3blzx9B0GIYXC1nX9SRJUuUThmE8JyAYulRM07IJgqiUyq7r1ioVgiAogtzc3FxfX4tD/8nXT46ODpfLpWWbruM5TkAS9HQ6TdEx4/GYpmlJklKHuJiegTkOBEFZllv1pmsHk9F0sVwyLMVxnKatdFNjWRYlsHq9DiGg67oJEM2XS8e1yqWq5wWiKAEAwDBMEHi9Xo+hiI2NDQRBjo4OOYYNw3A2m2UyGSCOxuOJlCt0+71UXkYQBEUREACqqur7PggB+XxeELjQCxEEoijKj+LFfJmCVz3PS0/iCIKkZrE0fqNpmqqqMAw3m83G+poduVIuCwFgr9czVK1SKvMct1rKFEH6vq9pWr1avXHjxmw2Oz4+RmEEjmJVVjRNG0+GiqwmQBRF0ZtvPrq8vK7XqxlBRBCEpul0qeB5AUNxlXJttVotFguB5ZIkAZKk0Wjsb+0EQdBpt23b9myHpulKpXLd6aEoznJ86jV7/vw5gmOP3ny0d/NGvV53Pe/F4fPrbme1WskrhWVZISt9+exptpB3Xb/f7zu2S9N0JpPhef7evXuz2SyMAlHkg8Dr9TuFQkESRAqmOtddz/O2tzebrXqjURuNRo8ff5l2Gmazueu6GEpks9n19U0EQXTNmk6ngiBAEJS+d5fyotfr3bixl81mB4PBkydPLMvAcdzzvI2NjSAI0q9vfX09CIKTk5OVppbL5bQ6x2dEmqYbjUaqXZtNRgxF/dI95zs8z+fz+ZQDgeP4y5cvJSk3n848z4dBCEqAN9/55vNXhzEM1CvVXC43n02Ojo4MVdvd3SUJ4vbt20++fNy+vOJZLj1UERQOwEC92SiXCjhJXFycA0B8dXmZz2dWS7nZamSzmZ//4mMIgnzfVRRlfW0XTOi9/YNGtU7TLApjs9ni9PXJZDwrFou9Xm9re6PRqLMCK4q8LMu6oUIQ1O/3gsCDETCO/cGwW67kYCR5/vzr8WSAovDW9kYQBLK8SJIEQSPbnm5utTw3EYUshjKzhcLzfOpvaDTr1Urtxo1bXz95/uzpq0ql8fTZy+/+4Ae8lIGAoNM953hyPBnCIHJw94EqOwTOnx53+oPZWmszCsHFYkExpOOapVIhFarEYQTDSDYjTSYTBEFqtVochF9++eU7b7/91ltv/ct/+S9fvnr56K0HnV67fXW9u7edFTP9ft+2bRiGfd+HUXwhLxEMb65tVOs1PwxfHx4f7B/0u4MgCJMkRjCUZdnZfNFutxuN1qNHj6Rc4fz88ujoaKVqIAjCUKKuRqom0xwrSRJJUZIklWvlUqmUMviuLy9DPwhcj+c4EicgBOY4ZqnIqYCIIkgMQwa9/ouXzyQpkwARwzCz8SCKIimbQWGIoOh8rrRarcD/5n/9f7Btu1QopuLKdMh7eXkVBAFN054bxECSz+ZIlnz26tlwMqRpNhU4rDdb6foXx3FVWaEYPBz2K5USL3A//elP4yQ5ePhWLl988eJFu91Ow+M8y5u2dXZ2RlHUStFSDCEnChzNSFnx/t2bGALO53OeF9JjEQRBvh8eHh6CIPid73zH98L5fJ7qNOM4Pnz5kiCIZrO5u7t7eXkZRRGKoilFIJ3D/Mmf/Emv16tWq61Wa7aY1prVTEYYDAaSJJE43uv1kiSZTqflYgXDsHK5TJJkt9tNf1qCpDCCMUx7uVzu79/AELRer+9sbSVJ8vTJVxiGzWZTZbX8/7V3Hj2S5Gd6D+99ZKQ3VVneds/0tBkOZzjgLrDgkQJIQdJiIR0lAZIOuggQsF9AwN4lfQXpsFgKFMnZITmue0ybqi5vsrLSm4jM8OYfRocg+BX2oH4PcchTIhH5N+/7PL+H51mSxEEcoQhm2z5NscPhkGEYjuNM0ywWi9VqNf9jQxAEwzDLstfX12maIhksCep4ONk/OHj24RPXdV3XLhRVnCIHg/7Bg8Pl0njz9tj33YW5nE9nLMvKsuY4Dk3TlUplNBqRJL6/u93pdGq1CsMwMYiOj49xHK/Xq/3u/Xg2xQm61Wotl8vr62uWZVutZpameSKr77tZlrmuay9NWRElSbItV5BUluV9388zaX3fz0ExKIpeXFzka1OtVsuBOSEIgjROkiRJEtu0fM9TJblcLJE4HvrBZDJ59uxZs9n8zW9+c3d3V6lUQBhZszkIwtls1m63WZbN3f87OzsEQQAAVlbaPM+enp73+/dhCHRdJyl2sViUy+W9vT1JEBEEITE8yzKSIKAkFQTh5fc/9Hq9nZ0dURAyCDm9vLrv9TmO0zSN4bmNjQ0v8P7h//xqdXV173CPpCkAQLfX++GHHyzHZjgaIchuv7e+2m6srN7d3IYg3lhbIyjKNk1RkRbzWQqnjx+9d3N361o2S7MFUXMsezgcyoqYZQkA0fHx8dzQP/zwQxiGGYZlWTZLYYIi19Y29vYOXMvNoRE5/e3m5sb1nEql4rr2F198gWGY53kwnNE0vbGxIUnS7e1ttVqdTqd5dAyO41qpOJvNFEWRJElSldyH3Gq1SJLEcfTy8vLq5jpH2D548CB/u+rVxjfffDOfz3EEFUV5a2sLACDyUhSHKRyPJqM4jjc3NiaTkWksvvzyy7V2++OPP/7db357d3Obd/Nc1y2XyxACu4G7vrnWbNVt2z46erNcGlCWvX37uqwVwyh4770HvX43TVNNUxEIhiBqZ/fZT37yVzCMXpxd8AxfKdd8zzOXtuu6giDIqjSbT65urwRB8EP/t//316rMb22uLZZ6FAWe5/zj55/t72/LiuA41qvX321sriNIGkWR69mCwMkKV67yMJIW1IpthaKoQRl+cXGxtrZ2dX1RqVR838dQol5tyVIhS/Fef/Dli28+/OgpQcL/8Kv/vbbepBly0BsyNF8prsQAnYxMkuAFXv3w2UdhGN7c3EgqT7O0MddZll0sFrZpVSqV6+vrfKbCUBSCIKGfWyOdo7dHKIE6ng2lmevaP/7RszzMThSF716+lBSZZhhOlGbz+XXnDkYwAiPXamvAB1mWhWEkybJpmueXF83mCoZhn/3u83/+L//FX/2zn/76f33+3//n/1BlpdWoBJZZrWgERVYbdVlRGJFnee704tR1/K2d7RcvXvR6vcDza7VatVzWVGU2GU+n41ys4TpOFAWOZQ6GPRzHl8vF9uZ6qaRNxsMHDw5hGDZNSxBVkiTh//Q3/yEIQ1UuuL4Xx4nrupVK5a//1d/sHGxEXkpwCIRB8+7i5esfzq/OCAoHIDFN09CXcAaTJEnT9OPHjzmGvrm5uu/dBZ4bJwDJUsNc4oygFooAgJxke3J+VlSLuThE13VJkgVBuLi4OD09hdKM41gMzQLPwTCMplmSJHOhd+e2a1nW3t4ex3FZBrfb7TwFybbN4WCQ36azLMtTBPKcZUEQPM/r9/u5fiZ/lqsViiUrtWoeP8DSTK7E4DiOYyjbtjW1gGFYbkOdjsYBiAmScf1Q07Q4Tm3LoSjK98PlcikLIoJCOIqKEk+giGUvWZbBcaLbG2UpjKJou91ut9s5caXb7Wqa5rpuv9+/u7ujKIqmaY7jnj1+OhlN4yip1Wq1Wo1iaFWVg8h/dfQGgCjJ0sF4gGCoJEkgiaIgtCxrNJyhKJZlmaLIAs+zLM0w1HQ6rVfLeXhht9sdDfu56BDH8dncgFCk1WoBAMaDYQ4iZjk6ATGOo+PhkCRJEid0fQZBkOsHtcbqfbfH8/zm5mbe/BmNRhzHZVn2ZwLEnwGZUQwq9dr9fRdK0ka9XhBlKM0Cz3MsG8Ow09PTLMtKpdLVzTXHcXGaphFYTGZPP3i8sbGR05AePnxYr9cBAPmOiyDoYND3/eD4+AiCYIbnSI6XFNV3PY7j8kP0sNenKYphGBBGAIAsTiAIypet+mpLLmg4SVXq9V/9/d///o+/x3G83+/jFMmy9KPHH6ytrQ3HgzxdYDybWtbSMJbnlxcYgjIsLwkyjCLz6YwTeBRGVtqraQI4gZUE/r5/v1zoJEa2m2tff/F1EHhh6PtRqKqKKEvVWrnRaBy/PY3jhKZpfb4wHXtjY+vTjz8tFUogio6PjzEMy3/Azz77HcdxFxdnpVKJoqharVbQlF6vNxgMUBR9+/Zoc3OzXq9nWbbSXq1UKv3hIBftCIIwN4xarfbxTz7p9XpnZ2dbW1vHZ+eVSuX29i5N03q1cXJysrOzs9Fef/ny5c9//vPpeJLnUA6HwxikpqXLCmMsZp1Oh8IJkiTLpdJkMiFxYjqdhp7farUWiwWJUwzDHB8f8yLXH/XzJjvLsjRNqarsOs50Onywf0BShONYe/s7tVrts89+e7C3//jxx19881ZWqwiMiZzA0kyj1tRU9dXLN0dHR47vMBxrmoveoG+5tut7OIbcX1/gSKqqqmEYcRyVy8U0S0gSpRnSMGYcT9UbNVUVS2VNkoQg8pxQh1EoS/G9nffnM9uxfQwhLcuaz6eSLKiFwmg0EUX52dOPPDe6v7+H4Pjz3/8Gw7NaXQtC13XtJMkoktWUhm1Gmlxtr24zNB9FMQij/nAAoZBpm737O47jWq3WZDjSdT3vSdq2zdJMng2l6zrL8pzAhjHQNLXZbMqyyFAEy7Ke5/b63TiFjk/eIhiaZNDm7t7N7Z0gyVAKhwtPkVSGYfr9YZ4M0e/3VaXQaDVHowlFUb/4xS9gGD69OI98r1lvLOe6yAscx13f3qAkgeLYzNC/e/3D9tbO5ubmwlxeXl5mSRrHcQKApqp3t5dnp8eiKGZQAsOwJAn7uzvT2RhBENu2RInf29sxjcXl5Xmj0dje3v3h+zcAAPjf/fW/9YIQhlAYhrd2dlZXV5cLq9Fo5FFHIIrG4/Hl5eVyaagFKT8eipLCszyC4iiC5GiUarkUgTAKHBAGYeSROOr6oVIsIzgxHU/mhk5R1GA0qdVqkiRROBFFMY7jcQTu7u66d3eBH2I4OpsM4jiyLCe/c0mSlK+n1WqV53nX9W3bliQp7/zwPBsGwZs3rxaLxaNHj4rF4mKxyI2UtVrN87zxeGzbdpIk0+nUNE2GYx+8/yBO40F/SFIEgeHdbtcwjDiOGZLa2t5o1OrX19eLxWJrfUOW5STJRrNZBqPNet0PQb8/tC1nOBzP5/PdrW2WZQkc9TyXxFGWI/NgGZLmeU70fd80TZqm8+SDwWCQg8NQFM0/zzsqtUqlWqoXFLXRaAAAxtMJimOGMf/6xfN6s05z7GQ6tV0LhtE0jbMsWy6XnheutlbyKULge47jUBTheQ4CQbo+G4/HrusQOC7LoqZpvChgBGXbds6gxxEURdHJdGSapiwKCIJMRiMcx3mWQRCkWCziOHnb6XlBSJJkvmCZpklRVL1ezwnVuaTVtu0cjpZmCUmSHM3IogSl2XKu+46bxLHv+1EQTqfTFMpkRTEMo1yrkjSFplBRUrIkbdRqWzs7NEnOdB3H8Vqtdn19c3BwwPP8F198YSwXOI7X6/UUQc9vb3f29kiStG379PTUtm2Wpg8PD/XZPJ+aFmSlUqmwLBsEge35E13PEFiR5DfHR9c3VwzDQBCkqvJ33323srbSbDazLNM0rVgsTOcza2niOE7TNJzCRydvQQCq9aZtmnPD2N7cXNpLYzYtVUtpDL56/hWGQB88ejIf62WtvLOzZSx023V397Y5gXcc5+b2tt/vEwQtyvJiYQ6HY5pi19bWPvnwx2EQ5AbgnAPR693jOP7JJz/ODyUQBHXvO7e3t7nO5y//8qdhGDIMUy6XJUma6fPRaIQR+NXVlaQoDMMwHJu73EejEU6R9dZKc6W9v7N/f39vLS3fDY6Pj588enJwcGDMFwAA13W/+uqrtY31vZ1d09JvLt8EoZvbIFiaEUXRdV1VklmWrVaredhyGmf5zKw3uEcJ9PT8hCJxUZZomlIUicBxDIP06YxmKBjOCBKr1+uWtQQAaKXGP/7x+zjDoThRJRmBEIqiysWKrusYhnU6Hcd1dWsJkkjRCrwgKIJAQlD35lqSJIIgoihSVVkQOEHka7XKXB8vFvM4CSgal2SOYagUijEWHU7GV5f3OxuH5WKr1VznGN6yLJajoygYjAaTyVRVtMF48sP3r5v1miiQnbsLmsFYjoyAH0WR5wYYSq80NtMITRM89NLZeJplsCKJpm3FWULSBACAZelyqWQYxmDQyzW4f3KDp6koyoVCIW8qgDjtj4Y4jjZqlSgKzs/Pbm6vLGv56MnT7v19COL+eJzBKIITnU7Xd4NaoZyGiSiKQRBZllUsluv1uqqqH3zwQe7I297elmXZ8zyKIh48eK/X7V2cX62urt73e2cX54a5lBWlVqtdXd3kqg2WZpIoWRoLwzAce9FsVQgabTQaCALTDOk4Vr1aKWiKqirD8QhD4cPDwyAI3r59y3FMo9FiCNZxHPinTz7FCJIXZUUpPHj43vb27tvT8/l8fn5yOplMaIpCEIRhqEajpqmKZS0xjCAoOvTC2+595Af5OIumCBD5IsdyLJmkURpH0+kUQsmpYQz6fRTDdnd3MxjJF0EURnhezO9TSQSiKEpASpAYJ7A0Tbquz7Ls6upqEASGvpQkSdd1XddnMz0nseTaSgSBYBie69MkSdbX11mW9TyP4zgYhk3T/JNmDkVJkrQsyzCMDIZxkiAoPAGpLItZmt7d3cFpJgg8TVHz+RwEYRAEgsBJojgajaaz2dbuXpykiqR6fuh5gaYVRVkVRblzfcMw1OpKk6JIVRbLJfXq6sowjIvL6wDEURT5vp8kCcdxpVKpVCoZhkEQBEVReXsuz5PCEdzUFyiEMDyHIEgGQapWSJLk9OKc4dh6s5nBkOVYpmnZnhPH8Xg0YWm6XmvKkkDTtK7PJ5MJy1AIAvV6Pce1ZEHc29vNZ4a6rgMAZoZebzby5rJtWr7vp3FUqVTubm9IkoyCAIURGM6yLJNFCULQxdJSlELOLNN1PcfVqqra6/WCIMhdAmEYQhBEkmSWZf37nsCzHM3EEaAwvNVoFhTFdz1BECiKSrIUwbCpMQ+iaDKbepZdltQsTliakRQZzhDbdfJ+oyTKruvCGCoIwt7eQZqmZ+fnX3/3otpuu37Q6/XyXV8QhE6nk3dU0jSlKKqgqDzPAwDm8/nCXKYIAjKIJnEUx5M0JgiiWio2Go0//OEPHM/IsgxBqSorNEMNh0Pf9ymc4HmeZ/n+YDQdT0IQm4tlkqVwBs306eX5BckQrUZD1ZTdna12uz0bG6qk7O/vJ2l8fXvrerbtOo5jde/7vu8znFitVrMMHo4mnhfQJFUplHY2Nj/66KNvv/220+nYtv306ZOtra2b26u7u7tCocBx3OXleS6s6vf719eXeQ8Wp0iapiEENk0zBNHFxUUQRRzHpVDmeV6rvbq/v4/hOEbRg8GIpVjLspr15uH+g7/7b3/nWG5BVmez2S9/+cuVlZWrq6tP/+KnAsvNZ8Mv//DrMLSjKJJl2XYcx3HiONXUQqVSsW17NJoYhpFnySEIynFsCgGMxKrl4lSfT6eTSrWkKAqCpIPBAMPRcrkIw1m1WpUV8fPPP4+TzPIj0/ZonGi3VtI4M3Rd5uW8rbqwTEmRCYbGKEqQxBTKcBitSFpVqwwGo9y6n2OuC5rE81y5UgBxMBh2Fsu579soBskFGaEw1w9evzwjUE7my2vtbUmQCYJYWWmCOHj+7TfPn3+NU7TtOOfnV4osPHm0D0OAZvAsA4IgqKqKIIQil5qVNZIQTMNb6uagNywVC7tbW37k+2FAUYRt27P5xPfdxWIxmoxs29zf3y9WyuPx+P7+nuMEkiSTOBVFGUaw4+OT+XwqSwKIg/l8WiiqDx8ewhiewRAEo4PJbDydP3j/0YsX34Ew5knaWpi72ztPHj8DABAEpUjy5eVlr9drNBqGYRQKhTSOer2ers+qzVZ3NP39H7/+9NNPWY4bDgaTyQTH8ZVG8/jN29M3xwxB1qs1DELKxdJKreEG9sHTQ15hkiSxbYtmyIuLM4xAnzz9QBB4iqHjCJA0hSBIHlE+GY031jaCIID/9j//1wikIMm8IMQximIZAqcohp6OJ6PRCE4z13Un0xEIgwcPD5MkUZUCRTEoivcHIwRCKIpM0zTwHNsyBJ7hWRJFMgpD54beG4xYnkNR1A8BAMB2HQzDEBg9PDwUeD7ygzAELEEBAOII8DxP8XScJiiMibIEpdnF1eXdbTdJU5ZhFsslCGNRliRBtBx7NBia9jKM/CdPnmxtbbEsmx/28ztarsIkCCI/tOYrcpymF1eXIInjKFlbW11ptpIUJFFi22YaJ8N+jyAIVVayLOvedwa9fqGo0QyDorimFUECpwkkiApNs4IsDXv9YX+w2m6tt1ssTSFwkiPgO/e9FEZKpRLP847jTCYTx3EURalWq0EQsCzr+34OVMBxnMKJ7k2nf38fgkSWZZbnaIalKCpIwGQ2K1crJE2lCTSZz5aWiWGYaZqNWt1emnedGxRFJUnkOG51ZaVQUBaLhW2bJI7n2TInJye9Xi9K4tW11XzynCQJz3IIgniOVSwWPceVBI6lmTwVGoCQwPAoipeWzQtSLiUKw9DzvBy0oGmabdsAABiGoyiKoijLMgSCKRJPggiEYRyBklo43D8oFTTLsnie18qlDIZQkjBt6+j05OL6yjNtyAvbjVY+3UlTSFVVjMBN0/RcH4KgWrOhKMpgMDo6OkqzrFCpULww1me5DKler5cq5dvb236/n8/SJUlCMCyPDwMAQAiSImgQBK5rr6ysYBh61+kIAlfWikvToAhSFPkERGma+q6n63quBUiSRORFmmWWhtnr9+MoKRTV2XS6tbOpSLKsys1GrdaopjF4/fqoe9sbDAblcrndXrFcZzAYuL6Domi90UqgLImhUqUsS5rje2EIsjiRKI6A0Y2NjefPnxuGgeP4xua653l3d7eWZe3u7mqaNp9Pc8XwbDZLoWR3dzc3PM8XBsMw4+nk6ub66dOnru8rBRVF0cF4lA/kr66vJ7Npq9WiCBqEsbWwaJIGXkySJJZhaZru7u7SNO2FfrPZPD09RaCIwpM0CfO93LKsJEvL5aosy/f3934Y8rz4s5/9TBTFzz//fDabi6IQhE6xrO3v7liO3encwjgcx7FtL3ied1xbELhms64oCkkTn332GUbgD95/bzAYxGGkqcXQ9bq39yiKlrVyGIYgTUu1Kk6TUZqRNI1gKEsLmRs/PHzv9ur2m29f1Mo1VmC7t50oiUqa/Ojp+wSW3XavLXM2mQ9C3yvVy7q5LJUb/e50MlqaM59lxSyGBUHo3F0XiwonUl7gqqq6e7AfJ9nlxcnjh/s0iQWhN5tNSJKMU2gxtxSp9K//zb9PQ7hzdR94YffmmiQwTZWm0/HZ5RlJE3ES2bYFQEhSOIIjSZpeXl4KkggAsFwHQwkYhh3H8/0QgUkIgliWLhYLOIEZxjSDkoKmnZycvP/06frGFsjgl6+PmqvrWQpvbm7+6IMnz7/86uLsgmX48XjseUGr0ZwMJycnJ7s7WxAEEQTWv79zHMf3vShJUpi86/ZVrUCSpFxQMQzjORFBkGatHvi+Khc4mvFdr1ourzZWQBL2Jt2FOZ1Op5zIr62vzufjFMree/RwOpu019fjOPb9gKQpimRs2z49OcGgjMAw+G//43/BSNJYOgvLRjFS0QqVcg1BsLO3J69evYKyRFEUlqU5jksSEIYhRTFBCMrlmuN7kRcNh8NypYhAEJxGBI4E3pIk0K21NkFgGYxwHIfi+GQyu769ieKYJEmeFz3PS0HsOg4GowxBLZfLOIxKpRKEo91Bv1our21sgDAMARBYIc5SEIQYSRAoYXvubDwxHRvJkAzJeJEjSTzn63qel7eVOY579epVjgwKw3C5XObmLJBkUZysrq5KooKg0EI3fN8VOTEGoTGblyvFYkEzFwvbtuM4xhCkvdHWdR3BUIGX/SCy3XBpOsPhGIIQRZK//fY5TeLtlVYMAjgD11dX7z96VG+3wxjEcXx9fR2GYalUyrIsJwFYlqVpWq5TIggiyzKR4+E0C1wPwQiKomzXWZgWBEEYRU5m8ygGEUhwnJzqc9fz6vU6SZKGPoujwPf9g4ODw/0D13Vns9lyudAKheXSME3TdV3XsgEAosRrpRLD0a7veY6bJEmtWiEIonfXzaBktbXC0YyqKL7vWktTkqRSQYMxNE4zPwgmk0meIL9YLPLts1wuL5fLHJIDw3AOtqRIsqQUCAxnaTqNk8BxKYLkaCZJEq1cYjh2aVkUx4RQ+uK7b+fLBYuTW9X6bnsjj9+yHe/PgMxCsSQIAkkzk8nk+x9eOY4jCALFci/fvoX/xGVMDcNQVBUnCZqm/2x2TbI0h22AJInThGY413Xn8/nhwR5JEs+/+QbJUlVRKBxDIJgX2DiKXNvWZ1PLsqrVKklTNMeCAFg5VkGWFFFKoIwmSFERRY5HCWw+HUdJVFAk0zSTGNZnRpwmDENFSZymcRCF3W53bX0zgbJ+b8TyXKXciJIYhtE4jLAwHfX6OWanVqt98sknGIa+ePECx1FBEPIpEYhDz/M6nQ4AoN6qNxp1fWGIouh4HoZhUQziNEnTdDybLpZLAEAAojiOMxjKknQ6G7bqDUVSFVEBfjzsDbfXtqMochaeZVlv3ryxLIvh6VKptDCNgioFrsHSRJZlGIHjOFmv15/96Mc4jp+cnTMsiyDIhx9+KBcKp6enQRimSWw7i8vL88319qPHjyE4u7y+uLi4CEPX8b3F0ugPe1tbGwRBJFkcBIEgCGHgdzodZ2GyNCtxPEXQpYK2tbWjFUpu4MuFQorAfhzjNIOgKMsKqlAYDcYCK4IkPnp9RNJUQVHfnh0JHN1crY+Gdzd3ZwyD2e5iPpsIEt8fTKqVlmn4+twJzJShxfFwkmZxsajiRCapXGO1XigUMAL1/HAyHqJJIvEcw9IogRe1ylw3L89uFbkS+kgSQuP+eHtz05iOshTIErs056LIEzSG42iaxn7ohVGQwilGoJKqDEcjnCRwHJ/M9DRNYRSbjuYb6/v6VL+/v0szoGkqBKe2baZwZtlOAsFhFD949LhQrkVJiiKE7/scQY2Ho+PXx1mS2rY7m8zXVtrlcrlSKoMw8BwXQaFu5/Zgb6darZwdnTzcPdzd3ru4upwtjJX1DSf0m2trAEp7w4FaLlIMF8XA9QLLsiiKqlfKRY75/tuvR6PR+saapEqjUW84HuEklsJQuVpBcVxRCjhBjUYTx3OzGDhLXeZ5OMsy6F29q3f1rt7V/3+F/FN/gXf1rt7Vu3pX/zT1/wCsdPzrDhcq0QAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#display(Image(filename=\"/tmp/original.png\"))" + "display(Image(filename=\"./original.png\"))" ] }, { "cell_type": "code", "execution_count": null, - "id": "41bf92cf-4e14-4a40-a77e-f5f52a48170f", + "id": "357b4c50-d1f4-46e9-93ee-1fff9b6f5ae5", "metadata": {}, "outputs": [], "source": [] @@ -63,9 +76,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Ubuntu(env)", "language": "python", - "name": "python3" + "name": "env" }, "language_info": { "codemirror_mode": { @@ -77,7 +90,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.2" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/notebooks/encoded.txt b/notebooks/encoded.txt new file mode 100644 index 00000000..f258cfe5 --- /dev/null +++ b/notebooks/encoded.txt @@ -0,0 +1,7 @@ +coastguard_352x288x30x420x300.avi +8 +288 +352 +0.14325875946969696 +./encoded_original +/tmp/decoded diff --git a/src/MCTF.py b/src/MCTF.py new file mode 100644 index 00000000..e1945f95 --- /dev/null +++ b/src/MCTF.py @@ -0,0 +1,1478 @@ +'''MCTF: Motion-Compensated Temporal Filtering with Hierarchical B-frames. + +Implementation features: +- Bidirectional prediction for B-frames +- Hierarchical B-frame structure +- Integration with VCF spatial transforms (2D-DCT, 2D-DWT, etc.) +- Reuses VCF quantizers, color transforms, and entropy codecs +''' + +import sys +import io +import os +import tempfile +import logging +import importlib +import math +from typing import List, Tuple, Dict, Optional +from dataclasses import dataclass +from enum import Enum + +import numpy as np +import cv2 +import av +from PIL import Image +from concurrent.futures import ThreadPoolExecutor +import multiprocessing as mp + +# VCF Framework +with open(os.path.join(tempfile.gettempdir(), "description.txt"), 'w') as f: + f.write(__doc__) + +import main +import parser +import entropy_video_coding as EVC + +# ============================================================================= +# Constants and Configuration +# ============================================================================= + +class FrameType(Enum): + I = "I" # Intra frame + P = "P" # Predicted frame (forward only) + B = "B" # Bidirectional frame + +@dataclass +class MotionVector: + """Motion vector with cost information.""" + dx: int + dy: int + sad: float + bits: float + cost: float + ref_idx: int # Reference frame index + +@dataclass +class EncodedFrame: + """Frame encoding information.""" + frame_idx: int + frame_type: FrameType + display_order: int + encoding_order: int + references: List[int] # Reference frame indices + data: Optional[np.ndarray] = None + mv_field: Optional[np.ndarray] = None + residual: Optional[np.ndarray] = None + +# ============================================================================= +# Arguments +# ============================================================================= + +DEFAULT_ENCODE_OUTPUT_PREFIX = os.path.join(tempfile.gettempdir(), "encoded") +DEFAULT_DECODE_OUTPUT_PREFIX = os.path.join(tempfile.gettempdir(), "decoded") + +# Encoder - MCTF-specific parameters only +# Note: -T (transform) is needed but not in VCF base parser, so we add it here +parser.parser_encode.add_argument("-T", "--transform", type=str, + help=f"2D spatial transform for residuals (default: {EVC.DEFAULT_TRANSFORM})", + default=EVC.DEFAULT_TRANSFORM) +parser.parser_encode.add_argument("-M", "--block_size_ME", type=parser.int_or_str, + help="Block size for motion estimation (default: 16)", + default=16) +parser.parser_encode.add_argument("-S", "--search_range", type=parser.int_or_str, + help="Search range in pixels (default: 32)", + default=32) +parser.parser_encode.add_argument("--fast", action="store_true", + help="Use fast motion estimation (diamond search)") +parser.parser_encode.add_argument("--gop_size", type=int, + help="GOP size (default: 16)", + default=16) +parser.parser_encode.add_argument("--num_gops", type=int, + help="Number of GOPs to encode (default: 1)", + default=1) +parser.parser_encode.add_argument("--max_b_frames", type=int, + help="Maximum consecutive B-frames (default: 10, minimum for prediction)", + default=10) +parser.parser_encode.add_argument("--hierarchical", action="store_true", + help="Use hierarchical B-frame structure") +parser.parser_encode.add_argument("--lambda_rd", type=float, + help="Lagrange multiplier for RD optimization (default: 0.92*QSS). " + "Higher = favor rate, lower = favor distortion. 0 = pure SAD.", + default=None) + +# Decoder - add transform parameter +parser.parser_decode.add_argument("-T", "--transform", type=str, + help=f"2D spatial transform for residuals (default: {EVC.DEFAULT_TRANSFORM})", + default=EVC.DEFAULT_TRANSFORM) + +# Parse and import transform +args = parser.parser.parse_known_args()[0] + +# Get transform name - use VCF's default if not specified +transform_name = getattr(args, 'transform', EVC.DEFAULT_TRANSFORM) + +if __debug__: + if args.debug: + print(f"MCTF: Importing {transform_name}") + +try: + transform = importlib.import_module(transform_name) +except ImportError as e: + print(f"Error: Could not find {transform_name} module ({e})") + sys.exit(1) + +# ============================================================================= +# Motion Estimation Utilities +# ============================================================================= + +def compute_sad(block1: np.ndarray, block2: np.ndarray) -> float: + """Compute Sum of Absolute Differences between two blocks.""" + return float(np.sum(np.abs(block1.astype(np.int16) - block2.astype(np.int16)))) + +def estimate_mv_bits(dx: int, dy: int) -> float: + """Estimate bits to encode a motion vector using Exp-Golomb-like model. + + Each component costs 2·floor(log2(|v| + 1)) + 1 bits. + Zero MV = 2 bits total (cheapest), large MV = expensive. + """ + def _component_bits(v): + return 2.0 * math.floor(math.log2(abs(v) + 1)) + 1.0 + return _component_bits(dx) + _component_bits(dy) + +# Bits to signal prediction mode in a B-frame block: +# fwd-only or bwd-only = 2 bits (1 bit skip-bi + 1 bit direction) +# bidirectional = 3 bits (1 bit skip-bi + 2 MVs flag) +MODE_BITS = {0: 2.0, 1: 2.0, 2: 3.0} + +# ============================================================================= +# Motion Estimation +# ============================================================================= + +def _diamond_search(ref_frame, curr_block, i, j, bs, sr=32, lmbda=0.0): + """Diamond search pattern for motion estimation with RD cost. + + Minimises J = SAD + λ · estimate_mv_bits(dx, dy). + Returns (best_mv, best_sad) — the raw SAD of the winner + so callers can still use it for further mode decisions. + """ + h, w = ref_frame.shape[:2] + + # Large diamond pattern + ldp = [(0, -2), (-1, -1), (1, -1), (-2, 0), (2, 0), (-1, 1), (1, 1), (0, 2)] + # Small diamond pattern + sdp = [(0, -1), (-1, 0), (1, 0), (0, 1)] + + cx, cy = j, i + best_mv = (0, 0) + best_sad = float('inf') + best_cost = float('inf') + + # Evaluate center position (MV = (0,0), cheapest rate) + if 0 <= cy and cy + bs <= h and 0 <= cx and cx + bs <= w: + best_sad = compute_sad(curr_block, ref_frame[cy:cy+bs, cx:cx+bs]) + best_cost = best_sad + lmbda * estimate_mv_bits(0, 0) + + # Large diamond search + improved = True + while improved: + improved = False + for ddx, ddy in ldp: + ry, rx = cy + ddy, cx + ddx + if (ry < 0 or ry + bs > h or rx < 0 or rx + bs > w or + abs(rx - j) > sr or abs(ry - i) > sr): + continue + + sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs]) + mv_dx, mv_dy = rx - j, ry - i + cost = sad + lmbda * estimate_mv_bits(mv_dx, mv_dy) + + if cost < best_cost: + best_sad = sad + best_cost = cost + best_mv = (mv_dx, mv_dy) + cx, cy = rx, ry + improved = True + + # Small diamond search refinement + improved = True + while improved: + improved = False + for ddx, ddy in sdp: + ry, rx = cy + ddy, cx + ddx + if (ry < 0 or ry + bs > h or rx < 0 or rx + bs > w or + abs(rx - j) > sr or abs(ry - i) > sr): + continue + + sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs]) + mv_dx, mv_dy = rx - j, ry - i + cost = sad + lmbda * estimate_mv_bits(mv_dx, mv_dy) + + if cost < best_cost: + best_sad = sad + best_cost = cost + best_mv = (mv_dx, mv_dy) + cx, cy = rx, ry + improved = True + + return best_mv, best_sad + +def _exhaustive_search(ref_frame, curr_block, i, j, bs, sr=32, lmbda=0.0): + """Exhaustive search for motion estimation with RD cost. + + Minimises J = SAD + λ · estimate_mv_bits(dx, dy). + """ + h, w = ref_frame.shape[:2] + best_mv = (0, 0) + best_sad = float('inf') + best_cost = float('inf') + + for dy in range(-sr, sr + 1): + for dx in range(-sr, sr + 1): + ry, rx = i + dy, j + dx + if 0 <= ry and ry + bs <= h and 0 <= rx and rx + bs <= w: + sad = compute_sad(curr_block, ref_frame[ry:ry+bs, rx:rx+bs]) + cost = sad + lmbda * estimate_mv_bits(dx, dy) + + if cost < best_cost: + best_sad = sad + best_cost = cost + best_mv = (dx, dy) + + return best_mv, best_sad + +def _process_block(args_tuple): + """Process a single block for motion estimation (for parallel execution).""" + ref, curr_block, i, j, bs, sr, fast, lmbda = args_tuple + + if fast: + mv, sad = _diamond_search(ref, curr_block, i, j, bs, sr, lmbda) + else: + mv, sad = _exhaustive_search(ref, curr_block, i, j, bs, sr, lmbda) + + return mv, sad + +def _process_row(args_tuple): + """Process one row of blocks for motion estimation.""" + ref, curr, i, bs, sr, w, fast, lmbda = args_tuple + mvs = [] + sads = [] + + for j in range(0, w - bs + 1, bs): + block = curr[i:i+bs, j:j+bs] + + if fast: + mv, sad = _diamond_search(ref, block, i, j, bs, sr, lmbda) + else: + mv, sad = _exhaustive_search(ref, block, i, j, bs, sr, lmbda) + + mvs.append(mv) + sads.append(sad) + + return mvs, sads + +def block_matching(ref_frame, curr_frame, bs=16, sr=32, fast=True, lmbda=0.0): + """Block-based motion estimation with RD-optimised MV selection. + + Each block minimises J = SAD + λ · R_mv instead of pure SAD. + """ + ref_gray = cv2.cvtColor(ref_frame, cv2.COLOR_RGB2GRAY) + curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_RGB2GRAY) + h, w = ref_gray.shape + + mv_h = (h - bs) // bs + 1 + mv_w = (w - bs) // bs + 1 + mv_field = np.zeros((mv_h, mv_w, 2), dtype=np.float32) + + # For exhaustive search, use multiprocessing; for fast search, use threading + if not fast and sr > 16: + # Exhaustive search with large search range - use multiprocessing + from multiprocessing import Pool + + # Create block tasks + block_args = [] + for i in range(0, h - bs + 1, bs): + for j in range(0, w - bs + 1, bs): + block = curr_gray[i:i+bs, j:j+bs] + block_args.append((ref_gray, block, i, j, bs, sr, fast, lmbda)) + + # Process blocks in parallel + with Pool(processes=mp.cpu_count()) as pool: + results = pool.map(_process_block, block_args) + + # Reshape results into MV field + idx = 0 + for ri in range(mv_h): + for ci in range(mv_w): + mv_field[ri, ci] = results[idx][0] + idx += 1 + else: + # Fast search or small search range - use threading (row-based) + row_args = [(ref_gray, curr_gray, i, bs, sr, w, fast, lmbda) + for i in range(0, h - bs + 1, bs)] + + with ThreadPoolExecutor(max_workers=max(1, mp.cpu_count() - 1)) as ex: + results = list(ex.map(_process_row, row_args)) + + for ri, (row_mvs, row_sads) in enumerate(results): + for ci, mv in enumerate(row_mvs): + mv_field[ri, ci] = mv + + return mv_field + +# ============================================================================= +# Bidirectional Motion Estimation +# ============================================================================= + +def _process_bidir_block(args_tuple): + """Process bidirectional ME for a single block with RD-optimised mode decision. + + Mode decision minimises J = SAD + λ · (mv_bits + mode_bits). + """ + past_gray, future_gray, curr_block, i, j, bs, sr, fast, h, w, lmbda = args_tuple + + # Forward prediction (from past) + if fast: + mv_fwd, sad_fwd = _diamond_search(past_gray, curr_block, i, j, bs, sr, lmbda) + else: + mv_fwd, sad_fwd = _exhaustive_search(past_gray, curr_block, i, j, bs, sr, lmbda) + + # Backward prediction (from future) + if fast: + mv_bwd, sad_bwd = _diamond_search(future_gray, curr_block, i, j, bs, sr, lmbda) + else: + mv_bwd, sad_bwd = _exhaustive_search(future_gray, curr_block, i, j, bs, sr, lmbda) + + # Bidirectional (average of both predictions) + ry_fwd = max(0, min(i + int(mv_fwd[1]), h - bs)) + rx_fwd = max(0, min(j + int(mv_fwd[0]), w - bs)) + ry_bwd = max(0, min(i + int(mv_bwd[1]), h - bs)) + rx_bwd = max(0, min(j + int(mv_bwd[0]), w - bs)) + + pred_fwd = past_gray[ry_fwd:ry_fwd+bs, rx_fwd:rx_fwd+bs] + pred_bwd = future_gray[ry_bwd:ry_bwd+bs, rx_bwd:rx_bwd+bs] + pred_bi = ((pred_fwd.astype(np.int16) + pred_bwd.astype(np.int16)) // 2).astype(np.uint8) + + sad_bi = compute_sad(curr_block, pred_bi) + + # RD cost for each mode: J = SAD + λ · (mv_bits + mode_bits) + cost_fwd = sad_fwd + lmbda * (estimate_mv_bits(*mv_fwd) + MODE_BITS[0]) + cost_bwd = sad_bwd + lmbda * (estimate_mv_bits(*mv_bwd) + MODE_BITS[1]) + cost_bi = sad_bi + lmbda * (estimate_mv_bits(*mv_fwd) + estimate_mv_bits(*mv_bwd) + MODE_BITS[2]) + + # Choose best mode based on RD cost + if cost_fwd <= cost_bwd and cost_fwd <= cost_bi: + mode = 0 # Forward + mv_f = mv_fwd + mv_b = (0, 0) + elif cost_bwd <= cost_bi: + mode = 1 # Backward + mv_f = (0, 0) + mv_b = mv_bwd + else: + mode = 2 # Bidirectional + mv_f = mv_fwd + mv_b = mv_bwd + + return mv_f, mv_b, mode + +def bidirectional_me(ref_past, ref_future, curr_frame, bs=16, sr=32, fast=True, lmbda=0.0): + """ + Bidirectional motion estimation for B-frames with RD-optimised mode decision. + + MV selection minimises J = SAD + λ · R_mv. + Mode decision minimises J = SAD + λ · (R_mv + R_mode). + Returns forward MV, backward MV, and best mode (forward/backward/bi). + """ + h, w = curr_frame.shape[:2] + curr_gray = cv2.cvtColor(curr_frame, cv2.COLOR_RGB2GRAY) + past_gray = cv2.cvtColor(ref_past, cv2.COLOR_RGB2GRAY) + future_gray = cv2.cvtColor(ref_future, cv2.COLOR_RGB2GRAY) + + mv_h = (h - bs) // bs + 1 + mv_w = (w - bs) // bs + 1 + + mv_forward = np.zeros((mv_h, mv_w, 2), dtype=np.float32) + mv_backward = np.zeros((mv_h, mv_w, 2), dtype=np.float32) + mode = np.zeros((mv_h, mv_w), dtype=np.uint8) # 0=fwd, 1=bwd, 2=bi + + # For exhaustive search, use multiprocessing + if not fast and sr > 16: + from multiprocessing import Pool + + # Create block tasks + block_args = [] + for i in range(0, h - bs + 1, bs): + for j in range(0, w - bs + 1, bs): + curr_block = curr_gray[i:i+bs, j:j+bs] + block_args.append((past_gray, future_gray, curr_block, i, j, bs, sr, fast, h, w, lmbda)) + + # Process blocks in parallel + with Pool(processes=mp.cpu_count()) as pool: + results = pool.map(_process_bidir_block, block_args) + + # Reshape results + idx = 0 + for ri in range(mv_h): + for ci in range(mv_w): + mv_forward[ri, ci] = results[idx][0] + mv_backward[ri, ci] = results[idx][1] + mode[ri, ci] = results[idx][2] + idx += 1 + else: + # Fast search - use sequential processing + for i in range(0, h - bs + 1, bs): + for j in range(0, w - bs + 1, bs): + curr_block = curr_gray[i:i+bs, j:j+bs] + + # Forward prediction (from past) + if fast: + mv_fwd, sad_fwd = _diamond_search(past_gray, curr_block, i, j, bs, sr, lmbda) + else: + mv_fwd, sad_fwd = _exhaustive_search(past_gray, curr_block, i, j, bs, sr, lmbda) + + # Backward prediction (from future) + if fast: + mv_bwd, sad_bwd = _diamond_search(future_gray, curr_block, i, j, bs, sr, lmbda) + else: + mv_bwd, sad_bwd = _exhaustive_search(future_gray, curr_block, i, j, bs, sr, lmbda) + + # Bidirectional (average of both) + ry_fwd = max(0, min(i + int(mv_fwd[1]), h - bs)) + rx_fwd = max(0, min(j + int(mv_fwd[0]), w - bs)) + ry_bwd = max(0, min(i + int(mv_bwd[1]), h - bs)) + rx_bwd = max(0, min(j + int(mv_bwd[0]), w - bs)) + + pred_fwd = past_gray[ry_fwd:ry_fwd+bs, rx_fwd:rx_fwd+bs] + pred_bwd = future_gray[ry_bwd:ry_bwd+bs, rx_bwd:rx_bwd+bs] + pred_bi = ((pred_fwd.astype(np.int16) + pred_bwd.astype(np.int16)) // 2).astype(np.uint8) + + sad_bi = compute_sad(curr_block, pred_bi) + + # RD cost for each mode: J = SAD + λ · (mv_bits + mode_bits) + cost_fwd = sad_fwd + lmbda * (estimate_mv_bits(*mv_fwd) + MODE_BITS[0]) + cost_bwd = sad_bwd + lmbda * (estimate_mv_bits(*mv_bwd) + MODE_BITS[1]) + cost_bi = sad_bi + lmbda * (estimate_mv_bits(*mv_fwd) + estimate_mv_bits(*mv_bwd) + MODE_BITS[2]) + + # Choose best mode based on RD cost + ri, ci = i // bs, j // bs + if cost_fwd <= cost_bwd and cost_fwd <= cost_bi: + mode[ri, ci] = 0 # Forward + mv_forward[ri, ci] = mv_fwd + mv_backward[ri, ci] = (0, 0) + elif cost_bwd <= cost_bi: + mode[ri, ci] = 1 # Backward + mv_forward[ri, ci] = (0, 0) + mv_backward[ri, ci] = mv_bwd + else: + mode[ri, ci] = 2 # Bidirectional + mv_forward[ri, ci] = mv_fwd + mv_backward[ri, ci] = mv_bwd + + return mv_forward, mv_backward, mode + +# ============================================================================= +# Motion Compensation +# ============================================================================= + +def motion_compensate(frame, mv_field, bs=16, direction=1): + """Apply motion compensation (single reference).""" + h, w = frame.shape[:2] + comp = np.zeros_like(frame) + + for i in range(0, h - bs + 1, bs): + for j in range(0, w - bs + 1, bs): + mv = mv_field[i // bs, j // bs] * direction + ry = int(np.clip(i + mv[1], 0, h - bs)) + rx = int(np.clip(j + mv[0], 0, w - bs)) + comp[i:i+bs, j:j+bs] = frame[ry:ry+bs, rx:rx+bs] + + # Handle boundaries + if h % bs != 0: + comp[-(h % bs):, :] = frame[-(h % bs):, :] + if w % bs != 0: + comp[:, -(w % bs):] = frame[:, -(w % bs):] + + return comp + +def motion_compensate_bidirectional(ref_past, ref_future, mv_fwd, mv_bwd, + mode, bs=16): + """Apply bidirectional motion compensation.""" + h, w = ref_past.shape[:2] + comp = np.zeros_like(ref_past) + + for i in range(0, h - bs + 1, bs): + for j in range(0, w - bs + 1, bs): + ri, ci = i // bs, j // bs + m = mode[ri, ci] + + if m == 0: # Forward only + mv = mv_fwd[ri, ci] + ry = int(np.clip(i + mv[1], 0, h - bs)) + rx = int(np.clip(j + mv[0], 0, w - bs)) + comp[i:i+bs, j:j+bs] = ref_past[ry:ry+bs, rx:rx+bs] + + elif m == 1: # Backward only + mv = mv_bwd[ri, ci] + ry = int(np.clip(i + mv[1], 0, h - bs)) + rx = int(np.clip(j + mv[0], 0, w - bs)) + comp[i:i+bs, j:j+bs] = ref_future[ry:ry+bs, rx:rx+bs] + + else: # Bidirectional + mv_f = mv_fwd[ri, ci] + mv_b = mv_bwd[ri, ci] + ry_f = int(np.clip(i + mv_f[1], 0, h - bs)) + rx_f = int(np.clip(j + mv_f[0], 0, w - bs)) + ry_b = int(np.clip(i + mv_b[1], 0, h - bs)) + rx_b = int(np.clip(j + mv_b[0], 0, w - bs)) + + pred_f = ref_past[ry_f:ry_f+bs, rx_f:rx_f+bs] + pred_b = ref_future[ry_b:ry_b+bs, rx_b:rx_b+bs] + comp[i:i+bs, j:j+bs] = ((pred_f.astype(np.int16) + + pred_b.astype(np.int16)) // 2).astype(np.uint8) + + # Handle boundaries + if h % bs != 0: + comp[-(h % bs):, :] = ref_past[-(h % bs):, :] + if w % bs != 0: + comp[:, -(w % bs):] = ref_past[:, -(w % bs):] + + return comp + +# ============================================================================= +# GOP Structure Management +# ============================================================================= + +def create_hierarchical_gop(gop_size: int, max_b_frames: int = 3) -> List[EncodedFrame]: + """ + Create hierarchical B-frame GOP structure. + + Example for GOP=8, max_b=3: + Display: 0 1 2 3 4 5 6 7 8 + Type: I B B B P B B B I + Encoding: 0 4 2 1 3 8 6 5 7 + Level: 0 2 1 2 0 2 1 2 0 + """ + frames = [] + display_order = 0 + + # I-frame at start + frames.append(EncodedFrame( + frame_idx=0, + frame_type=FrameType.I, + display_order=0, + encoding_order=0, + references=[] + )) + display_order += 1 + + # P or I frame at end of GOP + if gop_size > 1: + frames.append(EncodedFrame( + frame_idx=gop_size - 1, + frame_type=FrameType.P, + display_order=gop_size - 1, + encoding_order=1, + references=[0] + )) + + # Hierarchical B-frames + def add_hierarchical_b(start_ref, end_ref, level, encoding_order): + if end_ref - start_ref <= 1: + return encoding_order + + mid = (start_ref + end_ref) // 2 + frames.append(EncodedFrame( + frame_idx=mid, + frame_type=FrameType.B, + display_order=mid, + encoding_order=encoding_order, + references=[start_ref, end_ref] + )) + encoding_order += 1 + + if level < max_b_frames: + encoding_order = add_hierarchical_b(start_ref, mid, level + 1, encoding_order) + encoding_order = add_hierarchical_b(mid, end_ref, level + 1, encoding_order) + + return encoding_order + + add_hierarchical_b(0, gop_size - 1, 1, 2) + + # Sort by encoding order + frames.sort(key=lambda x: x.encoding_order) + + return frames + +def create_simple_gop(gop_size: int, max_b_frames: int = 3) -> List[EncodedFrame]: + """ + Create simple IBBP GOP structure. + + Example for GOP=8, max_b=3: + Display: 0 1 2 3 4 5 6 7 8 + Type: I B B B P B B B I + Encoding: 0 4 1 2 3 8 5 6 7 + """ + frames = [] + + # I-frame at start + frames.append(EncodedFrame( + frame_idx=0, + frame_type=FrameType.I, + display_order=0, + encoding_order=0, + references=[] + )) + + # P or I frame at end of GOP + if gop_size > 1: + anchor_pos = gop_size - 1 + frames.append(EncodedFrame( + frame_idx=anchor_pos, + frame_type=FrameType.P, + display_order=anchor_pos, + encoding_order=1, + references=[0] # Reference I-frame + )) + + # All B-frames reference I and P + encoding_order = 2 + for b_pos in range(1, anchor_pos): + frames.append(EncodedFrame( + frame_idx=b_pos, + frame_type=FrameType.B, + display_order=b_pos, + encoding_order=encoding_order, + references=[0, anchor_pos] # All B-frames reference (I, P) + )) + encoding_order += 1 + + # Sort by encoding order + frames.sort(key=lambda x: x.encoding_order) + + return frames + +# ============================================================================= +# CoDec Class +# ============================================================================= + +class CoDec(EVC.CoDec): + """MCTF Codec with hierarchical B-frames using VCF framework transforms.""" + + def __init__(self, args): + logging.debug("trace") + super().__init__(args) + self.transform_codec = transform.CoDec(args) + logging.info(f"Using {args.transform} spatial transform for residuals") + + # Pass QSS to transform codec if available + if hasattr(args, 'QSS'): + self.transform_codec.args.QSS = args.QSS + logging.info(f"Set transform codec QSS to {args.QSS}") + # Recreate the quantizer with the correct QSS + # (transform codec's __init__ already created it with possibly wrong QSS) + try: + from scalar_quantization.deadzone_quantization import Deadzone_Quantizer + self.transform_codec.Q = Deadzone_Quantizer(Q_step=args.QSS, min_val=0, max_val=255) + logging.info(f"Recreated quantizer with QSS={args.QSS}") + except Exception as e: + logging.warning(f"Could not recreate quantizer: {e}") + + # Monkey-patch transform codec methods to use self.args when called without arguments + # This fixes VCF framework's encode()/decode() which call these without args + # Also capture decoded output in case decode_write fails to persist to disk + self._captured_decode_output = [None] + original_encode_read = self.transform_codec.encode_read + original_encode_write = self.transform_codec.encode_write + original_decode_read = self.transform_codec.decode_read + original_decode_write = self.transform_codec.decode_write + + def patched_encode_read(fn=None): + if fn is None: + fn = self.transform_codec.args.original + return original_encode_read(fn) + + def patched_encode_write(codestream, fn=None): + if fn is None: + fn = self.transform_codec.args.encoded + return original_encode_write(codestream, fn) + + def patched_decode_read(fn=None): + if fn is None: + fn = self.transform_codec.args.encoded + return original_decode_read(fn) + + def patched_decode_write(img, fn=None): + if fn is None: + fn = self.transform_codec.args.decoded + self._captured_decode_output[0] = np.array(img, copy=True) + return original_decode_write(img, fn) + + self.transform_codec.encode_read = patched_encode_read + self.transform_codec.encode_write = patched_encode_write + self.transform_codec.decode_read = patched_decode_read + self.transform_codec.decode_write = patched_decode_write + + self.block_size = int(getattr(args, 'block_size_ME', 16)) + self.search_range = int(getattr(args, 'search_range', 32)) + self.fast = getattr(args, 'fast', False) + self.gop_size = int(getattr(args, 'gop_size', 16)) + self.num_gops = int(getattr(args, 'num_gops', 1)) + self.max_b_frames = int(getattr(args, 'max_b_frames', 10)) + self.hierarchical = getattr(args, 'hierarchical', False) + + # Ensure we have at least 10 frames for prediction + if self.max_b_frames < 10: + logging.warning(f"max_b_frames={self.max_b_frames} is too low, setting to 10") + self.max_b_frames = 10 + + # Where original frames are expected for metrics + self.original_prefix = getattr(args, "original_prefix", + os.path.join(tempfile.gettempdir(), "encoded_original")) + + # RD-optimization: λ controls the rate-distortion trade-off + # J = SAD + λ · R (λ=0 ⟹ pure SAD, higher λ ⟹ favor cheaper MVs) + # Default: √0.85 · QSS ≈ 0.92·QSS (H.264 SAD-λ relationship) + user_lambda = getattr(args, 'lambda_rd', None) + if user_lambda is not None: + self.lambda_rd = float(user_lambda) + else: + qss = float(getattr(args, 'QSS', 1)) + self.lambda_rd = math.sqrt(0.85) * qss + + logging.info(f"MCTF Config: GOP={self.gop_size}, NumGOPs={self.num_gops}, MaxB={self.max_b_frames}, " + f"BlockSize={self.block_size}, SearchRange={self.search_range}, " + f"Fast={self.fast}, Hierarchical={self.hierarchical}, " + f"λ_RD={self.lambda_rd:.4f}") + + def bye(self): + """Override parent's bye() to prevent double video encoding.""" + logging.debug("trace") + + # Only calculate metrics without re-encoding + if not self.encoding: + logging.info("MCTF: Skipping VCF's automatic video re-encoding (already done)") + + def encode(self): + """Encode video with MCTF.""" + logging.debug("trace") + fn = self.args.original + logging.info(f"Encoding {fn}") + + # Check if input is likely a video file + if fn.endswith('.png') or fn.endswith('.jpg') or fn.endswith('.jpeg'): + logging.error(f"MCTF requires a video file (e.g., .mp4, .avi) as input, not an image file.") + logging.error(f"Received: {fn}") + logging.error("Please use -o with a video file URL or path.") + return 0 + + try: + container = av.open(fn) + except Exception as e: + logging.error(f"Cannot open video file {fn}: {e}") + logging.error("MCTF requires a video file (e.g., .mp4, .avi) as input.") + return 0 + + # Calculate total frames from gop_size * num_gops + total_frames_to_encode = self.gop_size * self.num_gops + logging.info(f"Total frames to encode: {total_frames_to_encode} (GOP size={self.gop_size} × num GOPs={self.num_gops})") + + # Read frames + frames = [] + for packet in container.demux(): + if __debug__: + self.total_input_size += packet.size + for frame in packet.decode(): + img = np.array(frame.to_image().convert("RGB")) + frames.append(img) + if len(frames) >= total_frames_to_encode: + break + if len(frames) >= total_frames_to_encode: + break + container.close() + + if len(frames) < 2: + logging.error("Need at least 2 frames") + return 0 + + self.N_frames = len(frames) + self.height, self.width = frames[0].shape[:2] + self.N_channels = 3 + # Force original frames to be saved in /tmp + self.original_prefix = os.path.join(tempfile.gettempdir(), "encoded_original") + + logging.info(f"Video: {self.width}x{self.height}, {self.N_frames} frames, {self.N_channels} channels") + + # Save original frames + for idx, img in enumerate(frames): + img_fn = f"{self.original_prefix}_{idx:04d}.png" + Image.fromarray(img).save(img_fn) + + # Process GOPs + decoded_frames = {} # Cache for reference frames + + for gop_start in range(0, self.N_frames, self.gop_size): + gop_end = min(gop_start + self.gop_size, self.N_frames) + actual_gop_size = gop_end - gop_start + gop_start_size = self.total_output_size + + logging.info(f"\n{'='*60}") + logging.info(f"Processing GOP {gop_start}-{gop_end-1} (size={actual_gop_size})") + logging.info(f"{'='*60}") + + # Create GOP structure + if self.hierarchical: + gop_structure = create_hierarchical_gop(actual_gop_size, self.max_b_frames) + else: + gop_structure = create_simple_gop(actual_gop_size, self.max_b_frames) + + # Encode frames in encoding order + i_count = p_count = b_count = 0 + for frame_info in gop_structure: + abs_idx = gop_start + frame_info.frame_idx + if abs_idx >= self.N_frames: + continue + + frame = frames[abs_idx] + + if frame_info.frame_type == FrameType.I: + self._encode_i_frame(frame, abs_idx, decoded_frames) + i_count += 1 + + elif frame_info.frame_type == FrameType.P: + ref_idx = gop_start + frame_info.references[0] + self._encode_p_frame(frame, abs_idx, ref_idx, decoded_frames) + p_count += 1 + + elif frame_info.frame_type == FrameType.B: + ref_past_idx = gop_start + frame_info.references[0] + ref_future_idx = gop_start + frame_info.references[1] + self._encode_b_frame(frame, abs_idx, ref_past_idx, + ref_future_idx, decoded_frames) + b_count += 1 + + # GOP statistics + gop_bytes = self.total_output_size - gop_start_size + gop_pixels = actual_gop_size * self.width * self.height + gop_bpp = (gop_bytes * 8) / gop_pixels if gop_pixels > 0 else 0 + + logging.info(f"\nGOP {gop_start}-{gop_end-1} Summary:") + logging.info(f" Frame types: I={i_count}, P={p_count}, B={b_count}") + logging.info(f" GOP size: {gop_bytes} bytes ({gop_bpp:.4f} bpp)") + logging.info(f" Average: {gop_bytes/actual_gop_size:.2f} bytes/frame") + + logging.info(f"\n{'='*60}") + logging.info(f"ENCODING COMPLETE") + logging.info(f"{'='*60}") + + # Calculate and log metrics + total_pixels = self.N_frames * self.width * self.height + BPP = (self.total_output_size * 8) / total_pixels + + logging.info(f"Total frames encoded: {self.N_frames}") + logging.info(f"Video dimensions: {self.width}x{self.height}") + logging.info(f"Total output size: {self.total_output_size} bytes ({self.total_output_size/1024/1024:.2f} MB)") + logging.info(f"Total input size: {self.total_input_size} bytes ({self.total_input_size/1024/1024:.2f} MB)") + logging.info(f"Compression ratio: {self.total_input_size/self.total_output_size:.2f}:1") + logging.info(f"Total pixels: {total_pixels}") + logging.info(f"Bits Per Pixel (BPP): {BPP:.6f}") + logging.info(f"Compression rate: {BPP:.4f} bits/pixel") + logging.info(f"\nNOTE: The encoded size ({self.total_output_size/1024/1024:.2f} MB) is the actual compressed data.") + logging.info(f"The decoded MP4 is for playback only and uses H.264 re-encoding.") + logging.info(f"{'='*60}\n") + + # Persist metadata so decode() is self-contained + with open(f"{self.args.encoded}_meta.txt", "w") as f: + f.write(f"{self.original_prefix}\n") + f.write(f"{self.N_frames}\n") + f.write(f"{self.height}\n") + f.write(f"{self.width}\n") + f.write(f"{BPP}\n") + f.write(f"{self.total_output_size}\n") + + return self.total_output_size + + def _encode_i_frame(self, frame, idx, decoded_frames): + """Encode I-frame.""" + logging.info(f"Encoding I-frame {idx}") + + i_orig_fn = f"{self.args.encoded}_I_{idx:04d}.png" + i_enc_fn = f"{self.args.encoded}_{idx:04d}" + Image.fromarray(frame).save(i_orig_fn) + + # Temporarily set args so transform codec's encode() reads/writes correct files + saved_original = getattr(self.transform_codec.args, 'original', None) + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + + self.transform_codec.args.original = i_orig_fn + self.transform_codec.args.encoded = i_enc_fn + + # Recreate quantizer with correct QSS before encoding + if hasattr(self.args, 'QSS'): + self.transform_codec.args.QSS = self.args.QSS + from scalar_quantization.deadzone_quantization import Deadzone_Quantizer + self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255) + + # Use full encode() to ensure DCT transform and quantization are applied + O_bytes = self.transform_codec.encode() + + # Restore args + if saved_original is not None: + self.transform_codec.args.original = saved_original + if saved_encoded is not None: + self.transform_codec.args.encoded = saved_encoded + + self.total_output_size += O_bytes + + # Save metadata + with open(f"{i_enc_fn}_type.txt", 'w') as f: + f.write("I") + + # Decode and cache for references + dec_fn = f"{self.args.encoded}_dec_{idx:04d}.png" + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + saved_decoded = getattr(self.transform_codec.args, 'decoded', None) + + self.transform_codec.args.encoded = i_enc_fn + self.transform_codec.args.decoded = dec_fn + self._captured_decode_output[0] = None + self.transform_codec.decode() + + if saved_encoded is not None: + self.transform_codec.args.encoded = saved_encoded + if saved_decoded is not None: + self.transform_codec.args.decoded = saved_decoded + + # Use captured output if available (avoids FileNotFoundError when decode_write path differs) + if self._captured_decode_output[0] is not None: + decoded_frames[idx] = self._captured_decode_output[0] + elif os.path.exists(dec_fn): + decoded_frames[idx] = np.array(Image.open(dec_fn).convert("RGB")) + else: + raise FileNotFoundError( + f"Decoded frame not found at {dec_fn}. " + "The transform codec's decode() did not write the expected output." + ) + + logging.info(f" I-frame {idx}: {O_bytes} bytes") + + def _encode_p_frame(self, frame, idx, ref_idx, decoded_frames): + """Encode P-frame (forward prediction only) using VCF transform.""" + logging.info(f"Encoding P-frame {idx} (ref={ref_idx})") + + ref_frame = decoded_frames[ref_idx] + + # Motion estimation (RD-optimised: J = SAD + λ·R_mv) + mv_field = block_matching( + ref_frame, frame, + self.block_size, self.search_range, + self.fast, self.lambda_rd + ) + + # Motion compensation + pred = motion_compensate(ref_frame, mv_field, self.block_size) + + # Compute residual and map to [0, 255] without hard-clipping: + # residual ∈ [-255, 255] → /2 + 128 → [0.5, 255.5] → round → [0, 255] + # Max rounding error from mapping: ±1 per sample (vs up to ±128 with old +128 clip) + residual = frame.astype(np.int16) - pred.astype(np.int16) + residual_img = np.clip(np.round(residual.astype(np.float32) / 2 + 128), 0, 255).astype(np.uint8) + + # Save residual as PNG and encode using transform codec (DCT + quantize + entropy) + residual_fn = f"{self.args.encoded}_res_{idx:04d}.png" + Image.fromarray(residual_img).save(residual_fn) + + enc_fn = f"{self.args.encoded}_{idx:04d}" + + # Temporarily set args + saved_original = getattr(self.transform_codec.args, 'original', None) + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + + self.transform_codec.args.original = residual_fn + self.transform_codec.args.encoded = enc_fn + + # Recreate quantizer before encoding + if hasattr(self.args, 'QSS'): + self.transform_codec.args.QSS = self.args.QSS + from scalar_quantization.deadzone_quantization import Deadzone_Quantizer + self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255) + + O_bytes = self.transform_codec.encode() + + # Restore args + if saved_original is not None: + self.transform_codec.args.original = saved_original + if saved_encoded is not None: + self.transform_codec.args.encoded = saved_encoded + + self.total_output_size += O_bytes + + # Save motion vectors + np.savez_compressed( + f"{enc_fn}_mv.npz", + mv=mv_field, + ref_idx=ref_idx + ) + mv_size = os.path.getsize(f"{enc_fn}_mv.npz") + self.total_output_size += mv_size + + # Save frame type + with open(f"{enc_fn}_type.txt", 'w') as f: + f.write(f"P:{ref_idx}") + + # Decode residual to get reconstruction (encoder-side decode for reference) + dec_fn = f"{self.args.encoded}_dec_{idx:04d}.png" + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + saved_decoded = getattr(self.transform_codec.args, 'decoded', None) + + self.transform_codec.args.encoded = enc_fn + self.transform_codec.args.decoded = dec_fn + self._captured_decode_output[0] = None + self.transform_codec.decode() + + self.transform_codec.args.encoded = saved_encoded + self.transform_codec.args.decoded = saved_decoded + + # Undo mapping: (pixel - 128) * 2; use captured output if available + if self._captured_decode_output[0] is not None: + residual_img_dec = self._captured_decode_output[0] + elif os.path.exists(dec_fn): + residual_img_dec = np.array(Image.open(dec_fn).convert("RGB")) + else: + raise FileNotFoundError( + f"Decoded residual not found at {dec_fn}. " + "The transform codec's decode() did not write the expected output." + ) + residual_rec = (residual_img_dec.astype(np.int16) - 128) * 2 + + # Reconstruct and cache + recon = np.clip(pred.astype(np.int16) + residual_rec, 0, 255).astype(np.uint8) + decoded_frames[idx] = recon + + logging.info(f" P-frame {idx}: residual={O_bytes} bytes, mv={mv_size} bytes") + + def _encode_b_frame(self, frame, idx, ref_past_idx, ref_future_idx, decoded_frames): + """Encode B-frame (bidirectional prediction) using VCF transform.""" + logging.info(f"Encoding B-frame {idx} (refs={ref_past_idx},{ref_future_idx})") + + ref_past = decoded_frames[ref_past_idx] + ref_future = decoded_frames[ref_future_idx] + + # Bidirectional motion estimation (RD-optimised: J = SAD + λ·(R_mv + R_mode)) + mv_fwd, mv_bwd, mode = bidirectional_me( + ref_past, ref_future, frame, + self.block_size, self.search_range, + self.fast, self.lambda_rd + ) + + # Motion compensation + pred = motion_compensate_bidirectional( + ref_past, ref_future, mv_fwd, mv_bwd, mode, self.block_size + ) + + # Compute residual and map to [0, 255] without hard-clipping: + # residual ∈ [-255, 255] → /2 + 128 → [0.5, 255.5] → round → [0, 255] + residual = frame.astype(np.int16) - pred.astype(np.int16) + residual_img = np.clip(np.round(residual.astype(np.float32) / 2 + 128), 0, 255).astype(np.uint8) + + # Save residual as PNG and encode using transform codec (DCT + quantize + entropy) + residual_fn = f"{self.args.encoded}_res_{idx:04d}.png" + Image.fromarray(residual_img).save(residual_fn) + + enc_fn = f"{self.args.encoded}_{idx:04d}" + + # Temporarily set args + saved_original = getattr(self.transform_codec.args, 'original', None) + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + + self.transform_codec.args.original = residual_fn + self.transform_codec.args.encoded = enc_fn + + # Recreate quantizer before encoding + if hasattr(self.args, 'QSS'): + self.transform_codec.args.QSS = self.args.QSS + from scalar_quantization.deadzone_quantization import Deadzone_Quantizer + self.transform_codec.Q = Deadzone_Quantizer(Q_step=self.args.QSS, min_val=0, max_val=255) + + O_bytes = self.transform_codec.encode() + + # Restore args + if saved_original is not None: + self.transform_codec.args.original = saved_original + if saved_encoded is not None: + self.transform_codec.args.encoded = saved_encoded + + self.total_output_size += O_bytes + + # Save motion vectors and mode + np.savez_compressed( + f"{enc_fn}_mv.npz", + mv_fwd=mv_fwd, + mv_bwd=mv_bwd, + mode=mode, + ref_past=ref_past_idx, + ref_future=ref_future_idx + ) + mv_size = os.path.getsize(f"{enc_fn}_mv.npz") + self.total_output_size += mv_size + + # Save frame type + with open(f"{enc_fn}_type.txt", 'w') as f: + f.write(f"B:{ref_past_idx},{ref_future_idx}") + + # Decode residual to get reconstruction (encoder-side decode for reference) + dec_fn = f"{self.args.encoded}_dec_{idx:04d}.png" + saved_encoded = getattr(self.transform_codec.args, 'encoded', None) + saved_decoded = getattr(self.transform_codec.args, 'decoded', None) + + self.transform_codec.args.encoded = enc_fn + self.transform_codec.args.decoded = dec_fn + self._captured_decode_output[0] = None + self.transform_codec.decode() + + self.transform_codec.args.encoded = saved_encoded + self.transform_codec.args.decoded = saved_decoded + + # Undo mapping: (pixel - 128) * 2; use captured output if available + if self._captured_decode_output[0] is not None: + residual_img_dec = self._captured_decode_output[0] + elif os.path.exists(dec_fn): + residual_img_dec = np.array(Image.open(dec_fn).convert("RGB")) + else: + raise FileNotFoundError( + f"Decoded residual not found at {dec_fn}. " + "The transform codec's decode() did not write the expected output." + ) + residual_rec = (residual_img_dec.astype(np.int16) - 128) * 2 + + # Reconstruct and cache + recon = np.clip(pred.astype(np.int16) + residual_rec, 0, 255).astype(np.uint8) + decoded_frames[idx] = recon + + mode_stats = [np.sum(mode == i) for i in range(3)] + logging.info(f" B-frame {idx}: residual={O_bytes} bytes, mv={mv_size} bytes, " + f"modes(fwd/bwd/bi)={mode_stats}") + + def decode(self): + """Decode MCTF encoded video.""" + logging.debug("trace") + + # Read encoding metadata if available (makes decode self-contained) + meta = f"{self.args.encoded}_meta.txt" + if os.path.exists(meta): + with open(meta, "r") as f: + self.original_prefix = f.readline().strip() + self.N_frames = int(f.readline().strip()) + self.height = int(f.readline().strip()) + self.width = int(f.readline().strip()) + self._meta_BPP = float(f.readline().strip()) + line = f.readline().strip() + if line: + self.total_output_size = int(line) + + # First, scan all frames to determine decoding order + frame_info = {} + idx = 0 + while True: + type_fn = f"{self.args.encoded}_{idx:04d}_type.txt" + + if not os.path.exists(type_fn): + if idx == 0: + logging.error("No encoded frames found") + return 0 + break + + with open(type_fn, 'r') as f: + frame_type = f.read().strip() + + frame_info[idx] = { + 'type': frame_type, + 'display_order': idx + } + idx += 1 + + total_frames = len(frame_info) + logging.info(f"Found {total_frames} encoded frames") + + # Decode frames in dependency order (handles hierarchical B-frames) + # Keep decoding frames whose references are ready + decoded_frames = {} + remaining_frames = set(range(total_frames)) + + while remaining_frames: + progress = False + + for idx in list(remaining_frames): + frame_type = frame_info[idx]['type'] + can_decode = False + + if frame_type == "I": + # I-frames have no dependencies + can_decode = True + + elif frame_type.startswith("P:"): + # P-frames depend on one reference + ref_idx = int(frame_type.split(":")[1]) + can_decode = ref_idx in decoded_frames + + elif frame_type.startswith("B:"): + # B-frames depend on two references + refs = frame_type.split(":")[1].split(",") + ref_past = int(refs[0]) + ref_future = int(refs[1]) + can_decode = (ref_past in decoded_frames and ref_future in decoded_frames) + + # Decode if ready + if can_decode: + if frame_type == "I": + self._decode_i_frame(idx, decoded_frames) + elif frame_type.startswith("P:"): + ref_idx = int(frame_type.split(":")[1]) + self._decode_p_frame(idx, ref_idx, decoded_frames) + elif frame_type.startswith("B:"): + refs = frame_type.split(":")[1].split(",") + ref_past = int(refs[0]) + ref_future = int(refs[1]) + self._decode_b_frame(idx, ref_past, ref_future, decoded_frames) + + remaining_frames.remove(idx) + progress = True + + # Check for deadlock + if not progress: + raise RuntimeError(f"Cannot decode remaining frames {remaining_frames} - " + f"circular dependency or missing references") + + logging.info(f"\n{'='*60}") + logging.info(f"DECODING COMPLETE") + logging.info(f"{'='*60}") + logging.info(f"Total frames decoded: {len(decoded_frames)}") + + # Write all decoded frames to disk with consistent naming + # (guarantees files exist at the expected paths for RMSE and ffmpeg) + decoded_prefix = getattr(self.args, 'decoded', '/tmp/decoded') + if decoded_prefix.endswith('.png'): + decoded_prefix = decoded_prefix[:-4] + for idx in range(len(decoded_frames)): + out_fn = f"{decoded_prefix}_{idx:04d}.png" + Image.fromarray(decoded_frames[idx]).save(out_fn) + logging.info(f"Wrote {len(decoded_frames)} frames to {decoded_prefix}_XXXX.png") + + # Calculate quality metrics (RMSE) if original frames are available + try: + from information_theory import distortion + + total_RMSE = 0 + frames_compared = 0 + + for idx in range(len(decoded_frames)): + original_fn = f"{self.original_prefix}_{idx:04d}.png" + decoded_fn = f"{decoded_prefix}_{idx:04d}.png" + + if os.path.exists(original_fn) and os.path.exists(decoded_fn): + original_img = np.array(Image.open(original_fn).convert("RGB")) + decoded_img = np.array(Image.open(decoded_fn).convert("RGB")) + + frame_RMSE = distortion.RMSE(original_img, decoded_img) + total_RMSE += frame_RMSE + frames_compared += 1 + + if idx < 3 or idx == len(decoded_frames) - 1: # Log first 3 and last frame + logging.info(f" Frame {idx} RMSE: {frame_RMSE:.4f}") + + if frames_compared > 0: + avg_RMSE = total_RMSE / frames_compared + + # Calculate BPP from encoding metadata + BPP = 0 + if hasattr(self, 'total_output_size') and self.total_output_size > 0 and hasattr(self, 'width') and hasattr(self, 'height'): + total_pixels = frames_compared * self.width * self.height + BPP = (self.total_output_size * 8) / total_pixels + elif hasattr(self, '_meta_BPP') and self._meta_BPP > 0: + BPP = self._meta_BPP + else: + logging.warning("Could not determine BPP from encoding metadata") + + lrd = getattr(self, 'lambda_rd', 1.0) + J = avg_RMSE + lrd * BPP + + logging.info(f"\n{'='*60}") + logging.info(f"QUALITY METRICS") + logging.info(f"{'='*60}") + logging.info(f"Frames compared: {frames_compared}") + logging.info(f"Average RMSE (D): {avg_RMSE:.6f}") + logging.info(f"Bits Per Pixel (R): {BPP:.6f}") + logging.info(f"λ (lambda_rd): {lrd:.4f}") + logging.info(f"Rate-Distortion Cost (J = D + λ·R): {J:.6f}") + logging.info(f"{'='*60}\n") + + except ImportError: + logging.warning("information_theory module not available, skipping RMSE calculation") + except Exception as e: + logging.warning(f"Error calculating metrics: {e}") + + # Create output video + logging.info("Creating output video...") + + # Use ffmpeg to combine frames with optimized settings + import subprocess + try: + # Verify decoded frames actually exist before calling ffmpeg + first_frame = f"{decoded_prefix}_0000.png" + logging.info(f"Decoded prefix: {decoded_prefix}") + logging.info(f"First frame exists? {os.path.exists(first_frame)}") + if not os.path.exists(first_frame): + logging.error(f"Cannot create video: first decoded frame not found at {first_frame}") + return 0 + + output_mp4 = f'{decoded_prefix}.mp4' + cmd = [ + 'ffmpeg', '-y', + '-framerate', '30', + '-i', f'{decoded_prefix}_%04d.png', + '-c:v', 'libx264', + '-crf', '18', # Near-lossless quality (0=lossless, 51=worst, 18=visually lossless) + '-preset', 'medium', # Encoding speed (slower = better compression) + '-pix_fmt', 'yuv420p', + output_mp4 + ] + + # Debug: show command + logging.info(f"Running ffmpeg command: {' '.join(cmd)}") + + result = subprocess.run(cmd, check=True, capture_output=True, text=True) + + # Get output video size + if os.path.exists(output_mp4): + mp4_size = os.path.getsize(output_mp4) + logging.info(f"Video saved to {output_mp4}") + logging.info(f"Output MP4 size: {mp4_size} bytes ({mp4_size/1024/1024:.2f} MB)") + + # Compare with encoded size (if available from encoding metadata) + if hasattr(self, 'total_output_size') and self.total_output_size > 0: + ratio = mp4_size / self.total_output_size + logging.info(f"MP4 vs Encoded ratio: {ratio:.2f}x") + if ratio > 2: + logging.warning(f"MP4 is {ratio:.2f}x larger than encoded data!") + else: + # Try to use metadata loaded at start of decode() + if hasattr(self, '_meta_BPP') and self._meta_BPP > 0 and hasattr(self, 'width') and hasattr(self, 'height') and hasattr(self, 'N_frames'): + total_pixels = self.N_frames * self.height * self.width + encoded_size = int((self._meta_BPP * total_pixels) / 8) + if encoded_size > 0: + ratio = mp4_size / encoded_size + logging.info(f"Encoded data size: {encoded_size} bytes ({encoded_size/1024/1024:.2f} MB)") + logging.info(f"MP4 vs Encoded ratio: {ratio:.2f}x") + if ratio > 2: + logging.info(f"NOTE: MP4 is {ratio:.2f}x larger - this is normal for H.264 re-encoding") + else: + logging.debug("Could not calculate encoded size for comparison") + + # Show ffmpeg output if debugging + if result.stderr: + logging.debug(f"FFmpeg output: {result.stderr}") + + except subprocess.CalledProcessError as e: + logging.error(f"Failed to create video: {e}") + logging.error(f"FFmpeg stderr: {e.stderr}") + logging.error(f"FFmpeg stdout: {e.stdout}") + except FileNotFoundError: + logging.warning("ffmpeg not found, skipping video creation") + + return 0 + + def _decode_i_frame(self, idx, decoded_frames): + """Decode I-frame.""" + enc_fn = f"{self.args.encoded}_{idx:04d}" + dec_fn = f"{getattr(self.args, 'decoded', '/tmp/decoded')}_{idx:04d}.png" + + logging.info(f"Decoding I-frame {idx}") + saved_encoded = self.transform_codec.args.encoded + saved_decoded = self.transform_codec.args.decoded + + self.transform_codec.args.encoded = enc_fn + self.transform_codec.args.decoded = dec_fn + self.transform_codec.decode() + + self.transform_codec.args.encoded = saved_encoded + self.transform_codec.args.decoded = saved_decoded + + img = np.array(Image.open(dec_fn).convert("RGB")) + decoded_frames[idx] = img + + def _decode_p_frame(self, idx, ref_idx, decoded_frames): + """Decode P-frame using VCF transform.""" + logging.info(f"Decoding P-frame {idx} (ref={ref_idx})") + + enc_fn = f"{self.args.encoded}_{idx:04d}" + + # Load motion vectors + mv_data = np.load(f"{enc_fn}_mv.npz") + mv_field = mv_data['mv'] + + # Decode residual using transform codec + residual_fn = f"{self.args.encoded}_dec_res_{idx:04d}.png" + saved_encoded = self.transform_codec.args.encoded + saved_decoded = self.transform_codec.args.decoded + + self.transform_codec.args.encoded = enc_fn + self.transform_codec.args.decoded = residual_fn + self.transform_codec.decode() + + self.transform_codec.args.encoded = saved_encoded + self.transform_codec.args.decoded = saved_decoded + + # Undo /2+128 mapping: (pixel - 128) * 2 + residual = (np.array(Image.open(residual_fn).convert("RGB")).astype(np.int16) - 128) * 2 + + # Motion compensation + ref_frame = decoded_frames[ref_idx] + pred = motion_compensate(ref_frame, mv_field, self.block_size) + + # Reconstruct + recon = np.clip(pred.astype(np.int16) + residual, 0, 255).astype(np.uint8) + decoded_frames[idx] = recon + + def _decode_b_frame(self, idx, ref_past_idx, ref_future_idx, decoded_frames): + """Decode B-frame using VCF transform.""" + logging.info(f"Decoding B-frame {idx} (refs={ref_past_idx},{ref_future_idx})") + + enc_fn = f"{self.args.encoded}_{idx:04d}" + + # Load motion vectors and mode + mv_data = np.load(f"{enc_fn}_mv.npz") + mv_fwd = mv_data['mv_fwd'] + mv_bwd = mv_data['mv_bwd'] + mode = mv_data['mode'] + + # Decode residual using transform codec + residual_fn = f"{self.args.encoded}_dec_res_{idx:04d}.png" + saved_encoded = self.transform_codec.args.encoded + saved_decoded = self.transform_codec.args.decoded + + self.transform_codec.args.encoded = enc_fn + self.transform_codec.args.decoded = residual_fn + self.transform_codec.decode() + + self.transform_codec.args.encoded = saved_encoded + self.transform_codec.args.decoded = saved_decoded + + # Undo /2+128 mapping: (pixel - 128) * 2 + residual = (np.array(Image.open(residual_fn).convert("RGB")).astype(np.int16) - 128) * 2 + + # Motion compensation + ref_past = decoded_frames[ref_past_idx] + ref_future = decoded_frames[ref_future_idx] + pred = motion_compensate_bidirectional( + ref_past, ref_future, mv_fwd, mv_bwd, mode, self.block_size + ) + + # Reconstruct + recon = np.clip(pred.astype(np.int16) + residual, 0, 255).astype(np.uint8) + decoded_frames[idx] = recon + +# ============================================================================= +# Main +# ============================================================================= + +if __name__ == "__main__": + main.main(parser.parser, logging, CoDec) \ No newline at end of file