From 2e602801b372b0b68111316b89f567213e3ea378 Mon Sep 17 00:00:00 2001 From: Kazumasa Mitsunari Date: Tue, 29 Aug 2017 20:58:47 +0900 Subject: [PATCH] Add sound manager initial source code First version 2017/08/29 SoundManager consists of main 4 parts 1. doc Document of sound manager and audio manager architecture This describes application sequence Please open ApplicationGuide.md with browser 2. include Contains API of libsoundmanager LibSoundmanager API is going to be modified, so please don't use for now Update will be done in near future 3. soundmanager_binding Contains soundmanager binding. This is the service midleware If installing this, soundmanager is automatically launched by AppFW(systemd) 4. sample Contains sample applications. These applications follow the AudioManager sequence and using soundmanager binding Change-Id: I75b6c5c652e1dc00b39bc499a2ee6bf1e2aeaf6d Signed-off-by: Kazumasa Mitsunari --- CMakeLists.txt | 50 + LICENSE | 54 + cmake/modules/Findgtest.cmake | 38 + conf/soundmanager-dbus.conf | 18 + include/CMakeLists.txt | 18 + include/libsoundmanager/libsoundmanager.hpp | 108 + libsoundmanager/CMakeLists.txt | 57 + libsoundmanager/libsoundmanager.cpp | 447 + libsoundmanager/test.cpp | 165 + libsoundmanager/test/CMakeLists.txt | 30 + libsoundmanager/test/gtest_libsoundmanager.cpp | 49 + package/config.xml | 20 + package/icon.svg | 283 + sample/mediaplayer/.gitignore | 1 + sample/mediaplayer/.gitreview | 5 + sample/mediaplayer/LICENSE | 54 + sample/mediaplayer/app/MediaPlayer.qml | 415 + sample/mediaplayer/app/api/BluetoothManager.qml | 179 + sample/mediaplayer/app/api/LightMediaScanner.qml | 116 + sample/mediaplayer/app/app.pri | 21 + sample/mediaplayer/app/app.pro | 16 + .../mediaplayer/app/config.tests/libhomescreen.cpp | 7 + .../mediaplayer/app/config.tests/libhomescreen.pro | 5 + .../app/images/AGL_MediaPlayer_AlbumArtwork.svg | 71 + .../app/images/AGL_MediaPlayer_BackArrow.svg | 56 + .../images/AGL_MediaPlayer_Bluetooth_Active.svg | 84 + .../images/AGL_MediaPlayer_Bluetooth_Inactive.svg | 59 + .../app/images/AGL_MediaPlayer_CD_Active.svg | 84 + .../app/images/AGL_MediaPlayer_CD_Inactive.svg | 59 + .../app/images/AGL_MediaPlayer_DividingLine.svg | 60 + .../app/images/AGL_MediaPlayer_ForwardArrow.svg | 56 + .../app/images/AGL_MediaPlayer_Loop_Active.svg | 58 + .../app/images/AGL_MediaPlayer_Loop_Inactive.svg | 58 + .../app/images/AGL_MediaPlayer_Player_Pause.svg | 67 + .../app/images/AGL_MediaPlayer_Player_Play.svg | 67 + .../AGL_MediaPlayer_PlaylistToggle_Active.svg | 89 + .../AGL_MediaPlayer_PlaylistToggle_Inactive.svg | 89 + .../app/images/AGL_MediaPlayer_Playlist_Active.svg | 166 + .../images/AGL_MediaPlayer_Playlist_Inactive.svg | 89 + .../app/images/AGL_MediaPlayer_Radio_Active.svg | 299 + .../app/images/AGL_MediaPlayer_Radio_Inactive.svg | 131 + .../app/images/AGL_MediaPlayer_Shuffle_Active.svg | 56 + .../images/AGL_MediaPlayer_Shuffle_Inactive.svg | 56 + sample/mediaplayer/app/images/Albums_Active.svg | 155 + sample/mediaplayer/app/images/Albums_Inactive.svg | 95 + sample/mediaplayer/app/images/DividingLine.svg | 58 + sample/mediaplayer/app/images/GreenLine.svg | 59 + sample/mediaplayer/app/images/Music_Active.svg | 63 + sample/mediaplayer/app/images/Music_Inactive.svg | 63 + sample/mediaplayer/app/images/Podcasts_Active.svg | 77 + .../mediaplayer/app/images/Podcasts_Inactive.svg | 65 + sample/mediaplayer/app/images/Popup_Highlight.svg | 67 + sample/mediaplayer/app/images/Popup_PauseIcon.svg | 65 + sample/mediaplayer/app/images/Popup_PlayIcon.svg | 65 + .../mediaplayer/app/images/Popup_VerticalLine.svg | 69 + sample/mediaplayer/app/images/X.svg | 64 + sample/mediaplayer/app/images/images.qrc | 37 + sample/mediaplayer/app/libsmwrapper.cpp | 157 + sample/mediaplayer/app/libsmwrapper.h | 58 + sample/mediaplayer/app/main.cpp | 166 + sample/mediaplayer/app/mediaplayer.qrc | 7 + sample/mediaplayer/app/playlistwithmetadata.cpp | 227 + sample/mediaplayer/app/playlistwithmetadata.h | 55 + sample/mediaplayer/binding/binding.pri | 6 + sample/mediaplayer/binding/binding.pro | 16 + sample/mediaplayer/binding/export.map | 1 + .../binding/gdbus/api/org.lightmediascanner.xml | 75 + .../binding/gdbus/generate_interfaces.sh | 9 + .../binding/gdbus/lightmediascanner_interface.c | 5755 ++++++++ .../binding/gdbus/lightmediascanner_interface.h | 896 ++ sample/mediaplayer/binding/mediaplayer-api.c | 173 + sample/mediaplayer/binding/mediaplayer-manager.c | 294 + sample/mediaplayer/binding/mediaplayer-manager.h | 103 + sample/mediaplayer/mediaplayer.pro | 3 + sample/mediaplayer/package/config.xml | 19 + sample/mediaplayer/package/icon.svg | 279 + sample/mediaplayer/package/package.pro | 19 + sample/radio/COPYING | 339 + sample/radio/LICENSE | 54 + sample/radio/app/PresetDataObject.cpp | 63 + sample/radio/app/PresetDataObject.h | 57 + sample/radio/app/Radio.qml | 350 + sample/radio/app/api/Binding.qml | 200 + sample/radio/app/app.pri | 12 + sample/radio/app/app.pro | 14 + .../config.tests/libhomescreen/libhomescreen.cpp | 8 + .../config.tests/libhomescreen/libhomescreen.pro | 5 + .../radio/app/images/AGL_MediaPlayer_BackArrow.svg | 56 + .../app/images/AGL_MediaPlayer_ForwardArrow.svg | 56 + .../app/images/AGL_MediaPlayer_Player_Pause.svg | 67 + .../app/images/AGL_MediaPlayer_Player_Play.svg | 67 + sample/radio/app/images/FM_Icons_AM.svg | 71 + sample/radio/app/images/FM_Icons_FM.svg | 65 + sample/radio/app/images/HMI_Radio_Equalizer.svg | 335 + sample/radio/app/images/Radio_Active_Icon.svg | 299 + sample/radio/app/images/images.qrc | 12 + sample/radio/app/libsmwrapper.cpp | 157 + sample/radio/app/libsmwrapper.h | 58 + sample/radio/app/main.cpp | 152 + sample/radio/app/radio.qrc | 6 + sample/radio/binding/binding.pri | 6 + sample/radio/binding/binding.pro | 11 + sample/radio/binding/convenience/convenience.c | 304 + sample/radio/binding/convenience/convenience.h | 142 + sample/radio/binding/export.map | 1 + sample/radio/binding/radio-binding.c | 493 + sample/radio/binding/radio_impl.h | 76 + sample/radio/binding/radio_impl_rtlsdr.c | 254 + sample/radio/binding/radio_output.c | 294 + sample/radio/binding/radio_output.h | 31 + sample/radio/binding/rtl_fm.c | 1267 ++ sample/radio/binding/rtl_fm.h | 70 + sample/radio/compose_dummy.sh | 19 + sample/radio/package/config.xml | 19 + sample/radio/package/icon.svg | 14329 +++++++++++++++++++ sample/radio/package/package.pro | 19 + sample/radio/radio.pro | 3 + sample/radio_qml/COPYING | 339 + sample/radio_qml/LICENSE | 54 + sample/radio_qml/app/PresetDataObject.cpp | 63 + sample/radio_qml/app/PresetDataObject.h | 57 + sample/radio_qml/app/Radio.qml | 279 + sample/radio_qml/app/api/Binding.qml | 230 + sample/radio_qml/app/api/BindingSoundManager.qml | 146 + sample/radio_qml/app/app.pri | 12 + sample/radio_qml/app/app.pro | 11 + .../config.tests/libhomescreen/libhomescreen.cpp | 8 + .../config.tests/libhomescreen/libhomescreen.pro | 5 + .../app/images/AGL_MediaPlayer_BackArrow.svg | 56 + .../app/images/AGL_MediaPlayer_ForwardArrow.svg | 56 + .../app/images/AGL_MediaPlayer_Player_Pause.svg | 67 + .../app/images/AGL_MediaPlayer_Player_Play.svg | 67 + sample/radio_qml/app/images/FM_Icons_AM.svg | 71 + sample/radio_qml/app/images/FM_Icons_FM.svg | 65 + .../radio_qml/app/images/HMI_Radio_Equalizer.svg | 335 + sample/radio_qml/app/images/Radio_Active_Icon.svg | 299 + sample/radio_qml/app/images/images.qrc | 12 + sample/radio_qml/app/main.cpp | 115 + sample/radio_qml/app/radio.qrc | 7 + sample/radio_qml/binding/binding.pri | 6 + sample/radio_qml/binding/binding.pro | 11 + sample/radio_qml/binding/convenience/convenience.c | 304 + sample/radio_qml/binding/convenience/convenience.h | 142 + sample/radio_qml/binding/export.map | 1 + sample/radio_qml/binding/radio-binding.c | 493 + sample/radio_qml/binding/radio_impl.h | 76 + sample/radio_qml/binding/radio_impl_rtlsdr.c | 254 + sample/radio_qml/binding/radio_output.c | 294 + sample/radio_qml/binding/radio_output.h | 31 + sample/radio_qml/binding/rtl_fm.c | 1267 ++ sample/radio_qml/binding/rtl_fm.h | 70 + sample/radio_qml/package/.config.xml.swp | Bin 0 -> 12288 bytes sample/radio_qml/package/config.xml | 18 + sample/radio_qml/package/icon.svg | 14329 +++++++++++++++++++ sample/radio_qml/package/package.pro | 19 + sample/radio_qml/radio.pro | 3 + soundmanager.pc.in | 12 + soundmanager_binging/CMakeLists.txt | 54 + .../dbus/audio_manager_interface.c | 9360 ++++++++++++ .../dbus/audio_manager_interface.h | 1525 ++ soundmanager_binging/dbus/command_interface.xml | 55 + soundmanager_binging/dbus/generate_dbus.sh | 24 + soundmanager_binging/dbus/routing_interface.xml | 85 + .../dbus/sound_manager_interface.xml | 36 + soundmanager_binging/export.map | 1 + soundmanager_binging/sm-error.h | 52 + soundmanager_binging/sm-helper.c | 231 + soundmanager_binging/sm-helper.h | 93 + soundmanager_binging/soundmanager.c | 1485 ++ test/call-sm-binding-method_test.sh | 17 + test/dbus-call-connect-test.sh | 12 + test/dbus-call-test.sh | 17 + test/sm-binding-test-gdb.sh | 21 + test/sm-binding-test.sh | 21 + 174 files changed, 65844 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 cmake/modules/Findgtest.cmake create mode 100644 conf/soundmanager-dbus.conf create mode 100644 include/CMakeLists.txt create mode 100644 include/libsoundmanager/libsoundmanager.hpp create mode 100644 libsoundmanager/CMakeLists.txt create mode 100644 libsoundmanager/libsoundmanager.cpp create mode 100644 libsoundmanager/test.cpp create mode 100644 libsoundmanager/test/CMakeLists.txt create mode 100644 libsoundmanager/test/gtest_libsoundmanager.cpp create mode 100644 package/config.xml create mode 100644 package/icon.svg create mode 100644 sample/mediaplayer/.gitignore create mode 100644 sample/mediaplayer/.gitreview create mode 100644 sample/mediaplayer/LICENSE create mode 100644 sample/mediaplayer/app/MediaPlayer.qml create mode 100644 sample/mediaplayer/app/api/BluetoothManager.qml create mode 100644 sample/mediaplayer/app/api/LightMediaScanner.qml create mode 100644 sample/mediaplayer/app/app.pri create mode 100644 sample/mediaplayer/app/app.pro create mode 100644 sample/mediaplayer/app/config.tests/libhomescreen.cpp create mode 100644 sample/mediaplayer/app/config.tests/libhomescreen.pro create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_AlbumArtwork.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_BackArrow.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_DividingLine.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_ForwardArrow.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Pause.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Play.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Inactive.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Active.svg create mode 100644 sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Inactive.svg create mode 100644 sample/mediaplayer/app/images/Albums_Active.svg create mode 100644 sample/mediaplayer/app/images/Albums_Inactive.svg create mode 100644 sample/mediaplayer/app/images/DividingLine.svg create mode 100644 sample/mediaplayer/app/images/GreenLine.svg create mode 100644 sample/mediaplayer/app/images/Music_Active.svg create mode 100644 sample/mediaplayer/app/images/Music_Inactive.svg create mode 100644 sample/mediaplayer/app/images/Podcasts_Active.svg create mode 100644 sample/mediaplayer/app/images/Podcasts_Inactive.svg create mode 100644 sample/mediaplayer/app/images/Popup_Highlight.svg create mode 100644 sample/mediaplayer/app/images/Popup_PauseIcon.svg create mode 100644 sample/mediaplayer/app/images/Popup_PlayIcon.svg create mode 100644 sample/mediaplayer/app/images/Popup_VerticalLine.svg create mode 100644 sample/mediaplayer/app/images/X.svg create mode 100644 sample/mediaplayer/app/images/images.qrc create mode 100644 sample/mediaplayer/app/libsmwrapper.cpp create mode 100644 sample/mediaplayer/app/libsmwrapper.h create mode 100644 sample/mediaplayer/app/main.cpp create mode 100644 sample/mediaplayer/app/mediaplayer.qrc create mode 100644 sample/mediaplayer/app/playlistwithmetadata.cpp create mode 100644 sample/mediaplayer/app/playlistwithmetadata.h create mode 100644 sample/mediaplayer/binding/binding.pri create mode 100644 sample/mediaplayer/binding/binding.pro create mode 100644 sample/mediaplayer/binding/export.map create mode 100644 sample/mediaplayer/binding/gdbus/api/org.lightmediascanner.xml create mode 100755 sample/mediaplayer/binding/gdbus/generate_interfaces.sh create mode 100644 sample/mediaplayer/binding/gdbus/lightmediascanner_interface.c create mode 100644 sample/mediaplayer/binding/gdbus/lightmediascanner_interface.h create mode 100644 sample/mediaplayer/binding/mediaplayer-api.c create mode 100644 sample/mediaplayer/binding/mediaplayer-manager.c create mode 100644 sample/mediaplayer/binding/mediaplayer-manager.h create mode 100644 sample/mediaplayer/mediaplayer.pro create mode 100644 sample/mediaplayer/package/config.xml create mode 100644 sample/mediaplayer/package/icon.svg create mode 100644 sample/mediaplayer/package/package.pro create mode 100644 sample/radio/COPYING create mode 100644 sample/radio/LICENSE create mode 100644 sample/radio/app/PresetDataObject.cpp create mode 100644 sample/radio/app/PresetDataObject.h create mode 100644 sample/radio/app/Radio.qml create mode 100644 sample/radio/app/api/Binding.qml create mode 100644 sample/radio/app/app.pri create mode 100644 sample/radio/app/app.pro create mode 100644 sample/radio/app/config.tests/libhomescreen/libhomescreen.cpp create mode 100644 sample/radio/app/config.tests/libhomescreen/libhomescreen.pro create mode 100644 sample/radio/app/images/AGL_MediaPlayer_BackArrow.svg create mode 100644 sample/radio/app/images/AGL_MediaPlayer_ForwardArrow.svg create mode 100644 sample/radio/app/images/AGL_MediaPlayer_Player_Pause.svg create mode 100644 sample/radio/app/images/AGL_MediaPlayer_Player_Play.svg create mode 100644 sample/radio/app/images/FM_Icons_AM.svg create mode 100644 sample/radio/app/images/FM_Icons_FM.svg create mode 100644 sample/radio/app/images/HMI_Radio_Equalizer.svg create mode 100644 sample/radio/app/images/Radio_Active_Icon.svg create mode 100644 sample/radio/app/images/images.qrc create mode 100644 sample/radio/app/libsmwrapper.cpp create mode 100644 sample/radio/app/libsmwrapper.h create mode 100644 sample/radio/app/main.cpp create mode 100644 sample/radio/app/radio.qrc create mode 100644 sample/radio/binding/binding.pri create mode 100644 sample/radio/binding/binding.pro create mode 100644 sample/radio/binding/convenience/convenience.c create mode 100644 sample/radio/binding/convenience/convenience.h create mode 100644 sample/radio/binding/export.map create mode 100644 sample/radio/binding/radio-binding.c create mode 100644 sample/radio/binding/radio_impl.h create mode 100644 sample/radio/binding/radio_impl_rtlsdr.c create mode 100644 sample/radio/binding/radio_output.c create mode 100644 sample/radio/binding/radio_output.h create mode 100644 sample/radio/binding/rtl_fm.c create mode 100644 sample/radio/binding/rtl_fm.h create mode 100755 sample/radio/compose_dummy.sh create mode 100644 sample/radio/package/config.xml create mode 100644 sample/radio/package/icon.svg create mode 100644 sample/radio/package/package.pro create mode 100644 sample/radio/radio.pro create mode 100644 sample/radio_qml/COPYING create mode 100644 sample/radio_qml/LICENSE create mode 100644 sample/radio_qml/app/PresetDataObject.cpp create mode 100644 sample/radio_qml/app/PresetDataObject.h create mode 100644 sample/radio_qml/app/Radio.qml create mode 100644 sample/radio_qml/app/api/Binding.qml create mode 100644 sample/radio_qml/app/api/BindingSoundManager.qml create mode 100644 sample/radio_qml/app/app.pri create mode 100644 sample/radio_qml/app/app.pro create mode 100644 sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.cpp create mode 100644 sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.pro create mode 100644 sample/radio_qml/app/images/AGL_MediaPlayer_BackArrow.svg create mode 100644 sample/radio_qml/app/images/AGL_MediaPlayer_ForwardArrow.svg create mode 100644 sample/radio_qml/app/images/AGL_MediaPlayer_Player_Pause.svg create mode 100644 sample/radio_qml/app/images/AGL_MediaPlayer_Player_Play.svg create mode 100644 sample/radio_qml/app/images/FM_Icons_AM.svg create mode 100644 sample/radio_qml/app/images/FM_Icons_FM.svg create mode 100644 sample/radio_qml/app/images/HMI_Radio_Equalizer.svg create mode 100644 sample/radio_qml/app/images/Radio_Active_Icon.svg create mode 100644 sample/radio_qml/app/images/images.qrc create mode 100644 sample/radio_qml/app/main.cpp create mode 100644 sample/radio_qml/app/radio.qrc create mode 100644 sample/radio_qml/binding/binding.pri create mode 100644 sample/radio_qml/binding/binding.pro create mode 100644 sample/radio_qml/binding/convenience/convenience.c create mode 100644 sample/radio_qml/binding/convenience/convenience.h create mode 100644 sample/radio_qml/binding/export.map create mode 100644 sample/radio_qml/binding/radio-binding.c create mode 100644 sample/radio_qml/binding/radio_impl.h create mode 100644 sample/radio_qml/binding/radio_impl_rtlsdr.c create mode 100644 sample/radio_qml/binding/radio_output.c create mode 100644 sample/radio_qml/binding/radio_output.h create mode 100644 sample/radio_qml/binding/rtl_fm.c create mode 100644 sample/radio_qml/binding/rtl_fm.h create mode 100644 sample/radio_qml/package/.config.xml.swp create mode 100644 sample/radio_qml/package/config.xml create mode 100644 sample/radio_qml/package/icon.svg create mode 100644 sample/radio_qml/package/package.pro create mode 100644 sample/radio_qml/radio.pro create mode 100644 soundmanager.pc.in create mode 100644 soundmanager_binging/CMakeLists.txt create mode 100644 soundmanager_binging/dbus/audio_manager_interface.c create mode 100644 soundmanager_binging/dbus/audio_manager_interface.h create mode 100644 soundmanager_binging/dbus/command_interface.xml create mode 100755 soundmanager_binging/dbus/generate_dbus.sh create mode 100644 soundmanager_binging/dbus/routing_interface.xml create mode 100644 soundmanager_binging/dbus/sound_manager_interface.xml create mode 100644 soundmanager_binging/export.map create mode 100644 soundmanager_binging/sm-error.h create mode 100644 soundmanager_binging/sm-helper.c create mode 100644 soundmanager_binging/sm-helper.h create mode 100644 soundmanager_binging/soundmanager.c create mode 100755 test/call-sm-binding-method_test.sh create mode 100755 test/dbus-call-connect-test.sh create mode 100755 test/dbus-call-test.sh create mode 100755 test/sm-binding-test-gdb.sh create mode 100755 test/sm-binding-test.sh diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..083933a --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,50 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +project(SoundManager C CXX) + +cmake_minimum_required(VERSION 3.0) + +set(PROJECT_NAME "Sound Manager binding and client library") +set(PROJECT_VERSION "1.0") +set(PROJECT_PRETTY_NAME "SM") +set(PROJECT_DESCRIPTION " Sound Manager binding and client library\ + Binder communicates with Audio Manager and client library to hide IPC for Application") +set(PROJECT_URL "") +set(PROJECT_INCLUDEDIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}) +set(PROJECT_LIBDIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}) +set(SOUNDMANAGER_INCLUDEDIR ${PROJECT_INCLUDEDIR}/libsoundmanager) +set(binding_install_dir ${PREFIX}/lib/soundmanager) +set(PROJECT_BINDINGDIR ${binding_install_dir}) +set(LIBSM_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include) + +# get pkgconfig +INCLUDE(FindPkgConfig) +link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined) + +set(CMAKE_BUILD_TYPE Debug) +set(DEBUGMODE "1") +add_definitions(-DDEBUGMODE) + +add_subdirectory(soundmanager_binging) +add_subdirectory(libsoundmanager) +add_subdirectory(include) + +#generate configure file +configure_file(soundmanager.pc.in soundmanager.pc @ONLY) +INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/soundmanager.pc + DESTINATION + ${CMAKE_INSTALL_LIBDIR}/pkgconfig) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..31c692a --- /dev/null +++ b/LICENSE @@ -0,0 +1,54 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/cmake/modules/Findgtest.cmake b/cmake/modules/Findgtest.cmake new file mode 100644 index 0000000..8ea850f --- /dev/null +++ b/cmake/modules/Findgtest.cmake @@ -0,0 +1,38 @@ +SET(MODULE_NAME gtest) + +SET(${MODULE_NAME}_FOUND FALSE) + +FIND_PATH(${MODULE_NAME}_INCLUDE_DIRS + NAMES gtest/gtest.h + PATHS /usr/include /usr/local/include +) + +FIND_LIBRARY(LIB_GTEST + NAMES gtest + PATHS /usr/lib + /usr/lib64 + /usr/local/lib + /usr/local/lib64 +) + +FIND_LIBRARY(LIB_GTEST_MAIN + NAMES gtest_main + PATHS /usr/lib + /usr/lib64 + /usr/local/lib + /usr/local/lib64 +) + +IF(LIB_GTEST AND LIB_GTEST_MAIN) + SET(${MODULE_NAME}_FOUND TRUE) + SET(${MODULE_NAME}_LIBRARIES ${LIB_GTEST} ${LIB_GTEST_MAIN}) +ENDIF() + +MARK_AS_ADVANCED( + ${MODULE_NAME}_FOUND + ${MODULE_NAME}_INCLUDE_DIRS + ${MODULE_NAME}_LIBRARIES +) + +MESSAGE(STATUS "${MODULE_NAME}_INCLUDE_DIRS: ${${MODULE_NAME}_INCLUDE_DIRS}") +MESSAGE(STATUS "${MODULE_NAME}_LIBRARIES: ${${MODULE_NAME}_LIBRARIES}") diff --git a/conf/soundmanager-dbus.conf b/conf/soundmanager-dbus.conf new file mode 100644 index 0000000..cacb60e --- /dev/null +++ b/conf/soundmanager-dbus.conf @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt new file mode 100644 index 0000000..fe9a09c --- /dev/null +++ b/include/CMakeLists.txt @@ -0,0 +1,18 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + + +INSTALL(DIRECTORY libsoundmanager DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) \ No newline at end of file diff --git a/include/libsoundmanager/libsoundmanager.hpp b/include/libsoundmanager/libsoundmanager.hpp new file mode 100644 index 0000000..90ac572 --- /dev/null +++ b/include/libsoundmanager/libsoundmanager.hpp @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBSOUNDMANAGER_H +#define LIBSOUNDMANAGER_H +#include +#include +#include +#include +#include +#include +extern "C" +{ +#include +#include +#include +} + +using namespace am; + +const std::vector api_list{ + std::string("connect"), + std::string("disconnect"), + std::string("setVolume"), + std::string("volumeStep"), + std::string("setSinkMuteState"), + std::string("getListMainConnections"), + std::string("ackConnect"), + std::string("ackDisconnect"), + std::string("ackSetSourceState"), + std::string("registerSource"), + std::string("registerDomain"), + std::string("deregisterSource"), + std::string("subscribe"), + std::string("unsubscribe") +}; + +const std::vector event_list{ + std::string("newMainConnection"), + std::string("volumeChanged"), + std::string("removedMainConnection"), + std::string("sinkMuteStateChanged"), + std::string("mainConnectionStateChanged"), + std::string("setRoutingReady"), + std::string("setRoutingRundown"), + std::string("asyncConnect"), + std::string("asyncSetSourceState") +}; + +class LibSoundmanager +{ +private: + LibSoundmanager() = delete; +public: + LibSoundmanager(const int port, const std::string& token); + //LibSoundmanager(const std::string& uri); + ~LibSoundmanager(); + + /* Method */ + void register_callback( + void (*event_cb)(const std::string& event, struct json_object* event_contents), + void (*reply_cb)(struct json_object* reply_contents), + void (*hangup_cb)(void) = nullptr); + int run_eventloop(); + int call(const std::string& verb, struct json_object* arg); + int call(const char* verb, struct json_object* arg); + int subscribe(const std::string& event_name); + int unsubscribe(const std::string& event_name); + /*const struct afb_wsj1* get_websocket_handler(); + const struct sd_event* get_sd_event();*/ + +private: + int initialize_websocket(); + void (*onEvent)(const std::string& event, struct json_object* event_contents); + void (*onReply)(struct json_object* reply); + void (*onHangup)(void); + + struct afb_wsj1* sp_websock; + struct afb_wsj1_itf minterface; + sd_event* mploop; + std::string muri; + int mport = 12345; + std::string mtoken = "123456"; + + am_Error_e connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am::am_mainConnectionID_t& mainConnectionID); + am_Error_e disconnect(const am_mainConnectionID_t mainConnectionID); + +public: + /* Don't use/ Internal only */ + void on_hangup(void *closure, struct afb_wsj1 *wsj); + void on_call(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg); + void on_event(void *closure, const char *event, struct afb_wsj1_msg *msg); + void on_reply(void *closure, struct afb_wsj1_msg *msg); +}; +#endif /* LIBSOUNDMANAGER_H */ diff --git a/libsoundmanager/CMakeLists.txt b/libsoundmanager/CMakeLists.txt new file mode 100644 index 0000000..acf98de --- /dev/null +++ b/libsoundmanager/CMakeLists.txt @@ -0,0 +1,57 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + + +cmake_minimum_required(VERSION 3.0) + +set(TARGET_LIBSM soundmanager) +add_definitions("-std=c++11") + +pkg_check_modules(libsm_depends json-c libafbwsc libsystemd audiomanager) +set(libsm_sources libsoundmanager.cpp) + +include_directories(${LIBSM_INCLUDE_DIR}) +link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined) + +add_library(${TARGET_LIBSM} SHARED ${libsm_sources}) +target_compile_options(${TARGET_LIBSM} PUBLIC ${libsm_depends_CFLAGS}) + +if(DEFINED DEBUGMODE) + target_compile_options(${TARGET_LIBSM} PRIVATE -g -O0) +else(DEFINED DEBUGMODE) + target_compile_options(${TARGET_LIBSM} PRIVATE -g -O2) +endif(DEFINED DEBUGMODE) + +include_directories(${TARGET_LIBSM} ${libsm_depends_INCLUDE_DIRS}) +target_link_libraries(${TARGET_LIBSM} afbwsc -lpthread ${link_libraries} ${libsm_depends_LIBRARIES}) + +INSTALL(TARGETS ${TARGET_LIBSM} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) + +##################### +pkg_check_modules(test_depends glib-2.0 gio-2.0 gio-unix-2.0) +add_executable(libsoundmanager-demo test.cpp) +include_directories(libsoundmanager-demo ${test_depends_INCLUDE_DIRS}) +TARGET_LINK_LIBRARIES(libsoundmanager-demo + soundmanager + ${link_libraries} + -lpthread + ${test_depends_LIBRARIES} + ${libsm_depends_LIBRARIES} +) +##################### +add_subdirectory(test) + diff --git a/libsoundmanager/libsoundmanager.cpp b/libsoundmanager/libsoundmanager.cpp new file mode 100644 index 0000000..9f77723 --- /dev/null +++ b/libsoundmanager/libsoundmanager.cpp @@ -0,0 +1,447 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include + +#define ELOG(args,...) _ELOG(__FUNCTION__,__LINE__,args,##__VA_ARGS__) +#define DLOG(args,...) _DLOG(__FUNCTION__,__LINE__,args,##__VA_ARGS__) + +using namespace std; + +static void _DLOG(const char* func, const int line, const char* log, ...); +static void _ELOG(const char* func, const int line, const char* log, ...); +static bool has_verb(const string& verb); +static const char API[] = "soundmanager"; + +static void _on_hangup_static(void *closure, struct afb_wsj1 *wsj) +{ + static_cast(closure)->on_hangup(NULL,wsj); +} + +static void _on_call_static(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg) +{ + /* LibSoundmanager is not called from other process */ +} + +static void _on_event_static(void* closure, const char* event, struct afb_wsj1_msg *msg) +{ + static_cast(closure)->on_event(NULL,event,msg); +} + +static void _on_reply_static(void *closure, struct afb_wsj1_msg *msg) +{ + static_cast(closure)->on_reply(NULL,msg); +} + + +/** + * This function is constructor + * + * #### Parameters + * - port [in] : This argument should be specified to the port number to be used for websocket + * - token [in] : This argument should be specified to the token to be used for websocket + * + * #### Rreturn + * Nothing + * + * #### Note + * Use this constructor + * + */ +LibSoundmanager::LibSoundmanager(const int port, const string& token) +{ + int ret; + if(port > 0 && token.size() > 0) + { + mport = port; + mtoken = token; + } + else + { + ELOG("port and token should be > 0, Initial port and token uses."); + } + + ret = initialize_websocket(); + if(ret != 0 ) + { + ELOG("Failed to initialize websocket"); + } + else{ + DLOG("Initialized"); + } +} + +LibSoundmanager::~LibSoundmanager() +{ + if(mploop) + { + sd_event_unref(mploop); + } + if(sp_websock != NULL) + { + free(sp_websock); + } +} + +/** + * This function register callback function for reply/event message from sound manager + * + * #### Parameters + * - event_cb [in] : This argument should be specified to the callback for subscribed event + * - reply_cb [in] : This argument should be specified to the reply callback for call function + * + * #### Rreturn + * - Returns 0 on success or -1 in case of error. + * + * #### Note + * Event callback is invoked by sound manager for event you subscribed. + * If you would like to get event, please call subscribe function before/after this function + */ +void LibSoundmanager::register_callback( + void (*event_cb)(const std::string& event, struct json_object* event_contents), + void (*reply_cb)(struct json_object* reply_contents), + void (*hangup_cb)(void)) +{ + onEvent = event_cb; + onReply = reply_cb; + onHangup = hangup_cb; +} + +int LibSoundmanager::initialize_websocket() +{ + mploop = NULL; + onEvent = nullptr; + onReply = nullptr; + int ret = sd_event_default(&mploop); + if(ret < 0) + { + ELOG("Failed to create event loop"); + goto END; + } + /* Initialize interface from websocket */ + + minterface.on_hangup = _on_hangup_static; + minterface.on_call = _on_call_static; /* Is this necessary? */ + minterface.on_event = _on_event_static; + muri += "ws://localhost:" + to_string(mport) + "/api?token=" + mtoken; /*To be modified*/ + sp_websock = afb_ws_client_connect_wsj1(mploop, muri.c_str(), &minterface, this); + if(sp_websock == NULL) + { + ELOG("Failed to create websocket connection"); + goto END; + } + + /* creates the evsrc */ + //ret = sd_event_add_io(mploop,&mevent_src, sp_websock->fd, EPOLLIN, event_callback, NULL); + + return 0; +END: + if(mploop) + { + sd_event_unref(mploop); + } + return -1; +} + +static void *event_loop_run(void *args) +{ + struct sd_event* loop = (struct sd_event*)(args); + DLOG("start eventloop"); + for(;;) + sd_event_run(loop, 30000000); +} + +/** + * This function start receiving the reply/event message from sound manager + * + * #### Parameters + * Nothing + * #### Rreturn + * - Returns thread_id on success or -1 in case of error. + * + * #### Note + * + */ +int LibSoundmanager::run_eventloop() +{ + if(mploop && sp_websock) + { + pthread_t thread_id; + int ret = pthread_create(&thread_id, NULL, event_loop_run, mploop); + if(ret != 0) + { + ELOG("Cannot run eventloop due to error:%d", errno); + return -1; + } + else + return thread_id; + } + else + { + ELOG("Connecting is not established yet"); + return -1; + } +} + +/** + * This function calls the API of Audio Manager via WebSocket + * + * #### Parameters + * - verb [in] : This argument should be specified to the API name (e.g. "connect") + * - arg [in] : This argument should be specified to the argument of API. And this argument expects JSON object + * + * #### Rreturn + * - Returns 0 on success or -1 in case of error. + * + * #### Note + * To call Audio Manager's APIs, the application should set its function name, arguments to JSON format. + * + */ +int LibSoundmanager::call(const string& verb, struct json_object* arg) +{ + int ret; + if(!sp_websock) + { + return -1; + } + if (!has_verb(verb)) + { + ELOG("verb doesn't exit"); + return -1; + } + ret = afb_wsj1_call_j(sp_websock, API, verb.c_str(), arg, _on_reply_static, this); + if (ret < 0) { + ELOG("Failed to call verb:%s",verb.c_str()); + } + return ret; +} + +/** + * This function calls the API of Audio Manager via WebSocket + * This function is overload function of "call" + * + * #### Parameters + * - verb [in] : This argument should be specified to the API name (e.g. "connect") + * - arg [in] : This argument should be specified to the argument of API. And this argument expects JSON object + * + * #### Rreturn + * - Returns 0 on success or -1 in case of error. + * + * #### Note + * To call Audio Manager's APIs, the application should set its function name, arguments to JSON format. + * + */ +int LibSoundmanager::call(const char* verb, struct json_object* arg) +{ + int ret; + if(!sp_websock) + { + return -1; + } + if (!has_verb(string(verb))) + { + ELOG("verb doesn't exit"); + return -1; + } + ret = afb_wsj1_call_j(sp_websock, API, verb, arg, _on_reply_static, this); + if (ret < 0) { + ELOG("Failed to call verb:%s",verb); + } + return ret; +} + +/** + * Register callback function for each event + * + * #### Parameters + * - event_name [in] : This argument should be specified to the event name + * + * #### Rreturn + * - Returns 0 on success or -1 in case of error. + * + * #### Note + * This function enables to get an event to your callback function. + * Regarding the list of event name, please refer to CommandSender API and RountingSender API. + * + */ +int LibSoundmanager::subscribe(const string& event_name) +{ + if(!sp_websock) + { + return -1; + } + struct json_object* j_obj = json_object_new_object(); + json_object_object_add(j_obj, "event", json_object_new_string(event_name.c_str())); + + int ret = afb_wsj1_call_j(sp_websock, API, "subscribe", j_obj, _on_reply_static, this); + if (ret < 0) { + ELOG("Failed to call verb:%s",__FUNCTION__); + } + return ret; +} + +/** + * Unregister callback function for each event + * + * #### Parameters + * - event_name [in] : This argument should be specified to the event name + * + * #### Rreturn + * - Returns 0 on success or -1 in case of error. + * + * #### Note + * This function disables to get an event to your callback function. + * + */ +int LibSoundmanager::unsubscribe(const string& event_name) +{ + if(!sp_websock) + { + return -1; + } + struct json_object* j_obj = json_object_new_object(); + json_object_object_add(j_obj, "event", json_object_new_string(event_name.c_str())); + + int ret = afb_wsj1_call_j(sp_websock, API, "unsubscribe", j_obj, _on_reply_static, this); + if (ret < 0) { + ELOG("Failed to call verb:%s",__FUNCTION__); + } + return ret; +} + +am_Error_e LibSoundmanager::connect(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t& mainConnectionID) +{ + /*int ret; + char *key; + rc = asprintf(&key, "%d:%s/%s", ++num, api, "connect"); + ret = afb_wsj1_call_s(wsj1, api, verb, object, on_reply, key); + if(ret < 0) + { + fprintf(stderr, "calling %s/%s(%s) failed: %m\n", api, verb, object); + + }*/ + /* open the json scripts */ + // get mainconnedction ID */ + //mainConnectionID = xx; + return E_OK; +} + +am_Error_e LibSoundmanager::disconnect(const am_mainConnectionID_t mainConnectionID) +{ + return E_OK; +} + +/*const struct afb_wsj1* LibSoundmanager::get_websocket_handler() +{ + if(sp_websock) + { + return sp_websock; + } + return nullptr; +} + +const struct sd_event* LibSoundmanager::get_sd_event() +{ + if(mploop) + { + return mploop; + } + return nullptr; +}*/ + +/************* Callback Function *************/ + +void LibSoundmanager::on_hangup(void *closure, struct afb_wsj1 *wsj) +{ + DLOG("%s called", __FUNCTION__); + if(onHangup != nullptr) + { + onHangup(); + } +} + +void LibSoundmanager::on_call(void *closure, const char *api, const char *verb, struct afb_wsj1_msg *msg) +{ +} + +/* +* event is like "soundmanager/newMainConnection" +* msg is like {"event":"soundmanager\/newMainConnection","data":{"mainConnectionID":3,"sourceID":101,"sinkID":100,"delay":0,"connectionState":4},"jtype":"afb-event"})} +* ^key^ ^^^^^^^^^^^^ value ^^^^^^^^^^^^ +* so you can get + event name : struct json_object obj = json_object_object_get(msg,"event") +*/ +void LibSoundmanager::on_event(void *closure, const char *event, struct afb_wsj1_msg *msg) +{ + cout << "ON-EVENT:" << event << "(" << afb_wsj1_msg_object_s(msg) << ")" << endl; + if(onEvent != nullptr) + { + const string ev(event); + struct json_object* ev_contents = afb_wsj1_msg_object_j(msg); + onEvent(ev, ev_contents); + } +} + +void LibSoundmanager::on_reply(void *closure, struct afb_wsj1_msg *msg) +{ + cout << "ON-REPLY:" << "(" << afb_wsj1_msg_object_s(msg) << ")" << endl; + if(onReply != nullptr) + { + struct json_object* reply = afb_wsj1_msg_object_j(msg); + onReply(reply); + } +} + +/* Internal Function in libsoundmanager */ + +static void _ELOG(const char* func, const int line, const char* log, ...) +{ + char *message; + va_list args; + va_start(args, log); + if (log == NULL || vasprintf(&message, log, args) < 0) + message = NULL; + cout << "[ERROR]" << func << "(" << line << "):" << message << endl; + va_end(args); + free(message); +} + +static void _DLOG(const char* func, const int line, const char* log, ...) +{ + char *message; + va_list args; + va_start(args, log); + if (log == NULL || vasprintf(&message, log, args) < 0) + message = NULL; + cout << "[DEBUG]" << func << "(" << line << "):" << message << endl; + va_end(args); + free(message); +} + +static bool has_verb(const string& verb) +{ + DLOG("verb is %s", verb.c_str()); + if(find(api_list.begin(), api_list.end(), verb) != api_list.end()) + return true; + else + return false; +} diff --git a/libsoundmanager/test.cpp b/libsoundmanager/test.cpp new file mode 100644 index 0000000..aa3f51e --- /dev/null +++ b/libsoundmanager/test.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; + +static vector split(const string& str, char sep); +LibSoundmanager* sm; + +static void usage() +{ + cout << "verb "<< "key:arg" << endl; + cout << "example:" << endl; + cout << "connect sourceID 100 sinkID 100" << endl; + cout << "------- -------- --- " << endl; + cout << " verb key value" << endl; + cout << "verb list:" << endl; + for(auto itr = api_list.begin(); itr != api_list.end(); ++itr) + { + cout << " " << *itr << endl; + } + // Todo output api list + exit(0); +} + +static void call_test() +{ + string command; + + cout << "input verb and argments" << endl; + + /* read the buffer */ + for(;;){ + char line[1023]; + cin.getline(line, sizeof(line)); + command = line; + if(command.empty()){ + continue; + } + + vector v_command = split(command, ' '); + /*for(auto itr = v_command.begin(); itr != v_command.end(); ++itr) + { + cout << *itr < in argument part" << endl; + continue; + } + /* create json object */ + struct json_object* j_obj = json_object_new_object(); + for(int i = 1;i < (v_command.size()) ;++i){ + struct json_object* val = json_object_new_string(v_command[i+1].c_str()); + json_object_object_add(j_obj, v_command[i].c_str(), val); + ++i; + } + /* call verb via libsoundmanager */ + sm->call(v_command[0], j_obj); + /* free vector */ + vector().swap(v_command); + string().swap(command); + } +} + +static void onRep(struct json_object* reply_contents) +{ + const char* str = json_object_to_json_string(reply_contents); + cout << "[CB onRep]: " << str << endl; + json_object_put(reply_contents); +} + +static void onEv(const string& event, struct json_object* event_contents) +{ + const char* str = json_object_to_json_string(event_contents); + cout << "[CB onEvent]: event" << event.c_str() << " contents:" << str << endl; + json_object_put(event_contents); +} + +static vector split(const string& str, char sep) +{ + vector v; + stringstream ss(str); + string buffer; + while( getline(ss, buffer, sep) ) { + if(!buffer.empty()) + v.push_back(buffer); + } + return v; +} + +int main(int argc, char **argv) +{ + int ret; + if(argc == 1) + { + printf("Please input port num in first argument, and token in second argument"); + usage(); + return 0; + } + if(argc == 2) + { + string av(argv[1]); + if( (av == "-h") || (av == "--help")) + { + usage(); + return 0; + } + } + + string port_string(argv[1]); + string token(argv[2]); + char* endptr; + long port = strtol(port_string.c_str(),&endptr,10); + + /* error check of range */ + if( (port > 20000) || (port < 0) ) + { + printf("input under 20000(temporary number)"); + return 0; + } + if(*endptr != '\0') + { + printf("not number"); + return 0; + } + + cout << "Call test for libsoundmanager" << endl; + cout << "Call example: registerSource appname radio" << endl; + sm = new LibSoundmanager(port, token); + sm->register_callback(&onEv, &onRep); + + if (ret < 0) { + printf("failed to create event loop"); + return -1; + } + sm->run_eventloop(); + call_test(); + + return 0; +} \ No newline at end of file diff --git a/libsoundmanager/test/CMakeLists.txt b/libsoundmanager/test/CMakeLists.txt new file mode 100644 index 0000000..818ebeb --- /dev/null +++ b/libsoundmanager/test/CMakeLists.txt @@ -0,0 +1,30 @@ + + +SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/modules) +FIND_PACKAGE(gtest QUIET) + +#FIND_PACKAGE(gtest REQUIRED) +if(NOT gtest_FOUND) + MESSAGE(STATUS "gtest not found, disabling unit tests (BUILD_SM_API_TESTS=OFF)") + SET(BUILD_SM_API_TESTS FALSE) +else(NOT gtest_FOUND) + MESSAGE(STATUS "gtest found, enabling unit tests (BUILD_SM_API_TESTS=ON)") + SET(BUILD_SM_API_TESTS TRUE) +endif() + +IF(BUILD_SM_API_TESTS) +set(gtest_souces gtest_libsoundmanager.cpp) +include_directories(gtest_libsoundmanager PRIVEATE ${gtest_INCLUDE_DIRS}) +add_executable(gtest_libsoundmanager ${gtest_souces}) + +#add_dependencies(gtest_libsoundmanager gtest) +target_link_libraries(gtest_libsoundmanager + soundmanager + gtest_main.a + ${link_libraries} + ${libsm_depends_LIBRARIES} + ${gtest_LIBRARIES} + ) +add_test(gtest_libsoundmanager gtest_libsoundmanager) +ENDIF() +################################### diff --git a/libsoundmanager/test/gtest_libsoundmanager.cpp b/libsoundmanager/test/gtest_libsoundmanager.cpp new file mode 100644 index 0000000..44663ff --- /dev/null +++ b/libsoundmanager/test/gtest_libsoundmanager.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +using namespace std; +namespace { + +class LibSoundmanagerTest : public ::testing::Test{ +public: + void SetUp() + { + /* Launch sound manager binding */ + + } + void TearDown() + { + + } +}; + +TEST_F(LibSoundmanagerTest, call) +{ + LibSoundmanager tester = LibSoundmanager(12345,"123456"); + + struct json_object *verb = json_object_new_object(); + EXPECT_EQ(0, tester.call(string("getListMainConnections"), NULL)); + json_object_object_add(verb, "sourceID", json_object_new_int(1000)); + json_object_object_add(verb, "sinkID", json_object_new_int(1000)); + string test2("connect"); + EXPECT_EQ(0, tester.call(test2, verb)); +} + +} // namespace diff --git a/package/config.xml b/package/config.xml new file mode 100644 index 0000000..7cdb92e --- /dev/null +++ b/package/config.xml @@ -0,0 +1,20 @@ + + + soundmanager + + + Sound Manager Binding service rooting to Audio Manager + Kazumasa Mitsunari <knimitz@witz-inc.co.jp> + APL 2.0 + + + + + + + + + + + + diff --git a/package/icon.svg b/package/icon.svg new file mode 100644 index 0000000..6628784 --- /dev/null +++ b/package/icon.svg @@ -0,0 +1,283 @@ + + + +image/svg+xmlSETTINGS + \ No newline at end of file diff --git a/sample/mediaplayer/.gitignore b/sample/mediaplayer/.gitignore new file mode 100644 index 0000000..89f64c7 --- /dev/null +++ b/sample/mediaplayer/.gitignore @@ -0,0 +1 @@ +*.pro.* diff --git a/sample/mediaplayer/.gitreview b/sample/mediaplayer/.gitreview new file mode 100644 index 0000000..194665d --- /dev/null +++ b/sample/mediaplayer/.gitreview @@ -0,0 +1,5 @@ +[gerrit] +host=gerrit.automotivelinux.org +port=29418 +project=apps/mediaplayer +defaultbranch=master diff --git a/sample/mediaplayer/LICENSE b/sample/mediaplayer/LICENSE new file mode 100644 index 0000000..31c692a --- /dev/null +++ b/sample/mediaplayer/LICENSE @@ -0,0 +1,54 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/sample/mediaplayer/app/MediaPlayer.qml b/sample/mediaplayer/app/MediaPlayer.qml new file mode 100644 index 0000000..9e3bbcc --- /dev/null +++ b/sample/mediaplayer/app/MediaPlayer.qml @@ -0,0 +1,415 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Toyota Motor Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtQuick.Layouts 1.1 +import QtQuick.Controls 2.0 +import QtMultimedia 5.6 +import AGL.Demo.Controls 1.0 +import MediaPlayer 1.0 +import 'api' as API + +ApplicationWindow { + id: root + + property int sourceID: 0 + property bool registered_media: false + property int connectionID + property int sourceIndex + + API.LightMediaScanner { + id: binding + url: bindingAddress + } + + API.BluetoothManager { + id: bluetooth + url: bindingAddress + } + + MediaPlayer { + id: player + audioRole: MediaPlayer.MusicRole + autoLoad: true + playlist: playlist + + function time2str(value) { + return Qt.formatTime(new Date(value), 'mm:ss') + } + } + function stopMediaplayer(){ + console.log("stop mediaplayer from C++") + player.pause() + } + + function slotReply(msg){ + var jstr = JSON.stringify(msg) + console.log("mediaplayer: Json jstr:" + jstr) + var content = JSON.parse(jstr); + var verb = content.response.verb + var err = content.response.error + console.log("mediaplayer: verb: " + verb) + console.log("mediaplayer: content.response.error: " + err) + switch(verb) + { + case "connect": + console.log("mediaplayer: replied by connect") + if(err == 0){ + connectionID = content.response.mainConnectionID + console.log("mediaplayer: mainConnectionID is " + connectionID) + } + break; + case "registerSource": + console.log("mediaplayer: replied by registerSource") + if(err == 0){ + sourceID = content.response.sourceID + registered_media = true + } + } + } + + function slotEvent(event,msg){ + var jstr = JSON.stringify(msg) + var content = JSON.parse(jstr); + var eventName = content.event + console.log("mediaplayer: event qml: event" + eventName + " msg: " + jstr) + switch(eventName) + { + case "soundmanager\/asyncSetSourceState": + // This event doesn't come for now + console.log("mediaplayer: soundmanager\/asyncSetSourceState") + console.log("mediaplayer: my soundID:" + sourceID + "handle:" + content.data.handle + ",sourceID:" + content.data.sourceID + ",sourceState:" + content.data.sourceState) + if(sourceID == content.data.sourceID){ + console.log("mediaplayer: call ackSetSourceState") + var arg = JSON.stringify({handle:content.data.handle, error:0}) + smw.call("ackSetSourceState", arg) + switch(content.data.sourceState){ + case "on": + player.play() + break; + case "off": + player.pause() + break; + case "paused": + player.pause() + break; + default: + break; + } + } + break; + case "soundmanager\/asyncConnect": + // In reality, device should be opened in this timing + if(connectionID == content.data.connectionID){ + //player.open_device() + } + break; + case "soundmanager\/asyncDisconnect": + // In reality, device should be closed in this timing + if(connectionID == content.data.connectionID){ + // player.close_device() + } + break; + default: + break; + } + } + + Timer { + id: timer + interval: 250 + running: (bluetooth.av_connected && bluetooth.state == "playing") + repeat: true + onTriggered: { + bluetooth.position = bluetooth.position + 250 + slider.value = bluetooth.position + } + } + + Playlist { + id: playlist + playbackMode: random.checked ? Playlist.Random : loop.checked ? Playlist.Loop : Playlist.Sequential + } + + + ColumnLayout { + anchors.fill: parent + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 1080 + clip: true + Image { + id: albumart + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + height: sourceSize.height * width / sourceSize.width + fillMode: Image.PreserveAspectCrop + source: player.metaData.coverArtImage ? player.metaData.coverArtImage : '' + visible: bluetooth.av_connected == false + } + + Item { + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + height :307 + Rectangle { + anchors.fill: parent + color: 'black' + opacity: 0.75 + } + + ColumnLayout { + anchors.fill: parent + anchors.margins: root.width * 0.02 + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Row { + spacing: 20 + ToggleButton { + id: random + visible: bluetooth.connected == false + offImage: './images/AGL_MediaPlayer_Shuffle_Inactive.svg' + onImage: './images/AGL_MediaPlayer_Shuffle_Active.svg' + } + ToggleButton { + id: loop + visible: bluetooth.connected == false + offImage: './images/AGL_MediaPlayer_Loop_Inactive.svg' + onImage: './images/AGL_MediaPlayer_Loop_Active.svg' + } + } + ColumnLayout { + anchors.fill: parent + Label { + id: title + Layout.alignment: Layout.Center + text: bluetooth.av_connected ? bluetooth.title : (player.metaData.title ? player.metaData.title : '') + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + } + Label { + Layout.alignment: Layout.Center + text: bluetooth.av_connected ? bluetooth.artist : (player.metaData.contributingArtist ? player.metaData.contributingArtist : '') + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + font.pixelSize: title.font.pixelSize * 0.6 + } + } + } + Slider { + id: slider + Layout.fillWidth: true + to: bluetooth.av_connected ? bluetooth.duration : player.duration + enabled: bluetooth.av_connected == false + value: bluetooth.av_connected ? bluetooth.position : player.position + function getPosition() { + if (bluetooth.av_connected) { + return player.time2str(bluetooth.position) + } + return player.time2str(player.position) + } + Label { + id: position + anchors.left: parent.left + anchors.bottom: parent.top + font.pixelSize: 32 + text: slider.getPosition() + } + Label { + id: duration + anchors.right: parent.right + anchors.bottom: parent.top + font.pixelSize: 32 + text: bluetooth.av_connected ? player.time2str(bluetooth.duration) : player.time2str(player.duration) + } + onPressedChanged: player.seek(value) + } + RowLayout { + Layout.fillHeight: true +// Image { +// source: './images/AGL_MediaPlayer_Playlist_Inactive.svg' +// } +// Image { +// source: './images/AGL_MediaPlayer_CD_Inactive.svg' +// } + Item { Layout.fillWidth: true } + ImageButton { + id: previous + offImage: './images/AGL_MediaPlayer_BackArrow.svg' + onClicked: { + if (bluetooth.av_connected) { + bluetooth.sendMediaCommand("Previous") + bluetooth.position = 0 + } else { + playlist.previous() + } + } + } + ImageButton { + id: play + offImage: './images/AGL_MediaPlayer_Player_Play.svg' + onClicked: { + if (bluetooth.av_connected) { + bluetooth.sendMediaCommand("Play") + } else { + console.log("mediaplayer: registered_media is " + registered_media) + if(registered_media) + { + console.log("mediaplayer: call connect") + var JsonArg = JSON.stringify({sourceID:sourceID, sinkID: 1}) + smw.call("connect", JsonArg) + } + } + } + states: [ + State { + when: player.playbackState === MediaPlayer.PlayingState + PropertyChanges { + target: play + offImage: './images/AGL_MediaPlayer_Player_Pause.svg' + onClicked: { + var JsonArg = JSON.stringify({mainConnectionID: connectionID}) + console.log(JsonArg) + smw.call("disconnect",JsonArg) + } + } + }, + State { + when: bluetooth.av_connected && bluetooth.state == "playing" + PropertyChanges { + target: play + offImage: './images/AGL_MediaPlayer_Player_Pause.svg' + onClicked: bluetooth.sendMediaCommand("Pause") + } + } + + ] + } + ImageButton { + id: forward + offImage: './images/AGL_MediaPlayer_ForwardArrow.svg' + onClicked: { + if (bluetooth.av_connected) { + bluetooth.sendMediaCommand("Next") + } else { + playlist.next() + } + } + } + + Item { Layout.fillWidth: true } + + ToggleButton { + visible: bluetooth.connected + checked: bluetooth.av_connected + offImage: './images/AGL_MediaPlayer_Bluetooth_Inactive.svg' + onImage: './images/AGL_MediaPlayer_Bluetooth_Active.svg' + + onClicked: { + if (bluetooth.av_connected) { + bluetooth.disconnect_profiles() + } else { + bluetooth.connect_profiles() + } + } + } + } + } + } + } + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 407 + + PlaylistWithMetadata { + id: playlistmodel + source: playlist + } + + ListView { + anchors.fill: parent + id: playlistview + visible: bluetooth.av_connected == false + clip: true + header: Label { + x: 50 + text: 'PLAYLIST' + opacity: 0.5 + } + model: playlistmodel + currentIndex: playlist.currentIndex + + delegate: MouseArea { + id: delegate + width: ListView.view.width + height: ListView.view.height / 4 + RowLayout { + anchors.fill: parent + anchors.leftMargin: 50 + anchors.rightMargin: 50 + Image { + source: model.coverArt + fillMode: Image.PreserveAspectFit + Layout.preferredWidth: delegate.height + Layout.preferredHeight: delegate.height + } + ColumnLayout { + Layout.fillWidth: true + Label { + Layout.fillWidth: true + text: model.title + } + Label { + Layout.fillWidth: true + text: model.artist + color: '#66FF99' + font.pixelSize: 32 + } + } + Label { + text: player.time2str(model.duration) + color: '#66FF99' + font.pixelSize: 32 + } + } + onClicked: { + playlist.currentIndex = model.index + sourceIndex = model.index; + console.log("mediaplayer: call connect") + var JsonArg = JSON.stringify({sourceID:sourceID, sinkID: 1}) + smw.call("connect", JsonArg) + } + } + + highlight: Rectangle { + color: 'white' + opacity: 0.25 + } + } + } + Component.onCompleted: { + var media = JSON.stringify({appname:"mediaplayer"}) + var bta = JSON.stringify({appname:"bluetooth_audio"}) + smw.call("registerSource",media) + } + } +} diff --git a/sample/mediaplayer/app/api/BluetoothManager.qml b/sample/mediaplayer/app/api/BluetoothManager.qml new file mode 100644 index 0000000..f102fe2 --- /dev/null +++ b/sample/mediaplayer/app/api/BluetoothManager.qml @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtWebSockets 1.0 + +WebSocket { + id: root + active: true + url: bindingAddress + + property string statusString: "waiting..." + property string apiString: "Bluetooth-Manager" + property var verbs: [] + property string payloadLength: "9999" + + property string deviceAddress: "" + property bool connected: false + property bool av_connected: false + + property int position: 0 + property int duration: 0 + + property string artist: "" + property string title: "" + property string state: "stopped" + + // AVRCP Target UUID + property string avrcp_uuid: "0000110e-0000-1000-8000-00805f9b34fb" + + // A2DP Source + property string a2dp_uuid: "0000110a-0000-1000-8000-00805f9b34fb" + + readonly property var msgid: { + "call": 2, + "retok": 3, + "reterr": 4, + "event": 5 + } + + onTextMessageReceived: { + var json = JSON.parse(message) + console.debug("Raw response: " + message) + var request = json[2].request + var response = json[2].response + console.debug("response: " + JSON.stringify(response)) + switch (json[0]) { + case msgid.call: + break + case msgid.retok: + root.statusString = request.status + var address = "" + + if (request.info == "BT - Scan Result is Displayed") { + for (var i = 0; i < response.length; i++) { + var data = response[i] + if (data.Connected == "True" && data.UUIDs.indexOf(avrcp_uuid) >= 0) { + address = response[i].Address + console.debug("Connected Device: " + address) + + root.connected = true + player.pause() + + //NOTE: This hack is here for when MediaPlayer is started + // with an existing connection. + if (data.AVPConnected == "True") { + root.av_connected = true + } + } + } + root.deviceAddress = address + if (!address) { + root.connected = false + } + } + break + case msgid.reterr: + root.statusString = "Bad return value, binding probably not installed" + break + case msgid.event: + var payload = JSON.parse(JSON.stringify(json[2])) + var event = payload.event + + if (event == "Bluetooth-Manager/connection") { + sendSocketMessage("discovery_result", 'None') + } else if (event == "Bluetooth-Manager/device_updated") { + var data = payload.data + var metadata = data.Metadata + + if (root.deviceAddress != data.Address) + break + + if (data.Connected == "False") { + console.debug("Device Disconnected") + sendSocketMessage("discovery_result", 'None') + break + } + root.av_connected = data.AVPConnected == "True" + + if ('Position' in metadata) { + console.debug("Position " + metadata.Position) + root.position = metadata.Position + } + + if ('Duration' in metadata) { + console.debug("Duration " + metadata.Duration) + root.duration = metadata.Duration + } + + if ('Status' in metadata) { + console.debug("Status " + metadata.Status) + root.state = metadata.Status + } + + if ('Artist' in metadata) { + console.debug("Artist " + metadata.Artist) + root.artist = metadata.Artist + } + + if ('Title' in metadata) { + console.debug("Title " + metadata.Title) + root.title = metadata.Title + } + } + break + } + } + + onStatusChanged: { + switch (status) { + case WebSocket.Open: + console.debug("onStatusChanged: Open") + sendSocketMessage("subscribe", { value : "device_updated" }) + sendSocketMessage("subscribe", { value : "connection" }) + sendSocketMessage("discovery_result", 'None') + break + case WebSocket.Error: + root.statusString = "WebSocket error: " + root.errorString + break + } + } + + function sendSocketMessage(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, apiString + '/' + + verb, parameter ] + console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + verbs.push(verb) + root.sendTextMessage(JSON.stringify(requestJson)) + } + + function sendMediaCommand(state) { + var parameters = { "Address": deviceAddress, "value": state } + sendSocketMessage("set_avrcp_controls", parameters) + } + + function connect_profiles() { + sendSocketMessage("connect", { "value": root.deviceAddress, "uuid": a2dp_uuid }) + sendSocketMessage("connect", { "value": root.deviceAddress, "uuid": avrcp_uuid }) + } + + function disconnect_profiles() { + sendSocketMessage("disconnect", { "value": root.deviceAddress, "uuid": a2dp_uuid }) + sendSocketMessage("disconnect", { "value": root.deviceAddress, "uuid": avrcp_uuid }) + } +} diff --git a/sample/mediaplayer/app/api/LightMediaScanner.qml b/sample/mediaplayer/app/api/LightMediaScanner.qml new file mode 100644 index 0000000..cbacb8c --- /dev/null +++ b/sample/mediaplayer/app/api/LightMediaScanner.qml @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtWebSockets 1.0 + +WebSocket { + id: root + active: true + url: bindingAddress + + property string statusString: "waiting..." + property string apiString: "media-manager" + property var verbs: [] + property var items: [] + property string payloadLength: "9999" + + readonly property var msgid: { + "call": 2, + "retok": 3, + "reterr": 4, + "event": 5 + } + + function validateItem(media) { + for (var i = 0; i < media.length; i++) { + var item = media[i] + if (root.items.indexOf(item) < 0) { + playlist.addItem(item) + root.items.push(item) + } + } + } + + onTextMessageReceived: { + var json = JSON.parse(message) + console.debug("Raw response: " + message) + var request = json[2].request + var response = json[2].response + console.debug("response: " + JSON.stringify(response)) + switch (json[0]) { + case msgid.call: + break + case msgid.retok: + root.statusString = request.status + var verb = verbs.shift() + if (verb == "media_result") { + console.debug("Media result returned") + validateItem(response.Media) + } + break + case msgid.reterr: + root.statusString = "Bad return value, binding probably not installed" + break + case msgid.event: + var payload = JSON.parse(JSON.stringify(json[2])) + var event = payload.event + if (event == "media-manager/media_added") { + console.debug("Media is inserted") + validateItem(json[2].data.Media) + } else if (event == "media-manager/media_removed") { + var removed = 0 + console.debug("Media is removed") + player.stop() + + for (var i = 0; i < root.items.length; i++) { + if (root.items[i].startsWith(json[2].data.Path)) { + playlist.removeItem(i - removed++) + } + } + root.items = root.items.filter(function (item) { return !item.startsWith(json[2].data.Path) }) + } + break + } + } + + onStatusChanged: { + switch (status) { + case WebSocket.Open: + console.debug("onStatusChanged: Open") + sendSocketMessage("subscribe", { value: "media_added" }) + sendSocketMessage("subscribe", { value: "media_removed" }) + root.populateMediaPlaylist() + break + case WebSocket.Error: + root.statusString = "WebSocket error: " + root.errorString + break + } + } + + function sendSocketMessage(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, apiString + '/' + + verb, parameter ] + console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + verbs.push(verb) + sendTextMessage(JSON.stringify(requestJson)) + } + + function populateMediaPlaylist() { + sendSocketMessage("media_result", 'None') + } +} diff --git a/sample/mediaplayer/app/app.pri b/sample/mediaplayer/app/app.pri new file mode 100644 index 0000000..8671c5a --- /dev/null +++ b/sample/mediaplayer/app/app.pri @@ -0,0 +1,21 @@ +TEMPLATE = app + +load(configure) +qtCompileTest(libhomescreen) + +config_libhomescreen { + CONFIG += link_pkgconfig + PKGCONFIG += homescreen soundmanager + DEFINES += HAVE_LIBHOMESCREEN +} + +packagesExist(sqlite3 lightmediascanner) { + DEFINES += HAVE_LIGHTMEDIASCANNER +} + +packagesExist(dbus-1) { + DEFINES += HAVE_DBUS + QT += dbus +} + +DESTDIR = $${OUT_PWD}/../package/root/bin diff --git a/sample/mediaplayer/app/app.pro b/sample/mediaplayer/app/app.pro new file mode 100644 index 0000000..6d34047 --- /dev/null +++ b/sample/mediaplayer/app/app.pro @@ -0,0 +1,16 @@ +TARGET = mediaplayer +QT = quickcontrols2 multimedia + +HEADERS += \ + playlistwithmetadata.h libsmwrapper.h libsoundmanager.hpp + +SOURCES = main.cpp \ + playlistwithmetadata.cpp libsmwrapper.cpp +CONFIG += link_pkgconfig +PKGCONFIG += soundmanager libsystemd + +RESOURCES += \ + mediaplayer.qrc \ + images/images.qrc + +include(app.pri) diff --git a/sample/mediaplayer/app/config.tests/libhomescreen.cpp b/sample/mediaplayer/app/config.tests/libhomescreen.cpp new file mode 100644 index 0000000..e0fd460 --- /dev/null +++ b/sample/mediaplayer/app/config.tests/libhomescreen.cpp @@ -0,0 +1,7 @@ +#include + +int main(int argc,char **argv) +{ + LibHomeScreen libHomeScreen; + return 0; +} diff --git a/sample/mediaplayer/app/config.tests/libhomescreen.pro b/sample/mediaplayer/app/config.tests/libhomescreen.pro new file mode 100644 index 0000000..eb4e8f3 --- /dev/null +++ b/sample/mediaplayer/app/config.tests/libhomescreen.pro @@ -0,0 +1,5 @@ +SOURCES = libhomescreen.cpp + +CONFIG -= qt +CONFIG += link_pkgconfig +PKGCONFIG += homescreen diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_AlbumArtwork.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_AlbumArtwork.svg new file mode 100644 index 0000000..b2578c0 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_AlbumArtwork.svg @@ -0,0 +1,71 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_BackArrow.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_BackArrow.svg new file mode 100644 index 0000000..c49b519 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_BackArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Active.svg new file mode 100644 index 0000000..7386246 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Active.svg @@ -0,0 +1,84 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Inactive.svg new file mode 100644 index 0000000..24618b5 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Bluetooth_Inactive.svg @@ -0,0 +1,59 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Active.svg new file mode 100644 index 0000000..a65f309 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Active.svg @@ -0,0 +1,84 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Inactive.svg new file mode 100644 index 0000000..adc9127 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_CD_Inactive.svg @@ -0,0 +1,59 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_DividingLine.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_DividingLine.svg new file mode 100644 index 0000000..51ed1ee --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_DividingLine.svg @@ -0,0 +1,60 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_ForwardArrow.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_ForwardArrow.svg new file mode 100644 index 0000000..56576ac --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_ForwardArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Active.svg new file mode 100644 index 0000000..fed253d --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Active.svg @@ -0,0 +1,58 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Inactive.svg new file mode 100644 index 0000000..27ae317 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Loop_Inactive.svg @@ -0,0 +1,58 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Pause.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Pause.svg new file mode 100644 index 0000000..ee55213 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Pause.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Play.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Play.svg new file mode 100644 index 0000000..c296f8a --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Player_Play.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Active.svg new file mode 100644 index 0000000..6697335 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Active.svg @@ -0,0 +1,89 @@ + + + +image/svg+xmlPLAYLIST + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Inactive.svg new file mode 100644 index 0000000..afbae1e --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_PlaylistToggle_Inactive.svg @@ -0,0 +1,89 @@ + + + +image/svg+xmlPLAYLIST + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Active.svg new file mode 100644 index 0000000..d378e05 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Active.svg @@ -0,0 +1,166 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Inactive.svg new file mode 100644 index 0000000..65ee832 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Playlist_Inactive.svg @@ -0,0 +1,89 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Active.svg new file mode 100644 index 0000000..77a9afa --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Active.svg @@ -0,0 +1,299 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Inactive.svg new file mode 100644 index 0000000..fe00b77 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Radio_Inactive.svg @@ -0,0 +1,131 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Active.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Active.svg new file mode 100644 index 0000000..c2c04f8 --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Active.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Inactive.svg b/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Inactive.svg new file mode 100644 index 0000000..068370a --- /dev/null +++ b/sample/mediaplayer/app/images/AGL_MediaPlayer_Shuffle_Inactive.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Albums_Active.svg b/sample/mediaplayer/app/images/Albums_Active.svg new file mode 100644 index 0000000..64086f3 --- /dev/null +++ b/sample/mediaplayer/app/images/Albums_Active.svg @@ -0,0 +1,155 @@ + + + +image/svg+xmlALBUMS + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Albums_Inactive.svg b/sample/mediaplayer/app/images/Albums_Inactive.svg new file mode 100644 index 0000000..7d6b1d8 --- /dev/null +++ b/sample/mediaplayer/app/images/Albums_Inactive.svg @@ -0,0 +1,95 @@ + + + +image/svg+xmlALBUMS + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/DividingLine.svg b/sample/mediaplayer/app/images/DividingLine.svg new file mode 100644 index 0000000..40354c1 --- /dev/null +++ b/sample/mediaplayer/app/images/DividingLine.svg @@ -0,0 +1,58 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/GreenLine.svg b/sample/mediaplayer/app/images/GreenLine.svg new file mode 100644 index 0000000..8d3a431 --- /dev/null +++ b/sample/mediaplayer/app/images/GreenLine.svg @@ -0,0 +1,59 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Music_Active.svg b/sample/mediaplayer/app/images/Music_Active.svg new file mode 100644 index 0000000..22d50d0 --- /dev/null +++ b/sample/mediaplayer/app/images/Music_Active.svg @@ -0,0 +1,63 @@ + + + +image/svg+xmlMUSIC + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Music_Inactive.svg b/sample/mediaplayer/app/images/Music_Inactive.svg new file mode 100644 index 0000000..c009efa --- /dev/null +++ b/sample/mediaplayer/app/images/Music_Inactive.svg @@ -0,0 +1,63 @@ + + + +image/svg+xmlMUSIC + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Podcasts_Active.svg b/sample/mediaplayer/app/images/Podcasts_Active.svg new file mode 100644 index 0000000..ab68439 --- /dev/null +++ b/sample/mediaplayer/app/images/Podcasts_Active.svg @@ -0,0 +1,77 @@ + + + +image/svg+xmlPODCASTS + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Podcasts_Inactive.svg b/sample/mediaplayer/app/images/Podcasts_Inactive.svg new file mode 100644 index 0000000..43d6958 --- /dev/null +++ b/sample/mediaplayer/app/images/Podcasts_Inactive.svg @@ -0,0 +1,65 @@ + + + +image/svg+xmlPODCASTS + \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Popup_Highlight.svg b/sample/mediaplayer/app/images/Popup_Highlight.svg new file mode 100644 index 0000000..24795a4 --- /dev/null +++ b/sample/mediaplayer/app/images/Popup_Highlight.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Popup_PauseIcon.svg b/sample/mediaplayer/app/images/Popup_PauseIcon.svg new file mode 100644 index 0000000..f1df1a7 --- /dev/null +++ b/sample/mediaplayer/app/images/Popup_PauseIcon.svg @@ -0,0 +1,65 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Popup_PlayIcon.svg b/sample/mediaplayer/app/images/Popup_PlayIcon.svg new file mode 100644 index 0000000..5053ebb --- /dev/null +++ b/sample/mediaplayer/app/images/Popup_PlayIcon.svg @@ -0,0 +1,65 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/Popup_VerticalLine.svg b/sample/mediaplayer/app/images/Popup_VerticalLine.svg new file mode 100644 index 0000000..b8457ec --- /dev/null +++ b/sample/mediaplayer/app/images/Popup_VerticalLine.svg @@ -0,0 +1,69 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/X.svg b/sample/mediaplayer/app/images/X.svg new file mode 100644 index 0000000..3afe6f6 --- /dev/null +++ b/sample/mediaplayer/app/images/X.svg @@ -0,0 +1,64 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/mediaplayer/app/images/images.qrc b/sample/mediaplayer/app/images/images.qrc new file mode 100644 index 0000000..eb07c3b --- /dev/null +++ b/sample/mediaplayer/app/images/images.qrc @@ -0,0 +1,37 @@ + + + AGL_MediaPlayer_Bluetooth_Active.svg + AGL_MediaPlayer_AlbumArtwork.svg + AGL_MediaPlayer_BackArrow.svg + AGL_MediaPlayer_Bluetooth_Inactive.svg + AGL_MediaPlayer_CD_Active.svg + AGL_MediaPlayer_CD_Inactive.svg + AGL_MediaPlayer_DividingLine.svg + AGL_MediaPlayer_ForwardArrow.svg + AGL_MediaPlayer_Loop_Active.svg + AGL_MediaPlayer_Loop_Inactive.svg + AGL_MediaPlayer_Player_Pause.svg + AGL_MediaPlayer_Player_Play.svg + AGL_MediaPlayer_Playlist_Active.svg + AGL_MediaPlayer_Playlist_Inactive.svg + AGL_MediaPlayer_PlaylistToggle_Active.svg + AGL_MediaPlayer_PlaylistToggle_Inactive.svg + AGL_MediaPlayer_Radio_Active.svg + AGL_MediaPlayer_Radio_Inactive.svg + AGL_MediaPlayer_Shuffle_Active.svg + AGL_MediaPlayer_Shuffle_Inactive.svg + Albums_Active.svg + Albums_Inactive.svg + DividingLine.svg + GreenLine.svg + Music_Active.svg + Music_Inactive.svg + Podcasts_Active.svg + Podcasts_Inactive.svg + Popup_Highlight.svg + Popup_PauseIcon.svg + Popup_PlayIcon.svg + Popup_VerticalLine.svg + X.svg + + diff --git a/sample/mediaplayer/app/libsmwrapper.cpp b/sample/mediaplayer/app/libsmwrapper.cpp new file mode 100644 index 0000000..29da01c --- /dev/null +++ b/sample/mediaplayer/app/libsmwrapper.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "libsmwrapper.h" +using namespace std; + +static int create_json_object(const QJsonObject& obj, struct json_object* jobj); +static bool put_val_to_jobj(const char* key, const QJsonValue& val, struct json_object* jobj); +static bool put_array_to_jobj(const char* key, const QJsonArray& qarray, struct json_object* jobj); + +LibSMWrapper::LibSMWrapper(QObject *parent) : + QObject(parent) +{ + /* This is not enabled */ + //libsm = new LibSoundmanager(); +} + +LibSMWrapper::LibSMWrapper(const int port, const QString& token, QObject *parent) : + QObject(parent) +{ + libsm = new LibSoundmanager(port, token.toStdString()); +} + +LibSMWrapper::~LibSMWrapper() +{ + delete libsm; +} + +int LibSMWrapper::call(const QString &verb, const QString &arg) +{ + // translate QJsonObject to struct json_object + struct json_object* jobj = json_object_new_object(); + QJsonDocument jsonDoc = QJsonDocument::fromJson(arg.toUtf8()); + const QJsonObject jsonObj = jsonDoc.object(); + int ret = create_json_object(jsonObj, jobj); + if(ret < 0) + { + return -1; + } + return libsm->call(verb.toStdString().c_str(), jobj); +} + +static int create_json_object(const QJsonObject& obj, struct json_object* jobj) +{ + try{ + for(auto itr = obj.begin(); itr != obj.end();++itr) + { + string key = itr.key().toStdString(); + //const char* key = itr.key().toStdString().c_str(); + + bool ret = put_val_to_jobj(key.c_str(), itr.value(),jobj); + if(!ret){ + /*This is not implemented*/ + qDebug("JsonArray can't parse for now"); + return -1; + // ToDo + // For now, array may not be inputted for soundmanager + // But use case absolutely exists + /*QJsonArray qarray = itr.value().toArray(); + ret = put_array_to_jobj(key, qarray, jobj);*/ + } + } + } + catch(...){ + qDebug("Json parse error occured"); + return -1; + } + return 0; +} + +static bool put_val_to_jobj(const char* key, const QJsonValue& val, struct json_object* jobj) +{ + if(val.isArray()){ + return false; // Array can't input + } + if(val.isString()){ + string value = val.toString().toStdString(); + json_object_object_add(jobj, key, json_object_new_string(value.c_str())); + } + else{ + const int value = val.toInt(); + json_object_object_add(jobj, key, json_object_new_int(value)); + } + return true; +} + +static bool put_array_to_jobj(const char* key, const QJsonArray& qarray, struct json_object* jobj) +{ + // ToDo Fix this !! +/* struct json_object* jarray = json_object_new_array(); + + bool ret; + for(auto jitr = qarray.begin(); jitr != qarray.end(); ++jitr){ + struct json_object* tmp = json_object_new_object(); + ret = put_val_to_jobj(key,jitr,tmp); + if(!ret) + { + put_array_to_jobj(key,jitr,tmp); + } + json_object_array_add(jarray, tmp); + } + json_object_object_add(jobj, key, jarray); + return true;*/ +} + +void LibSMWrapper::wrapper_registerCallback( + void (*event_func)(const string& event, struct json_object* event_contents), + void (*reply_func)(struct json_object* reply_contents)) +{ + libsm->register_callback(event_func, reply_func); +} + +void LibSMWrapper::subscribe(const QString event_name) +{ + std::string str = event_name.toStdString(); + libsm->subscribe(str); +} + +void LibSMWrapper::unsubscribe(const QString event_name) +{ + std::string str = event_name.toStdString(); + libsm->unsubscribe(str); +} + +void LibSMWrapper::run_eventloop() +{ + libsm->run_eventloop(); +} + +void LibSMWrapper::print(const QString &str) +{ + qDebug("%s is called", str.toStdString().c_str()); +} + +void LibSMWrapper::emit_event(const QString &event, const QJsonObject &msg) +{ + qDebug("emit smEvent signal @%s", __FUNCTION__); + emit smEvent(event, msg); +} +void LibSMWrapper::emit_reply(const QJsonObject &msg) +{ + qDebug("emit smReply signal @%s", __FUNCTION__); + emit smReply(msg); +} \ No newline at end of file diff --git a/sample/mediaplayer/app/libsmwrapper.h b/sample/mediaplayer/app/libsmwrapper.h new file mode 100644 index 0000000..3954a29 --- /dev/null +++ b/sample/mediaplayer/app/libsmwrapper.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef SIGNALER_H +#define SIGNALER_H + + #include + #include + #include + #include + #include + #include + #include + + +class LibSMWrapper : public QObject +{ + Q_OBJECT +public: // method + explicit LibSMWrapper(QObject *parent = nullptr); + LibSMWrapper(const int port, const QString& token, QObject *parent = nullptr); + ~LibSMWrapper(); + + void wrapper_registerCallback( + void (*event_func)(const std::string& event, struct json_object* event_contents), + void (*reply_func)(struct json_object* reply_contents) + ); + void subscribe(const QString event_name); + void unsubscribe(const QString event_name); + void run_eventloop(); + + void emit_event(const QString &event, const QJsonObject &msg); + void emit_reply(const QJsonObject &msg); +public slots: + int call(const QString &verb, const QString &arg); + void print(const QString &str); +signals: + void smEvent(const QVariant &event, const QVariant &msg); + void smReply(const QVariant &msg); + +private: + LibSoundmanager* libsm; +}; + + +#endif /*SIGNALER_H*/ \ No newline at end of file diff --git a/sample/mediaplayer/app/main.cpp b/sample/mediaplayer/app/main.cpp new file mode 100644 index 0000000..6a2bb70 --- /dev/null +++ b/sample/mediaplayer/app/main.cpp @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Toyota Motor Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "libsmwrapper.h" + +#ifdef HAVE_LIBHOMESCREEN +#include +#endif + +#include "playlistwithmetadata.h" + +LibSMWrapper* smw; +static int mysourceID = 0; +static bool firsttime = true; +QObject *root; + +static void onRep(struct json_object* reply_contents); +static void onEv(const std::string& event, struct json_object* event_contents); + +int main(int argc, char *argv[]) +{ +#ifdef HAVE_LIBHOMESCREEN + LibHomeScreen libHomeScreen; + + if (!libHomeScreen.renderAppToAreaAllowed(0, 1)) { + qWarning() << "renderAppToAreaAllowed is denied"; + return -1; + } +#endif + + QGuiApplication app(argc, argv); + + QQuickStyle::setStyle("AGL"); + + qmlRegisterType("MediaPlayer", 1, 0, "PlaylistWithMetadata"); + + QQmlApplicationEngine engine; + QQmlContext *context = engine.rootContext(); + + QCommandLineParser parser; + parser.addPositionalArgument("port", app.translate("main", "port for binding")); + parser.addPositionalArgument("secret", app.translate("main", "secret for binding")); + parser.addHelpOption(); + parser.addVersionOption(); + parser.process(app); + QStringList positionalArguments = parser.positionalArguments(); + + if (positionalArguments.length() == 2) { + int port = positionalArguments.takeFirst().toInt(); + QString secret = positionalArguments.takeFirst(); + QUrl bindingAddress; + bindingAddress.setScheme(QStringLiteral("ws")); + bindingAddress.setHost(QStringLiteral("localhost")); + bindingAddress.setPort(port); + bindingAddress.setPath(QStringLiteral("/api")); + QUrlQuery query; + query.addQueryItem(QStringLiteral("token"), secret); + bindingAddress.setQuery(query); + context->setContextProperty(QStringLiteral("bindingAddress"), bindingAddress); + + // prepare to use soundmangaer + smw = new LibSMWrapper(port, secret); + smw->wrapper_registerCallback(onEv, onRep); + smw->subscribe(QString("asyncSetSourceState")); + smw->subscribe(QString("asyncConnect")); + smw->run_eventloop(); + engine.rootContext()->setContextProperty("smw",smw); + } + + engine.load(QUrl(QStringLiteral("qrc:/MediaPlayer.qml"))); + + root = engine.rootObjects().first(); + QObject::connect(smw, SIGNAL(smEvent(QVariant, QVariant)), + root, SLOT(slotEvent(QVariant, QVariant))); + QObject::connect(smw, SIGNAL(smReply(QVariant)), + root, SLOT(slotReply(QVariant))); + + return app.exec(); +} + +static void onRep(struct json_object* reply_contents) +{ + qDebug("%s is called", __FUNCTION__); + QString str = QString(json_object_get_string(reply_contents)); + QJsonParseError error; + QJsonDocument jdoc = QJsonDocument::fromJson(str.toUtf8(), &error); + QJsonObject jobj = jdoc.object(); + + smw->emit_reply(jobj); + json_object_put(reply_contents); +} + +static void onEv(const std::string& event, struct json_object* event_contents) +{ + qDebug("%s is called", __FUNCTION__); + QString str = QString(json_object_get_string(event_contents)); + const QString event_name = QString(event.c_str()); + + if(firsttime){ + qDebug("check to return acknowledge to SM"); + if(!event_name.contains("asyncSetSourceState", Qt::CaseSensitive)){ + return; + } + /* this is temporary fix because QML doesn't catch signal if application is on background first*/ + qDebug("return acknowledge to SM"); + struct json_object *content_data, *content_handle, *content_sourceID; + qDebug() << str; + json_object_object_get_ex(event_contents,"data", &content_data); + json_bool has_handle = json_object_object_get_ex(content_data,"handle",&content_handle); + json_bool has_sourceID = json_object_object_get_ex(content_data,"sourceID",&content_sourceID); + if(!has_handle || !has_sourceID){ + qDebug("doesn't have sourceID/handle"); + return; + } + + int event_sourceID = json_object_get_int(content_sourceID); + /* QML has sourceID */ + mysourceID = root->property("sourceID").toInt(); + qDebug("my sourceID is %d", mysourceID); + + if(event_sourceID != mysourceID){ + qDebug("sourceID is not designated to me"); + return; + } + + /* Following code is mediaplayer only because mediaplayer doen't react in background first if it is on background*/ + struct json_object* ret_obj = json_object_new_object(); + json_object_object_add(ret_obj, "handle", content_handle); + json_object_object_add(ret_obj, "error", json_object_new_int(0)); + QString ret = QString(json_object_get_string(ret_obj)); + smw->call(QString("ackSetSourceState"), ret); + /* to here */ + firsttime = false; + } + + QJsonParseError error; + QJsonDocument jdoc = QJsonDocument::fromJson(str.toUtf8(), &error); + const QJsonObject jobj = jdoc.object(); + smw->emit_event(event_name, jobj); + + json_object_put(event_contents); +} diff --git a/sample/mediaplayer/app/mediaplayer.qrc b/sample/mediaplayer/app/mediaplayer.qrc new file mode 100644 index 0000000..15e5288 --- /dev/null +++ b/sample/mediaplayer/app/mediaplayer.qrc @@ -0,0 +1,7 @@ + + + MediaPlayer.qml + api/LightMediaScanner.qml + api/BluetoothManager.qml + + diff --git a/sample/mediaplayer/app/playlistwithmetadata.cpp b/sample/mediaplayer/app/playlistwithmetadata.cpp new file mode 100644 index 0000000..9e2e614 --- /dev/null +++ b/sample/mediaplayer/app/playlistwithmetadata.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "playlistwithmetadata.h" + +#include +#include +#include +#include +#include +#include + +class PlaylistWithMetadata::Private +{ +public: + Private(PlaylistWithMetadata *parent); + + void disconnect(); + void connect(); + +private: + void loadMetadata(int row); + +private: + PlaylistWithMetadata *q; + +public: + QAbstractListModel *source; + QList connections; + QList urls; + QHash title; + QHash artist; + QHash coverArt; + QHash duration; + QHash players; +}; + +PlaylistWithMetadata::Private::Private(PlaylistWithMetadata *parent) + : q(parent) + , source(nullptr) +{ +} + +void PlaylistWithMetadata::Private::disconnect() +{ + if (source) { + for (const auto &connection : connections) + q->disconnect(connection); + connections.clear(); + } +} + +void PlaylistWithMetadata::Private::connect() +{ + if (source) { + connections.append(q->connect(source, &QAbstractListModel::rowsAboutToBeInserted, [&](const QModelIndex &parent, int first, int last) { + Q_UNUSED(parent) + q->beginInsertRows(QModelIndex(), first, last); + })); + connections.append(q->connect(source, &QAbstractListModel::rowsInserted, [&](const QModelIndex &parent, int first, int last) { + Q_UNUSED(parent) + for (int i = first; i <= last; i++) { + loadMetadata(i); + } + q->endInsertRows(); + })); + + connections.append(q->connect(source, &QAbstractListModel::rowsAboutToBeRemoved, [&](const QModelIndex &parent, int first, int last) { + Q_UNUSED(parent) + q->beginRemoveRows(QModelIndex(), first, last); + })); + connections.append(q->connect(source, &QAbstractListModel::rowsRemoved, [&](const QModelIndex &parent, int first, int last) { + Q_UNUSED(parent) + for (int i = last; i >= first; --i) { + QUrl url = urls.at(i); + urls.removeAt(i); + + players.remove(url); + title.remove(url); + artist.remove(url); + coverArt.remove(url); + duration.remove(url); + } + q->endRemoveRows(); + })); + + int count = source->rowCount(); + if (count > 0) { + q->beginInsertRows(QModelIndex(), 0, count); + for (int i = 0; i < count; i++) { + loadMetadata(i); + } + q->endInsertRows(); + } + } +} + +void PlaylistWithMetadata::Private::loadMetadata(int row) +{ + QUrl url = source->data(source->index(row), Qt::UserRole + 1).toUrl(); + QMediaPlayer *player = new QMediaPlayer(q); + urls.append(url); + players.insert(url, player); + q->connect(player, &QMediaPlayer::mediaStatusChanged, [this, url](QMediaPlayer::MediaStatus mediaStatus) { + switch (mediaStatus) { + case QMediaPlayer::NoMedia: + case QMediaPlayer::LoadedMedia: { + QMediaPlayer *player = players.take(url); + title.insert(url, player->metaData(QMediaMetaData::Title).toString()); + artist.insert(url, player->metaData(QMediaMetaData::ContributingArtist).toString()); + QVariant coverArtImage = player->metaData(QMediaMetaData::CoverArtImage); + if (coverArtImage.type() == QVariant::Image) { + QImage image = coverArtImage.value(); + QByteArray data; + QBuffer buffer(&data); + buffer.open(QBuffer::WriteOnly); + QImageWriter png(&buffer, "png"); + if (png.write(image)) { + buffer.close(); + coverArt.insert(url, QUrl(QStringLiteral("data:image/png;base64,") + data.toBase64())); + } + } + duration.insert(url, player->duration()); + QModelIndex index = q->index(urls.indexOf(url)); + q->dataChanged(index, index, QVector() << TitleRole << ArtistRole << CoverArtRole << DurationRole); + player->deleteLater(); + break; } + default: + break; + } + + }); + player->setMedia(url); +} + +PlaylistWithMetadata::PlaylistWithMetadata(QObject *parent) + : QAbstractListModel(parent) + , d(new Private(this)) +{ +} + +PlaylistWithMetadata::~PlaylistWithMetadata() +{ + delete d; +} + +int PlaylistWithMetadata::rowCount(const QModelIndex &parent) const +{ + int ret = 0; + if (parent.isValid()) + return ret; + if (d->source) + ret = d->source->rowCount(QModelIndex()); + return ret; +} + +QVariant PlaylistWithMetadata::data(const QModelIndex &index, int role) const +{ + QVariant ret; + if (!index.isValid()) + return ret; + int row = index.row(); + if (row < 0 || rowCount() <= row) + return ret; + QUrl url = d->urls.at(row); + switch (role) { + case TitleRole: + ret = d->title.value(url); + if (ret.toString().isEmpty()) + ret = QVariant(url.fileName()); + break; + case ArtistRole: + ret = d->artist.value(url); + break; + case CoverArtRole: + ret = d->coverArt.value(url); + break; + case SourceRole: + ret = url; + break; + case DurationRole: + ret = d->duration.value(url); + break; + default: + qWarning() << role; + } + + return ret; +} + +QHash PlaylistWithMetadata::roleNames() const +{ + return { + {TitleRole, "title"}, + {ArtistRole, "artist"}, + {CoverArtRole, "coverArt"}, + {SourceRole, "source"}, + {DurationRole, "duration"} + }; +} + +QAbstractListModel *PlaylistWithMetadata::source() const +{ + return d->source; +} + +void PlaylistWithMetadata::setSource(QAbstractListModel *source) +{ + if (d->source == source) return; + d->disconnect(); + d->source = source; + d->connect(); + emit sourceChanged(source); +} diff --git a/sample/mediaplayer/app/playlistwithmetadata.h b/sample/mediaplayer/app/playlistwithmetadata.h new file mode 100644 index 0000000..74cf6f5 --- /dev/null +++ b/sample/mediaplayer/app/playlistwithmetadata.h @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PLAYLISTWITHMETADATA_H +#define PLAYLISTWITHMETADATA_H + +#include + +class PlaylistWithMetadata : public QAbstractListModel +{ + Q_OBJECT + Q_PROPERTY(QAbstractListModel *source READ source WRITE setSource NOTIFY sourceChanged) +public: + PlaylistWithMetadata(QObject *parent = nullptr); + ~PlaylistWithMetadata(); + + enum { + TitleRole = Qt::DisplayRole + , ArtistRole = Qt::UserRole + 1 + , CoverArtRole + , SourceRole + , DurationRole + }; + + int rowCount(const QModelIndex &parent = QModelIndex()) const override; + QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override; + QHash roleNames() const override; + + QAbstractListModel *source() const; + +public slots: + void setSource(QAbstractListModel *source); + +signals: + void sourceChanged(QAbstractListModel *source); + +private: + class Private; + Private *d; +}; + +#endif // PLAYLISTWITHMETADATA_H diff --git a/sample/mediaplayer/binding/binding.pri b/sample/mediaplayer/binding/binding.pri new file mode 100644 index 0000000..3448a56 --- /dev/null +++ b/sample/mediaplayer/binding/binding.pri @@ -0,0 +1,6 @@ +TEMPLATE = lib +CONFIG += plugin use_c_linker +CONFIG -= qt +QMAKE_CFLAGS += -Wextra -Wconversion -Wno-unused-parameter -Werror=maybe-uninitialized -Werror=implicit-function-declaration -ffunction-sections -fdata-sections -Wl,--as-needed -Wl,--gc-sections + +DESTDIR = $${OUT_PWD}/../package/root/lib diff --git a/sample/mediaplayer/binding/binding.pro b/sample/mediaplayer/binding/binding.pro new file mode 100644 index 0000000..8a3ef73 --- /dev/null +++ b/sample/mediaplayer/binding/binding.pro @@ -0,0 +1,16 @@ +TARGET = mediaplayer-binding + +HEADERS = mediaplayer-manager.h \ + gdbus/lightmediascanner_interface.h + +SOURCES = mediaplayer-api.c \ + mediaplayer-manager.c \ + gdbus/lightmediascanner_interface.c + +LIBS += -Wl,--version-script=$$PWD/export.map + +CONFIG += link_pkgconfig +INCLUDEPATH += $$PWD/gdbus +PKGCONFIG += json-c afb-daemon sqlite3 glib-2.0 gio-2.0 gio-unix-2.0 zlib + +include(binding.pri) diff --git a/sample/mediaplayer/binding/export.map b/sample/mediaplayer/binding/export.map new file mode 100644 index 0000000..eea0d7b --- /dev/null +++ b/sample/mediaplayer/binding/export.map @@ -0,0 +1 @@ +{ global: afbBindingV2*; local: *; }; diff --git a/sample/mediaplayer/binding/gdbus/api/org.lightmediascanner.xml b/sample/mediaplayer/binding/gdbus/api/org.lightmediascanner.xml new file mode 100644 index 0000000..1651b47 --- /dev/null +++ b/sample/mediaplayer/binding/gdbus/api/org.lightmediascanner.xml @@ -0,0 +1,75 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/sample/mediaplayer/binding/gdbus/generate_interfaces.sh b/sample/mediaplayer/binding/gdbus/generate_interfaces.sh new file mode 100755 index 0000000..f5cbc66 --- /dev/null +++ b/sample/mediaplayer/binding/gdbus/generate_interfaces.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +CG=gdbus-codegen +API=api + +$CG \ + --interface-prefix org.lightmediascanner. \ + --generate-c-code lightmediascanner_interface \ + $API/org.lightmediascanner.xml diff --git a/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.c b/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.c new file mode 100644 index 0000000..6269a7d --- /dev/null +++ b/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.c @@ -0,0 +1,5755 @@ +/* + * Generated by gdbus-codegen 2.52.0. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "lightmediascanner_interface.h" + +#include +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface org.freedesktop.DBus.Properties + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:OrgFreedesktopDBusProperties + * @title: OrgFreedesktopDBusProperties + * @short_description: Generated C code for the org.freedesktop.DBus.Properties D-Bus interface + * + * This section contains code for working with the org.freedesktop.DBus.Properties D-Bus interface in C. + */ + +/* ---- Introspection data for org.freedesktop.DBus.Properties ---- */ + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_get_IN_ARG_interface_name = +{ + { + -1, + (gchar *) "interface_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_get_IN_ARG_property_name = +{ + { + -1, + (gchar *) "property_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_method_info_get_IN_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_get_IN_ARG_interface_name, + &_org_freedesktop_dbus_properties_method_info_get_IN_ARG_property_name, + NULL +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_get_OUT_ARG_value = +{ + { + -1, + (gchar *) "value", + (gchar *) "v", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_method_info_get_OUT_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_get_OUT_ARG_value, + NULL +}; + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_properties_method_info_get = +{ + { + -1, + (gchar *) "Get", + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_method_info_get_IN_ARG_pointers, + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_method_info_get_OUT_ARG_pointers, + NULL + }, + "handle-get", + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_get_all_IN_ARG_interface_name = +{ + { + -1, + (gchar *) "interface_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_method_info_get_all_IN_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_get_all_IN_ARG_interface_name, + NULL +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_get_all_OUT_ARG_properties = +{ + { + -1, + (gchar *) "properties", + (gchar *) "a{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_method_info_get_all_OUT_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_get_all_OUT_ARG_properties, + NULL +}; + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_properties_method_info_get_all = +{ + { + -1, + (gchar *) "GetAll", + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_method_info_get_all_IN_ARG_pointers, + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_method_info_get_all_OUT_ARG_pointers, + NULL + }, + "handle-get-all", + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_set_IN_ARG_interface_name = +{ + { + -1, + (gchar *) "interface_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_set_IN_ARG_property_name = +{ + { + -1, + (gchar *) "property_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_method_info_set_IN_ARG_value = +{ + { + -1, + (gchar *) "value", + (gchar *) "v", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_method_info_set_IN_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_set_IN_ARG_interface_name, + &_org_freedesktop_dbus_properties_method_info_set_IN_ARG_property_name, + &_org_freedesktop_dbus_properties_method_info_set_IN_ARG_value, + NULL +}; + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_properties_method_info_set = +{ + { + -1, + (gchar *) "Set", + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_method_info_set_IN_ARG_pointers, + NULL, + NULL + }, + "handle-set", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _org_freedesktop_dbus_properties_method_info_pointers[] = +{ + &_org_freedesktop_dbus_properties_method_info_get, + &_org_freedesktop_dbus_properties_method_info_get_all, + &_org_freedesktop_dbus_properties_method_info_set, + NULL +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_interface_name = +{ + { + -1, + (gchar *) "interface_name", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_changed_properties = +{ + { + -1, + (gchar *) "changed_properties", + (gchar *) "a{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_invalidated_properties = +{ + { + -1, + (gchar *) "invalidated_properties", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_pointers[] = +{ + &_org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_interface_name, + &_org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_changed_properties, + &_org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_invalidated_properties, + NULL +}; + +static const _ExtendedGDBusSignalInfo _org_freedesktop_dbus_properties_signal_info_properties_changed = +{ + { + -1, + (gchar *) "PropertiesChanged", + (GDBusArgInfo **) &_org_freedesktop_dbus_properties_signal_info_properties_changed_ARG_pointers, + NULL + }, + "properties-changed" +}; + +static const _ExtendedGDBusSignalInfo * const _org_freedesktop_dbus_properties_signal_info_pointers[] = +{ + &_org_freedesktop_dbus_properties_signal_info_properties_changed, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _org_freedesktop_dbus_properties_interface_info = +{ + { + -1, + (gchar *) "org.freedesktop.DBus.Properties", + (GDBusMethodInfo **) &_org_freedesktop_dbus_properties_method_info_pointers, + (GDBusSignalInfo **) &_org_freedesktop_dbus_properties_signal_info_pointers, + NULL, + NULL + }, + "org-freedesktop-dbus-properties", +}; + + +/** + * org_freedesktop_dbus_properties_interface_info: + * + * Gets a machine-readable description of the org.freedesktop.DBus.Properties D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +org_freedesktop_dbus_properties_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct; +} + +/** + * org_freedesktop_dbus_properties_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #OrgFreedesktopDBusProperties interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +org_freedesktop_dbus_properties_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * OrgFreedesktopDBusProperties: + * + * Abstract interface type for the D-Bus interface org.freedesktop.DBus.Properties. + */ + +/** + * OrgFreedesktopDBusPropertiesIface: + * @parent_iface: The parent interface. + * @handle_get: Handler for the #OrgFreedesktopDBusProperties::handle-get signal. + * @handle_get_all: Handler for the #OrgFreedesktopDBusProperties::handle-get-all signal. + * @handle_set: Handler for the #OrgFreedesktopDBusProperties::handle-set signal. + * @properties_changed: Handler for the #OrgFreedesktopDBusProperties::properties-changed signal. + * + * Virtual table for the D-Bus interface org.freedesktop.DBus.Properties. + */ + +typedef OrgFreedesktopDBusPropertiesIface OrgFreedesktopDBusPropertiesInterface; +G_DEFINE_INTERFACE (OrgFreedesktopDBusProperties, org_freedesktop_dbus_properties, G_TYPE_OBJECT); + +static void +org_freedesktop_dbus_properties_default_init (OrgFreedesktopDBusPropertiesIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * OrgFreedesktopDBusProperties::handle-get: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: A #GDBusMethodInvocation. + * @arg_interface_name: Argument passed by remote caller. + * @arg_property_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the Get() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_properties_complete_get() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPropertiesIface, handle_get), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING); + + /** + * OrgFreedesktopDBusProperties::handle-get-all: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: A #GDBusMethodInvocation. + * @arg_interface_name: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetAll() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_properties_complete_get_all() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-all", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPropertiesIface, handle_get_all), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING); + + /** + * OrgFreedesktopDBusProperties::handle-set: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: A #GDBusMethodInvocation. + * @arg_interface_name: Argument passed by remote caller. + * @arg_property_name: Argument passed by remote caller. + * @arg_value: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the Set() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_properties_complete_set() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-set", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPropertiesIface, handle_set), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT); + + /* GObject signals for received D-Bus signals: */ + /** + * OrgFreedesktopDBusProperties::properties-changed: + * @object: A #OrgFreedesktopDBusProperties. + * @arg_interface_name: Argument. + * @arg_changed_properties: Argument. + * @arg_invalidated_properties: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "PropertiesChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("properties-changed", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPropertiesIface, properties_changed), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 3, G_TYPE_STRING, G_TYPE_VARIANT, G_TYPE_STRV); + +} + +/** + * org_freedesktop_dbus_properties_emit_properties_changed: + * @object: A #OrgFreedesktopDBusProperties. + * @arg_interface_name: Argument to pass with the signal. + * @arg_changed_properties: Argument to pass with the signal. + * @arg_invalidated_properties: Argument to pass with the signal. + * + * Emits the "PropertiesChanged" D-Bus signal. + */ +void +org_freedesktop_dbus_properties_emit_properties_changed ( + OrgFreedesktopDBusProperties *object, + const gchar *arg_interface_name, + GVariant *arg_changed_properties, + const gchar *const *arg_invalidated_properties) +{ + g_signal_emit_by_name (object, "properties-changed", arg_interface_name, arg_changed_properties, arg_invalidated_properties); +} + +/** + * org_freedesktop_dbus_properties_call_get: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @arg_property_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Get() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_properties_call_get_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_properties_call_get_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_properties_call_get ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Get", + g_variant_new ("(ss)", + arg_interface_name, + arg_property_name), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_properties_call_get_finish: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_properties_call_get(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_properties_call_get(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_get_finish ( + OrgFreedesktopDBusProperties *proxy, + GVariant **out_value, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@v)", + out_value); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_call_get_sync: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @arg_property_name: Argument to pass with the method invocation. + * @out_value: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Get() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_properties_call_get() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_get_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant **out_value, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Get", + g_variant_new ("(ss)", + arg_interface_name, + arg_property_name), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@v)", + out_value); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_call_get_all: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetAll() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_properties_call_get_all_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_properties_call_get_all_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_properties_call_get_all ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetAll", + g_variant_new ("(s)", + arg_interface_name), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_properties_call_get_all_finish: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @out_properties: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_properties_call_get_all(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_properties_call_get_all(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_get_all_finish ( + OrgFreedesktopDBusProperties *proxy, + GVariant **out_properties, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@a{sv})", + out_properties); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_call_get_all_sync: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @out_properties: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetAll() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_properties_call_get_all() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_get_all_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + GVariant **out_properties, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetAll", + g_variant_new ("(s)", + arg_interface_name), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@a{sv})", + out_properties); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_call_set: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @arg_property_name: Argument to pass with the method invocation. + * @arg_value: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Set() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_properties_call_set_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_properties_call_set_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_properties_call_set ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant *arg_value, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Set", + g_variant_new ("(ss@v)", + arg_interface_name, + arg_property_name, + arg_value), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_properties_call_set_finish: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_properties_call_set(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_properties_call_set(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_set_finish ( + OrgFreedesktopDBusProperties *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_call_set_sync: + * @proxy: A #OrgFreedesktopDBusPropertiesProxy. + * @arg_interface_name: Argument to pass with the method invocation. + * @arg_property_name: Argument to pass with the method invocation. + * @arg_value: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Set() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_properties_call_set() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_properties_call_set_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant *arg_value, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Set", + g_variant_new ("(ss@v)", + arg_interface_name, + arg_property_name, + arg_value), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_properties_complete_get: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @value: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the Get() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_properties_complete_get ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + GVariant *value) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@v)", + value)); +} + +/** + * org_freedesktop_dbus_properties_complete_get_all: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @properties: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetAll() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_properties_complete_get_all ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + GVariant *properties) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@a{sv})", + properties)); +} + +/** + * org_freedesktop_dbus_properties_complete_set: + * @object: A #OrgFreedesktopDBusProperties. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Set() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_properties_complete_set ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusPropertiesProxy: + * + * The #OrgFreedesktopDBusPropertiesProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusPropertiesProxyClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusPropertiesProxy. + */ + +struct _OrgFreedesktopDBusPropertiesProxyPrivate +{ + GData *qdata; +}; + +static void org_freedesktop_dbus_properties_proxy_iface_init (OrgFreedesktopDBusPropertiesIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPropertiesProxy, org_freedesktop_dbus_properties_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (OrgFreedesktopDBusPropertiesProxy) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, org_freedesktop_dbus_properties_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPropertiesProxy, org_freedesktop_dbus_properties_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, org_freedesktop_dbus_properties_proxy_iface_init)); + +#endif +static void +org_freedesktop_dbus_properties_proxy_finalize (GObject *object) +{ + OrgFreedesktopDBusPropertiesProxy *proxy = ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (org_freedesktop_dbus_properties_proxy_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_properties_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_properties_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_properties_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + gsize n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +org_freedesktop_dbus_properties_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + OrgFreedesktopDBusPropertiesProxy *proxy = ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +org_freedesktop_dbus_properties_proxy_init (OrgFreedesktopDBusPropertiesProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = org_freedesktop_dbus_properties_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, OrgFreedesktopDBusPropertiesProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_freedesktop_dbus_properties_interface_info ()); +} + +static void +org_freedesktop_dbus_properties_proxy_class_init (OrgFreedesktopDBusPropertiesProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_properties_proxy_finalize; + gobject_class->get_property = org_freedesktop_dbus_properties_proxy_get_property; + gobject_class->set_property = org_freedesktop_dbus_properties_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = org_freedesktop_dbus_properties_proxy_g_signal; + proxy_class->g_properties_changed = org_freedesktop_dbus_properties_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusPropertiesProxyPrivate)); +#endif +} + +static void +org_freedesktop_dbus_properties_proxy_iface_init (OrgFreedesktopDBusPropertiesIface *iface) +{ +} + +/** + * org_freedesktop_dbus_properties_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Properties. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_properties_proxy_new_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_properties_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_properties_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Properties", NULL); +} + +/** + * org_freedesktop_dbus_properties_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_properties_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_properties_proxy_new(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusPropertiesProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusProperties * +org_freedesktop_dbus_properties_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PROPERTIES (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_properties_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Properties. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_properties_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPropertiesProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusProperties * +org_freedesktop_dbus_properties_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Properties", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PROPERTIES (ret); + else + return NULL; +} + + +/** + * org_freedesktop_dbus_properties_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like org_freedesktop_dbus_properties_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_properties_proxy_new_for_bus_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_properties_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_properties_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Properties", NULL); +} + +/** + * org_freedesktop_dbus_properties_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_properties_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_properties_proxy_new_for_bus(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusPropertiesProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusProperties * +org_freedesktop_dbus_properties_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PROPERTIES (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_properties_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like org_freedesktop_dbus_properties_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_properties_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPropertiesProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusProperties * +org_freedesktop_dbus_properties_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Properties", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PROPERTIES (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusPropertiesSkeleton: + * + * The #OrgFreedesktopDBusPropertiesSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusPropertiesSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusPropertiesSkeleton. + */ + +struct _OrgFreedesktopDBusPropertiesSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_org_freedesktop_dbus_properties_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + guint num_extra; + gsize n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_org_freedesktop_dbus_properties_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_org_freedesktop_dbus_properties_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_properties_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _org_freedesktop_dbus_properties_skeleton_vtable = +{ + _org_freedesktop_dbus_properties_skeleton_handle_method_call, + _org_freedesktop_dbus_properties_skeleton_handle_get_property, + _org_freedesktop_dbus_properties_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +org_freedesktop_dbus_properties_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return org_freedesktop_dbus_properties_interface_info (); +} + +static GDBusInterfaceVTable * +org_freedesktop_dbus_properties_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_org_freedesktop_dbus_properties_skeleton_vtable; +} + +static GVariant * +org_freedesktop_dbus_properties_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_org_freedesktop_dbus_properties_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _org_freedesktop_dbus_properties_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _org_freedesktop_dbus_properties_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _org_freedesktop_dbus_properties_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.DBus.Properties", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +org_freedesktop_dbus_properties_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void +_org_freedesktop_dbus_properties_on_signal_properties_changed ( + OrgFreedesktopDBusProperties *object, + const gchar *arg_interface_name, + GVariant *arg_changed_properties, + const gchar *const *arg_invalidated_properties) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(s@a{sv}^as)", + arg_interface_name, + arg_changed_properties, + arg_invalidated_properties)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.DBus.Properties", "PropertiesChanged", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void org_freedesktop_dbus_properties_skeleton_iface_init (OrgFreedesktopDBusPropertiesIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPropertiesSkeleton, org_freedesktop_dbus_properties_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (OrgFreedesktopDBusPropertiesSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, org_freedesktop_dbus_properties_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPropertiesSkeleton, org_freedesktop_dbus_properties_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, org_freedesktop_dbus_properties_skeleton_iface_init)); + +#endif +static void +org_freedesktop_dbus_properties_skeleton_finalize (GObject *object) +{ + OrgFreedesktopDBusPropertiesSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (org_freedesktop_dbus_properties_skeleton_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_properties_skeleton_init (OrgFreedesktopDBusPropertiesSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = org_freedesktop_dbus_properties_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON, OrgFreedesktopDBusPropertiesSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +org_freedesktop_dbus_properties_skeleton_class_init (OrgFreedesktopDBusPropertiesSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_properties_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = org_freedesktop_dbus_properties_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = org_freedesktop_dbus_properties_skeleton_dbus_interface_get_properties; + skeleton_class->flush = org_freedesktop_dbus_properties_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = org_freedesktop_dbus_properties_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusPropertiesSkeletonPrivate)); +#endif +} + +static void +org_freedesktop_dbus_properties_skeleton_iface_init (OrgFreedesktopDBusPropertiesIface *iface) +{ + iface->properties_changed = _org_freedesktop_dbus_properties_on_signal_properties_changed; +} + +/** + * org_freedesktop_dbus_properties_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.freedesktop.DBus.Properties. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPropertiesSkeleton): The skeleton object. + */ +OrgFreedesktopDBusProperties * +org_freedesktop_dbus_properties_skeleton_new (void) +{ + return ORG_FREEDESKTOP_DBUS_PROPERTIES (g_object_new (TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for interface org.freedesktop.DBus.Introspectable + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:OrgFreedesktopDBusIntrospectable + * @title: OrgFreedesktopDBusIntrospectable + * @short_description: Generated C code for the org.freedesktop.DBus.Introspectable D-Bus interface + * + * This section contains code for working with the org.freedesktop.DBus.Introspectable D-Bus interface in C. + */ + +/* ---- Introspection data for org.freedesktop.DBus.Introspectable ---- */ + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_introspectable_method_info_introspect_OUT_ARG_xml_data = +{ + { + -1, + (gchar *) "xml_data", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_introspectable_method_info_introspect_OUT_ARG_pointers[] = +{ + &_org_freedesktop_dbus_introspectable_method_info_introspect_OUT_ARG_xml_data, + NULL +}; + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_introspectable_method_info_introspect = +{ + { + -1, + (gchar *) "Introspect", + NULL, + (GDBusArgInfo **) &_org_freedesktop_dbus_introspectable_method_info_introspect_OUT_ARG_pointers, + NULL + }, + "handle-introspect", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _org_freedesktop_dbus_introspectable_method_info_pointers[] = +{ + &_org_freedesktop_dbus_introspectable_method_info_introspect, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _org_freedesktop_dbus_introspectable_interface_info = +{ + { + -1, + (gchar *) "org.freedesktop.DBus.Introspectable", + (GDBusMethodInfo **) &_org_freedesktop_dbus_introspectable_method_info_pointers, + NULL, + NULL, + NULL + }, + "org-freedesktop-dbus-introspectable", +}; + + +/** + * org_freedesktop_dbus_introspectable_interface_info: + * + * Gets a machine-readable description of the org.freedesktop.DBus.Introspectable D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +org_freedesktop_dbus_introspectable_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct; +} + +/** + * org_freedesktop_dbus_introspectable_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #OrgFreedesktopDBusIntrospectable interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +org_freedesktop_dbus_introspectable_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * OrgFreedesktopDBusIntrospectable: + * + * Abstract interface type for the D-Bus interface org.freedesktop.DBus.Introspectable. + */ + +/** + * OrgFreedesktopDBusIntrospectableIface: + * @parent_iface: The parent interface. + * @handle_introspect: Handler for the #OrgFreedesktopDBusIntrospectable::handle-introspect signal. + * + * Virtual table for the D-Bus interface org.freedesktop.DBus.Introspectable. + */ + +typedef OrgFreedesktopDBusIntrospectableIface OrgFreedesktopDBusIntrospectableInterface; +G_DEFINE_INTERFACE (OrgFreedesktopDBusIntrospectable, org_freedesktop_dbus_introspectable, G_TYPE_OBJECT); + +static void +org_freedesktop_dbus_introspectable_default_init (OrgFreedesktopDBusIntrospectableIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * OrgFreedesktopDBusIntrospectable::handle-introspect: + * @object: A #OrgFreedesktopDBusIntrospectable. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Introspect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_introspectable_complete_introspect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-introspect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusIntrospectableIface, handle_introspect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + +} + +/** + * org_freedesktop_dbus_introspectable_call_introspect: + * @proxy: A #OrgFreedesktopDBusIntrospectableProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Introspect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_introspectable_call_introspect_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_introspectable_call_introspect_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_introspectable_call_introspect ( + OrgFreedesktopDBusIntrospectable *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Introspect", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_introspectable_call_introspect_finish: + * @proxy: A #OrgFreedesktopDBusIntrospectableProxy. + * @out_xml_data: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_introspectable_call_introspect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_introspectable_call_introspect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_introspectable_call_introspect_finish ( + OrgFreedesktopDBusIntrospectable *proxy, + gchar **out_xml_data, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_xml_data); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_introspectable_call_introspect_sync: + * @proxy: A #OrgFreedesktopDBusIntrospectableProxy. + * @out_xml_data: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Introspect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_introspectable_call_introspect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_introspectable_call_introspect_sync ( + OrgFreedesktopDBusIntrospectable *proxy, + gchar **out_xml_data, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Introspect", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_xml_data); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_introspectable_complete_introspect: + * @object: A #OrgFreedesktopDBusIntrospectable. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @xml_data: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the Introspect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_introspectable_complete_introspect ( + OrgFreedesktopDBusIntrospectable *object, + GDBusMethodInvocation *invocation, + const gchar *xml_data) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(s)", + xml_data)); +} + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusIntrospectableProxy: + * + * The #OrgFreedesktopDBusIntrospectableProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusIntrospectableProxyClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusIntrospectableProxy. + */ + +struct _OrgFreedesktopDBusIntrospectableProxyPrivate +{ + GData *qdata; +}; + +static void org_freedesktop_dbus_introspectable_proxy_iface_init (OrgFreedesktopDBusIntrospectableIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusIntrospectableProxy, org_freedesktop_dbus_introspectable_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (OrgFreedesktopDBusIntrospectableProxy) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, org_freedesktop_dbus_introspectable_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusIntrospectableProxy, org_freedesktop_dbus_introspectable_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, org_freedesktop_dbus_introspectable_proxy_iface_init)); + +#endif +static void +org_freedesktop_dbus_introspectable_proxy_finalize (GObject *object) +{ + OrgFreedesktopDBusIntrospectableProxy *proxy = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (org_freedesktop_dbus_introspectable_proxy_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_introspectable_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_introspectable_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_introspectable_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + gsize n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +org_freedesktop_dbus_introspectable_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + OrgFreedesktopDBusIntrospectableProxy *proxy = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +org_freedesktop_dbus_introspectable_proxy_init (OrgFreedesktopDBusIntrospectableProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = org_freedesktop_dbus_introspectable_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, OrgFreedesktopDBusIntrospectableProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_freedesktop_dbus_introspectable_interface_info ()); +} + +static void +org_freedesktop_dbus_introspectable_proxy_class_init (OrgFreedesktopDBusIntrospectableProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_introspectable_proxy_finalize; + gobject_class->get_property = org_freedesktop_dbus_introspectable_proxy_get_property; + gobject_class->set_property = org_freedesktop_dbus_introspectable_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = org_freedesktop_dbus_introspectable_proxy_g_signal; + proxy_class->g_properties_changed = org_freedesktop_dbus_introspectable_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusIntrospectableProxyPrivate)); +#endif +} + +static void +org_freedesktop_dbus_introspectable_proxy_iface_init (OrgFreedesktopDBusIntrospectableIface *iface) +{ +} + +/** + * org_freedesktop_dbus_introspectable_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Introspectable. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_introspectable_proxy_new_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_introspectable_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_introspectable_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL); +} + +/** + * org_freedesktop_dbus_introspectable_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_introspectable_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_introspectable_proxy_new(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusIntrospectableProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusIntrospectable * +org_freedesktop_dbus_introspectable_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_introspectable_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Introspectable. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_introspectable_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusIntrospectableProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusIntrospectable * +org_freedesktop_dbus_introspectable_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (ret); + else + return NULL; +} + + +/** + * org_freedesktop_dbus_introspectable_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like org_freedesktop_dbus_introspectable_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_introspectable_proxy_new_for_bus_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_introspectable_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_introspectable_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL); +} + +/** + * org_freedesktop_dbus_introspectable_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_introspectable_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_introspectable_proxy_new_for_bus(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusIntrospectableProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusIntrospectable * +org_freedesktop_dbus_introspectable_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_introspectable_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like org_freedesktop_dbus_introspectable_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_introspectable_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusIntrospectableProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusIntrospectable * +org_freedesktop_dbus_introspectable_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusIntrospectableSkeleton: + * + * The #OrgFreedesktopDBusIntrospectableSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusIntrospectableSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusIntrospectableSkeleton. + */ + +struct _OrgFreedesktopDBusIntrospectableSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_org_freedesktop_dbus_introspectable_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + OrgFreedesktopDBusIntrospectableSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + guint num_extra; + gsize n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_org_freedesktop_dbus_introspectable_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusIntrospectableSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_org_freedesktop_dbus_introspectable_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusIntrospectableSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_introspectable_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _org_freedesktop_dbus_introspectable_skeleton_vtable = +{ + _org_freedesktop_dbus_introspectable_skeleton_handle_method_call, + _org_freedesktop_dbus_introspectable_skeleton_handle_get_property, + _org_freedesktop_dbus_introspectable_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return org_freedesktop_dbus_introspectable_interface_info (); +} + +static GDBusInterfaceVTable * +org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_org_freedesktop_dbus_introspectable_skeleton_vtable; +} + +static GVariant * +org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + OrgFreedesktopDBusIntrospectableSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_org_freedesktop_dbus_introspectable_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _org_freedesktop_dbus_introspectable_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _org_freedesktop_dbus_introspectable_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _org_freedesktop_dbus_introspectable_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.DBus.Introspectable", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +org_freedesktop_dbus_introspectable_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void org_freedesktop_dbus_introspectable_skeleton_iface_init (OrgFreedesktopDBusIntrospectableIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusIntrospectableSkeleton, org_freedesktop_dbus_introspectable_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (OrgFreedesktopDBusIntrospectableSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, org_freedesktop_dbus_introspectable_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusIntrospectableSkeleton, org_freedesktop_dbus_introspectable_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, org_freedesktop_dbus_introspectable_skeleton_iface_init)); + +#endif +static void +org_freedesktop_dbus_introspectable_skeleton_finalize (GObject *object) +{ + OrgFreedesktopDBusIntrospectableSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (org_freedesktop_dbus_introspectable_skeleton_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_introspectable_skeleton_init (OrgFreedesktopDBusIntrospectableSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = org_freedesktop_dbus_introspectable_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON, OrgFreedesktopDBusIntrospectableSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +org_freedesktop_dbus_introspectable_skeleton_class_init (OrgFreedesktopDBusIntrospectableSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_introspectable_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_properties; + skeleton_class->flush = org_freedesktop_dbus_introspectable_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = org_freedesktop_dbus_introspectable_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusIntrospectableSkeletonPrivate)); +#endif +} + +static void +org_freedesktop_dbus_introspectable_skeleton_iface_init (OrgFreedesktopDBusIntrospectableIface *iface) +{ +} + +/** + * org_freedesktop_dbus_introspectable_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.freedesktop.DBus.Introspectable. + * + * Returns: (transfer full) (type OrgFreedesktopDBusIntrospectableSkeleton): The skeleton object. + */ +OrgFreedesktopDBusIntrospectable * +org_freedesktop_dbus_introspectable_skeleton_new (void) +{ + return ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (g_object_new (TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for interface org.freedesktop.DBus.Peer + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:OrgFreedesktopDBusPeer + * @title: OrgFreedesktopDBusPeer + * @short_description: Generated C code for the org.freedesktop.DBus.Peer D-Bus interface + * + * This section contains code for working with the org.freedesktop.DBus.Peer D-Bus interface in C. + */ + +/* ---- Introspection data for org.freedesktop.DBus.Peer ---- */ + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_peer_method_info_ping = +{ + { + -1, + (gchar *) "Ping", + NULL, + NULL, + NULL + }, + "handle-ping", + FALSE +}; + +static const _ExtendedGDBusArgInfo _org_freedesktop_dbus_peer_method_info_get_machine_id_OUT_ARG_machine_uuid = +{ + { + -1, + (gchar *) "machine_uuid", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _org_freedesktop_dbus_peer_method_info_get_machine_id_OUT_ARG_pointers[] = +{ + &_org_freedesktop_dbus_peer_method_info_get_machine_id_OUT_ARG_machine_uuid, + NULL +}; + +static const _ExtendedGDBusMethodInfo _org_freedesktop_dbus_peer_method_info_get_machine_id = +{ + { + -1, + (gchar *) "GetMachineId", + NULL, + (GDBusArgInfo **) &_org_freedesktop_dbus_peer_method_info_get_machine_id_OUT_ARG_pointers, + NULL + }, + "handle-get-machine-id", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _org_freedesktop_dbus_peer_method_info_pointers[] = +{ + &_org_freedesktop_dbus_peer_method_info_ping, + &_org_freedesktop_dbus_peer_method_info_get_machine_id, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _org_freedesktop_dbus_peer_interface_info = +{ + { + -1, + (gchar *) "org.freedesktop.DBus.Peer", + (GDBusMethodInfo **) &_org_freedesktop_dbus_peer_method_info_pointers, + NULL, + NULL, + NULL + }, + "org-freedesktop-dbus-peer", +}; + + +/** + * org_freedesktop_dbus_peer_interface_info: + * + * Gets a machine-readable description of the org.freedesktop.DBus.Peer D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +org_freedesktop_dbus_peer_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct; +} + +/** + * org_freedesktop_dbus_peer_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #OrgFreedesktopDBusPeer interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +org_freedesktop_dbus_peer_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * OrgFreedesktopDBusPeer: + * + * Abstract interface type for the D-Bus interface org.freedesktop.DBus.Peer. + */ + +/** + * OrgFreedesktopDBusPeerIface: + * @parent_iface: The parent interface. + * @handle_get_machine_id: Handler for the #OrgFreedesktopDBusPeer::handle-get-machine-id signal. + * @handle_ping: Handler for the #OrgFreedesktopDBusPeer::handle-ping signal. + * + * Virtual table for the D-Bus interface org.freedesktop.DBus.Peer. + */ + +typedef OrgFreedesktopDBusPeerIface OrgFreedesktopDBusPeerInterface; +G_DEFINE_INTERFACE (OrgFreedesktopDBusPeer, org_freedesktop_dbus_peer, G_TYPE_OBJECT); + +static void +org_freedesktop_dbus_peer_default_init (OrgFreedesktopDBusPeerIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * OrgFreedesktopDBusPeer::handle-ping: + * @object: A #OrgFreedesktopDBusPeer. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Ping() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_peer_complete_ping() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ping", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPeerIface, handle_ping), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * OrgFreedesktopDBusPeer::handle-get-machine-id: + * @object: A #OrgFreedesktopDBusPeer. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetMachineId() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call org_freedesktop_dbus_peer_complete_get_machine_id() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-machine-id", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (OrgFreedesktopDBusPeerIface, handle_get_machine_id), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + +} + +/** + * org_freedesktop_dbus_peer_call_ping: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Ping() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_peer_call_ping_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_peer_call_ping_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_peer_call_ping ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Ping", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_peer_call_ping_finish: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_peer_call_ping(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_peer_call_ping(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_peer_call_ping_finish ( + OrgFreedesktopDBusPeer *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_peer_call_ping_sync: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Ping() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_peer_call_ping() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_peer_call_ping_sync ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Ping", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_peer_call_get_machine_id: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetMachineId() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_peer_call_get_machine_id_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_peer_call_get_machine_id_sync() for the synchronous, blocking version of this method. + */ +void +org_freedesktop_dbus_peer_call_get_machine_id ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetMachineId", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * org_freedesktop_dbus_peer_call_get_machine_id_finish: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @out_machine_uuid: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_peer_call_get_machine_id(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with org_freedesktop_dbus_peer_call_get_machine_id(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_peer_call_get_machine_id_finish ( + OrgFreedesktopDBusPeer *proxy, + gchar **out_machine_uuid, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_machine_uuid); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_peer_call_get_machine_id_sync: + * @proxy: A #OrgFreedesktopDBusPeerProxy. + * @out_machine_uuid: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetMachineId() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_peer_call_get_machine_id() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +org_freedesktop_dbus_peer_call_get_machine_id_sync ( + OrgFreedesktopDBusPeer *proxy, + gchar **out_machine_uuid, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetMachineId", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_machine_uuid); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * org_freedesktop_dbus_peer_complete_ping: + * @object: A #OrgFreedesktopDBusPeer. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Ping() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_peer_complete_ping ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * org_freedesktop_dbus_peer_complete_get_machine_id: + * @object: A #OrgFreedesktopDBusPeer. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @machine_uuid: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetMachineId() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +org_freedesktop_dbus_peer_complete_get_machine_id ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation, + const gchar *machine_uuid) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(s)", + machine_uuid)); +} + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusPeerProxy: + * + * The #OrgFreedesktopDBusPeerProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusPeerProxyClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusPeerProxy. + */ + +struct _OrgFreedesktopDBusPeerProxyPrivate +{ + GData *qdata; +}; + +static void org_freedesktop_dbus_peer_proxy_iface_init (OrgFreedesktopDBusPeerIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPeerProxy, org_freedesktop_dbus_peer_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (OrgFreedesktopDBusPeerProxy) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PEER, org_freedesktop_dbus_peer_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPeerProxy, org_freedesktop_dbus_peer_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PEER, org_freedesktop_dbus_peer_proxy_iface_init)); + +#endif +static void +org_freedesktop_dbus_peer_proxy_finalize (GObject *object) +{ + OrgFreedesktopDBusPeerProxy *proxy = ORG_FREEDESKTOP_DBUS_PEER_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (org_freedesktop_dbus_peer_proxy_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_peer_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_peer_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +org_freedesktop_dbus_peer_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + gsize n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_ORG_FREEDESKTOP_DBUS_PEER); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_PEER); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +org_freedesktop_dbus_peer_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + OrgFreedesktopDBusPeerProxy *proxy = ORG_FREEDESKTOP_DBUS_PEER_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +org_freedesktop_dbus_peer_proxy_init (OrgFreedesktopDBusPeerProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = org_freedesktop_dbus_peer_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, OrgFreedesktopDBusPeerProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_freedesktop_dbus_peer_interface_info ()); +} + +static void +org_freedesktop_dbus_peer_proxy_class_init (OrgFreedesktopDBusPeerProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_peer_proxy_finalize; + gobject_class->get_property = org_freedesktop_dbus_peer_proxy_get_property; + gobject_class->set_property = org_freedesktop_dbus_peer_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = org_freedesktop_dbus_peer_proxy_g_signal; + proxy_class->g_properties_changed = org_freedesktop_dbus_peer_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusPeerProxyPrivate)); +#endif +} + +static void +org_freedesktop_dbus_peer_proxy_iface_init (OrgFreedesktopDBusPeerIface *iface) +{ +} + +/** + * org_freedesktop_dbus_peer_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Peer. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_peer_proxy_new_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_peer_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_peer_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Peer", NULL); +} + +/** + * org_freedesktop_dbus_peer_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_peer_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_peer_proxy_new(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusPeerProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusPeer * +org_freedesktop_dbus_peer_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PEER (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_peer_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.freedesktop.DBus.Peer. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_peer_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPeerProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusPeer * +org_freedesktop_dbus_peer_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Peer", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PEER (ret); + else + return NULL; +} + + +/** + * org_freedesktop_dbus_peer_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like org_freedesktop_dbus_peer_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call org_freedesktop_dbus_peer_proxy_new_for_bus_finish() to get the result of the operation. + * + * See org_freedesktop_dbus_peer_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +org_freedesktop_dbus_peer_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Peer", NULL); +} + +/** + * org_freedesktop_dbus_peer_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_dbus_peer_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with org_freedesktop_dbus_peer_proxy_new_for_bus(). + * + * Returns: (transfer full) (type OrgFreedesktopDBusPeerProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusPeer * +org_freedesktop_dbus_peer_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PEER (ret); + else + return NULL; +} + +/** + * org_freedesktop_dbus_peer_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like org_freedesktop_dbus_peer_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See org_freedesktop_dbus_peer_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPeerProxy): The constructed proxy object or %NULL if @error is set. + */ +OrgFreedesktopDBusPeer * +org_freedesktop_dbus_peer_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.DBus.Peer", NULL); + if (ret != NULL) + return ORG_FREEDESKTOP_DBUS_PEER (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * OrgFreedesktopDBusPeerSkeleton: + * + * The #OrgFreedesktopDBusPeerSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * OrgFreedesktopDBusPeerSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #OrgFreedesktopDBusPeerSkeleton. + */ + +struct _OrgFreedesktopDBusPeerSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_org_freedesktop_dbus_peer_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + OrgFreedesktopDBusPeerSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PEER_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + guint num_extra; + gsize n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_ORG_FREEDESKTOP_DBUS_PEER); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_DBUS_PEER); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_org_freedesktop_dbus_peer_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusPeerSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PEER_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_org_freedesktop_dbus_peer_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + OrgFreedesktopDBusPeerSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PEER_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_dbus_peer_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _org_freedesktop_dbus_peer_skeleton_vtable = +{ + _org_freedesktop_dbus_peer_skeleton_handle_method_call, + _org_freedesktop_dbus_peer_skeleton_handle_get_property, + _org_freedesktop_dbus_peer_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +org_freedesktop_dbus_peer_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return org_freedesktop_dbus_peer_interface_info (); +} + +static GDBusInterfaceVTable * +org_freedesktop_dbus_peer_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_org_freedesktop_dbus_peer_skeleton_vtable; +} + +static GVariant * +org_freedesktop_dbus_peer_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + OrgFreedesktopDBusPeerSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PEER_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_org_freedesktop_dbus_peer_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _org_freedesktop_dbus_peer_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _org_freedesktop_dbus_peer_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _org_freedesktop_dbus_peer_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.DBus.Peer", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +org_freedesktop_dbus_peer_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void org_freedesktop_dbus_peer_skeleton_iface_init (OrgFreedesktopDBusPeerIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPeerSkeleton, org_freedesktop_dbus_peer_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (OrgFreedesktopDBusPeerSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PEER, org_freedesktop_dbus_peer_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopDBusPeerSkeleton, org_freedesktop_dbus_peer_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_DBUS_PEER, org_freedesktop_dbus_peer_skeleton_iface_init)); + +#endif +static void +org_freedesktop_dbus_peer_skeleton_finalize (GObject *object) +{ + OrgFreedesktopDBusPeerSkeleton *skeleton = ORG_FREEDESKTOP_DBUS_PEER_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (org_freedesktop_dbus_peer_skeleton_parent_class)->finalize (object); +} + +static void +org_freedesktop_dbus_peer_skeleton_init (OrgFreedesktopDBusPeerSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = org_freedesktop_dbus_peer_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON, OrgFreedesktopDBusPeerSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +org_freedesktop_dbus_peer_skeleton_class_init (OrgFreedesktopDBusPeerSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = org_freedesktop_dbus_peer_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = org_freedesktop_dbus_peer_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = org_freedesktop_dbus_peer_skeleton_dbus_interface_get_properties; + skeleton_class->flush = org_freedesktop_dbus_peer_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = org_freedesktop_dbus_peer_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (OrgFreedesktopDBusPeerSkeletonPrivate)); +#endif +} + +static void +org_freedesktop_dbus_peer_skeleton_iface_init (OrgFreedesktopDBusPeerIface *iface) +{ +} + +/** + * org_freedesktop_dbus_peer_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.freedesktop.DBus.Peer. + * + * Returns: (transfer full) (type OrgFreedesktopDBusPeerSkeleton): The skeleton object. + */ +OrgFreedesktopDBusPeer * +org_freedesktop_dbus_peer_skeleton_new (void) +{ + return ORG_FREEDESKTOP_DBUS_PEER (g_object_new (TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for interface org.lightmediascanner.Scanner1 + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:Scanner1 + * @title: Scanner1 + * @short_description: Generated C code for the org.lightmediascanner.Scanner1 D-Bus interface + * + * This section contains code for working with the org.lightmediascanner.Scanner1 D-Bus interface in C. + */ + +/* ---- Introspection data for org.lightmediascanner.Scanner1 ---- */ + +static const _ExtendedGDBusArgInfo _scanner1_method_info_scan_IN_ARG_specification = +{ + { + -1, + (gchar *) "specification", + (gchar *) "a{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _scanner1_method_info_scan_IN_ARG_pointers[] = +{ + &_scanner1_method_info_scan_IN_ARG_specification, + NULL +}; + +static const _ExtendedGDBusMethodInfo _scanner1_method_info_scan = +{ + { + -1, + (gchar *) "Scan", + (GDBusArgInfo **) &_scanner1_method_info_scan_IN_ARG_pointers, + NULL, + NULL + }, + "handle-scan", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _scanner1_method_info_stop = +{ + { + -1, + (gchar *) "Stop", + NULL, + NULL, + NULL + }, + "handle-stop", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _scanner1_method_info_request_write_lock = +{ + { + -1, + (gchar *) "RequestWriteLock", + NULL, + NULL, + NULL + }, + "handle-request-write-lock", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _scanner1_method_info_release_write_lock = +{ + { + -1, + (gchar *) "ReleaseWriteLock", + NULL, + NULL, + NULL + }, + "handle-release-write-lock", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _scanner1_method_info_pointers[] = +{ + &_scanner1_method_info_scan, + &_scanner1_method_info_stop, + &_scanner1_method_info_request_write_lock, + &_scanner1_method_info_release_write_lock, + NULL +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Category = +{ + { + -1, + (gchar *) "Category", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_UpToDate = +{ + { + -1, + (gchar *) "UpToDate", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Processed = +{ + { + -1, + (gchar *) "Processed", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Deleted = +{ + { + -1, + (gchar *) "Deleted", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Skipped = +{ + { + -1, + (gchar *) "Skipped", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _scanner1_signal_info_scan_progress_ARG_Errors = +{ + { + -1, + (gchar *) "Errors", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _scanner1_signal_info_scan_progress_ARG_pointers[] = +{ + &_scanner1_signal_info_scan_progress_ARG_Category, + &_scanner1_signal_info_scan_progress_ARG_Path, + &_scanner1_signal_info_scan_progress_ARG_UpToDate, + &_scanner1_signal_info_scan_progress_ARG_Processed, + &_scanner1_signal_info_scan_progress_ARG_Deleted, + &_scanner1_signal_info_scan_progress_ARG_Skipped, + &_scanner1_signal_info_scan_progress_ARG_Errors, + NULL +}; + +static const _ExtendedGDBusSignalInfo _scanner1_signal_info_scan_progress = +{ + { + -1, + (gchar *) "ScanProgress", + (GDBusArgInfo **) &_scanner1_signal_info_scan_progress_ARG_pointers, + NULL + }, + "scan-progress" +}; + +static const _ExtendedGDBusSignalInfo * const _scanner1_signal_info_pointers[] = +{ + &_scanner1_signal_info_scan_progress, + NULL +}; + +static const _ExtendedGDBusPropertyInfo _scanner1_property_info_data_base_path = +{ + { + -1, + (gchar *) "DataBasePath", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "data-base-path", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _scanner1_property_info_is_scanning = +{ + { + -1, + (gchar *) "IsScanning", + (gchar *) "b", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "is-scanning", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _scanner1_property_info_write_locked = +{ + { + -1, + (gchar *) "WriteLocked", + (gchar *) "b", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "write-locked", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _scanner1_property_info_update_id = +{ + { + -1, + (gchar *) "UpdateID", + (gchar *) "t", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "update-id", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _scanner1_property_info_categories = +{ + { + -1, + (gchar *) "Categories", + (gchar *) "a{sv}", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "categories", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo * const _scanner1_property_info_pointers[] = +{ + &_scanner1_property_info_data_base_path, + &_scanner1_property_info_is_scanning, + &_scanner1_property_info_write_locked, + &_scanner1_property_info_update_id, + &_scanner1_property_info_categories, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _scanner1_interface_info = +{ + { + -1, + (gchar *) "org.lightmediascanner.Scanner1", + (GDBusMethodInfo **) &_scanner1_method_info_pointers, + (GDBusSignalInfo **) &_scanner1_signal_info_pointers, + (GDBusPropertyInfo **) &_scanner1_property_info_pointers, + NULL + }, + "scanner1", +}; + + +/** + * scanner1_interface_info: + * + * Gets a machine-readable description of the org.lightmediascanner.Scanner1 D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +scanner1_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct; +} + +/** + * scanner1_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #Scanner1 interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +scanner1_override_properties (GObjectClass *klass, guint property_id_begin) +{ + g_object_class_override_property (klass, property_id_begin++, "data-base-path"); + g_object_class_override_property (klass, property_id_begin++, "is-scanning"); + g_object_class_override_property (klass, property_id_begin++, "write-locked"); + g_object_class_override_property (klass, property_id_begin++, "update-id"); + g_object_class_override_property (klass, property_id_begin++, "categories"); + return property_id_begin - 1; +} + + + +/** + * Scanner1: + * + * Abstract interface type for the D-Bus interface org.lightmediascanner.Scanner1. + */ + +/** + * Scanner1Iface: + * @parent_iface: The parent interface. + * @handle_release_write_lock: Handler for the #Scanner1::handle-release-write-lock signal. + * @handle_request_write_lock: Handler for the #Scanner1::handle-request-write-lock signal. + * @handle_scan: Handler for the #Scanner1::handle-scan signal. + * @handle_stop: Handler for the #Scanner1::handle-stop signal. + * @get_categories: Getter for the #Scanner1:categories property. + * @get_data_base_path: Getter for the #Scanner1:data-base-path property. + * @get_is_scanning: Getter for the #Scanner1:is-scanning property. + * @get_update_id: Getter for the #Scanner1:update-id property. + * @get_write_locked: Getter for the #Scanner1:write-locked property. + * @scan_progress: Handler for the #Scanner1::scan-progress signal. + * + * Virtual table for the D-Bus interface org.lightmediascanner.Scanner1. + */ + +typedef Scanner1Iface Scanner1Interface; +G_DEFINE_INTERFACE (Scanner1, scanner1, G_TYPE_OBJECT); + +static void +scanner1_default_init (Scanner1Iface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * Scanner1::handle-scan: + * @object: A #Scanner1. + * @invocation: A #GDBusMethodInvocation. + * @arg_specification: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the Scan() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call scanner1_complete_scan() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-scan", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (Scanner1Iface, handle_scan), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT); + + /** + * Scanner1::handle-stop: + * @object: A #Scanner1. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Stop() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call scanner1_complete_stop() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-stop", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (Scanner1Iface, handle_stop), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * Scanner1::handle-request-write-lock: + * @object: A #Scanner1. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the RequestWriteLock() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call scanner1_complete_request_write_lock() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-request-write-lock", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (Scanner1Iface, handle_request_write_lock), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * Scanner1::handle-release-write-lock: + * @object: A #Scanner1. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the ReleaseWriteLock() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call scanner1_complete_release_write_lock() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-release-write-lock", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (Scanner1Iface, handle_release_write_lock), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /* GObject signals for received D-Bus signals: */ + /** + * Scanner1::scan-progress: + * @object: A #Scanner1. + * @arg_Category: Argument. + * @arg_Path: Argument. + * @arg_UpToDate: Argument. + * @arg_Processed: Argument. + * @arg_Deleted: Argument. + * @arg_Skipped: Argument. + * @arg_Errors: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "ScanProgress" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("scan-progress", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (Scanner1Iface, scan_progress), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 7, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64); + + /* GObject properties for D-Bus properties: */ + /** + * Scanner1:data-base-path: + * + * Represents the D-Bus property "DataBasePath". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("data-base-path", "DataBasePath", "DataBasePath", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * Scanner1:is-scanning: + * + * Represents the D-Bus property "IsScanning". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boolean ("is-scanning", "IsScanning", "IsScanning", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * Scanner1:write-locked: + * + * Represents the D-Bus property "WriteLocked". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boolean ("write-locked", "WriteLocked", "WriteLocked", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * Scanner1:update-id: + * + * Represents the D-Bus property "UpdateID". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_uint64 ("update-id", "UpdateID", "UpdateID", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * Scanner1:categories: + * + * Represents the D-Bus property "Categories". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_variant ("categories", "Categories", "Categories", G_VARIANT_TYPE ("a{sv}"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +/** + * scanner1_get_data_base_path: (skip) + * @object: A #Scanner1. + * + * Gets the value of the "DataBasePath" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use scanner1_dup_data_base_path() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +scanner1_get_data_base_path (Scanner1 *object) +{ + return SCANNER1_GET_IFACE (object)->get_data_base_path (object); +} + +/** + * scanner1_dup_data_base_path: (skip) + * @object: A #Scanner1. + * + * Gets a copy of the "DataBasePath" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +scanner1_dup_data_base_path (Scanner1 *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "data-base-path", &value, NULL); + return value; +} + +/** + * scanner1_set_data_base_path: (skip) + * @object: A #Scanner1. + * @value: The value to set. + * + * Sets the "DataBasePath" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +scanner1_set_data_base_path (Scanner1 *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "data-base-path", value, NULL); +} + +/** + * scanner1_get_is_scanning: (skip) + * @object: A #Scanner1. + * + * Gets the value of the "IsScanning" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +gboolean +scanner1_get_is_scanning (Scanner1 *object) +{ + return SCANNER1_GET_IFACE (object)->get_is_scanning (object); +} + +/** + * scanner1_set_is_scanning: (skip) + * @object: A #Scanner1. + * @value: The value to set. + * + * Sets the "IsScanning" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +scanner1_set_is_scanning (Scanner1 *object, gboolean value) +{ + g_object_set (G_OBJECT (object), "is-scanning", value, NULL); +} + +/** + * scanner1_get_write_locked: (skip) + * @object: A #Scanner1. + * + * Gets the value of the "WriteLocked" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +gboolean +scanner1_get_write_locked (Scanner1 *object) +{ + return SCANNER1_GET_IFACE (object)->get_write_locked (object); +} + +/** + * scanner1_set_write_locked: (skip) + * @object: A #Scanner1. + * @value: The value to set. + * + * Sets the "WriteLocked" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +scanner1_set_write_locked (Scanner1 *object, gboolean value) +{ + g_object_set (G_OBJECT (object), "write-locked", value, NULL); +} + +/** + * scanner1_get_update_id: (skip) + * @object: A #Scanner1. + * + * Gets the value of the "UpdateID" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +guint64 +scanner1_get_update_id (Scanner1 *object) +{ + return SCANNER1_GET_IFACE (object)->get_update_id (object); +} + +/** + * scanner1_set_update_id: (skip) + * @object: A #Scanner1. + * @value: The value to set. + * + * Sets the "UpdateID" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +scanner1_set_update_id (Scanner1 *object, guint64 value) +{ + g_object_set (G_OBJECT (object), "update-id", value, NULL); +} + +/** + * scanner1_get_categories: (skip) + * @object: A #Scanner1. + * + * Gets the value of the "Categories" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use scanner1_dup_categories() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +GVariant * +scanner1_get_categories (Scanner1 *object) +{ + return SCANNER1_GET_IFACE (object)->get_categories (object); +} + +/** + * scanner1_dup_categories: (skip) + * @object: A #Scanner1. + * + * Gets a copy of the "Categories" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref(). + */ +GVariant * +scanner1_dup_categories (Scanner1 *object) +{ + GVariant *value; + g_object_get (G_OBJECT (object), "categories", &value, NULL); + return value; +} + +/** + * scanner1_set_categories: (skip) + * @object: A #Scanner1. + * @value: The value to set. + * + * Sets the "Categories" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +scanner1_set_categories (Scanner1 *object, GVariant *value) +{ + g_object_set (G_OBJECT (object), "categories", value, NULL); +} + +/** + * scanner1_emit_scan_progress: + * @object: A #Scanner1. + * @arg_Category: Argument to pass with the signal. + * @arg_Path: Argument to pass with the signal. + * @arg_UpToDate: Argument to pass with the signal. + * @arg_Processed: Argument to pass with the signal. + * @arg_Deleted: Argument to pass with the signal. + * @arg_Skipped: Argument to pass with the signal. + * @arg_Errors: Argument to pass with the signal. + * + * Emits the "ScanProgress" D-Bus signal. + */ +void +scanner1_emit_scan_progress ( + Scanner1 *object, + const gchar *arg_Category, + const gchar *arg_Path, + guint64 arg_UpToDate, + guint64 arg_Processed, + guint64 arg_Deleted, + guint64 arg_Skipped, + guint64 arg_Errors) +{ + g_signal_emit_by_name (object, "scan-progress", arg_Category, arg_Path, arg_UpToDate, arg_Processed, arg_Deleted, arg_Skipped, arg_Errors); +} + +/** + * scanner1_call_scan: + * @proxy: A #Scanner1Proxy. + * @arg_specification: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Scan() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_call_scan_finish() to get the result of the operation. + * + * See scanner1_call_scan_sync() for the synchronous, blocking version of this method. + */ +void +scanner1_call_scan ( + Scanner1 *proxy, + GVariant *arg_specification, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Scan", + g_variant_new ("(@a{sv})", + arg_specification), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * scanner1_call_scan_finish: + * @proxy: A #Scanner1Proxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_call_scan(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with scanner1_call_scan(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_scan_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_scan_sync: + * @proxy: A #Scanner1Proxy. + * @arg_specification: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Scan() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See scanner1_call_scan() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_scan_sync ( + Scanner1 *proxy, + GVariant *arg_specification, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Scan", + g_variant_new ("(@a{sv})", + arg_specification), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_stop: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Stop() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_call_stop_finish() to get the result of the operation. + * + * See scanner1_call_stop_sync() for the synchronous, blocking version of this method. + */ +void +scanner1_call_stop ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Stop", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * scanner1_call_stop_finish: + * @proxy: A #Scanner1Proxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_call_stop(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with scanner1_call_stop(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_stop_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_stop_sync: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Stop() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See scanner1_call_stop() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_stop_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Stop", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_request_write_lock: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the RequestWriteLock() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_call_request_write_lock_finish() to get the result of the operation. + * + * See scanner1_call_request_write_lock_sync() for the synchronous, blocking version of this method. + */ +void +scanner1_call_request_write_lock ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "RequestWriteLock", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * scanner1_call_request_write_lock_finish: + * @proxy: A #Scanner1Proxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_call_request_write_lock(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with scanner1_call_request_write_lock(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_request_write_lock_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_request_write_lock_sync: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the RequestWriteLock() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See scanner1_call_request_write_lock() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_request_write_lock_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "RequestWriteLock", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_release_write_lock: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ReleaseWriteLock() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_call_release_write_lock_finish() to get the result of the operation. + * + * See scanner1_call_release_write_lock_sync() for the synchronous, blocking version of this method. + */ +void +scanner1_call_release_write_lock ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ReleaseWriteLock", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * scanner1_call_release_write_lock_finish: + * @proxy: A #Scanner1Proxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_call_release_write_lock(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with scanner1_call_release_write_lock(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_release_write_lock_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_call_release_write_lock_sync: + * @proxy: A #Scanner1Proxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ReleaseWriteLock() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See scanner1_call_release_write_lock() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +scanner1_call_release_write_lock_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ReleaseWriteLock", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * scanner1_complete_scan: + * @object: A #Scanner1. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Scan() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +scanner1_complete_scan ( + Scanner1 *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * scanner1_complete_stop: + * @object: A #Scanner1. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Stop() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +scanner1_complete_stop ( + Scanner1 *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * scanner1_complete_request_write_lock: + * @object: A #Scanner1. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the RequestWriteLock() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +scanner1_complete_request_write_lock ( + Scanner1 *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * scanner1_complete_release_write_lock: + * @object: A #Scanner1. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ReleaseWriteLock() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +scanner1_complete_release_write_lock ( + Scanner1 *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/* ------------------------------------------------------------------------ */ + +/** + * Scanner1Proxy: + * + * The #Scanner1Proxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * Scanner1ProxyClass: + * @parent_class: The parent class. + * + * Class structure for #Scanner1Proxy. + */ + +struct _Scanner1ProxyPrivate +{ + GData *qdata; +}; + +static void scanner1_proxy_iface_init (Scanner1Iface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (Scanner1Proxy, scanner1_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (Scanner1Proxy) + G_IMPLEMENT_INTERFACE (TYPE_SCANNER1, scanner1_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (Scanner1Proxy, scanner1_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_SCANNER1, scanner1_proxy_iface_init)); + +#endif +static void +scanner1_proxy_finalize (GObject *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (scanner1_proxy_parent_class)->finalize (object); +} + +static void +scanner1_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 5); + info = _scanner1_property_info_pointers[prop_id - 1]; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name); + if (info->use_gvariant) + { + g_value_set_variant (value, variant); + } + else + { + if (variant != NULL) + g_dbus_gvariant_to_gvalue (variant, value); + } + if (variant != NULL) + g_variant_unref (variant); +} + +static void +scanner1_proxy_set_property_cb (GDBusProxy *proxy, + GAsyncResult *res, + gpointer user_data) +{ + const _ExtendedGDBusPropertyInfo *info = user_data; + GError *error; + GVariant *_ret; + error = NULL; + _ret = g_dbus_proxy_call_finish (proxy, res, &error); + if (!_ret) + { + g_warning ("Error setting property '%s' on interface org.lightmediascanner.Scanner1: %s (%s, %d)", + info->parent_struct.name, + error->message, g_quark_to_string (error->domain), error->code); + g_error_free (error); + } + else + { + g_variant_unref (_ret); + } +} + +static void +scanner1_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 5); + info = _scanner1_property_info_pointers[prop_id - 1]; + variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_dbus_proxy_call (G_DBUS_PROXY (object), + "org.freedesktop.DBus.Properties.Set", + g_variant_new ("(ssv)", "org.lightmediascanner.Scanner1", info->parent_struct.name, variant), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, (GAsyncReadyCallback) scanner1_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct); + g_variant_unref (variant); +} + +static void +scanner1_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + gsize n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_SCANNER1); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_SCANNER1); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +scanner1_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static const gchar * +scanner1_proxy_get_data_base_path (Scanner1 *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DataBasePath"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static gboolean +scanner1_proxy_get_is_scanning (Scanner1 *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + GVariant *variant; + gboolean value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IsScanning"); + if (variant != NULL) + { + value = g_variant_get_boolean (variant); + g_variant_unref (variant); + } + return value; +} + +static gboolean +scanner1_proxy_get_write_locked (Scanner1 *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + GVariant *variant; + gboolean value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "WriteLocked"); + if (variant != NULL) + { + value = g_variant_get_boolean (variant); + g_variant_unref (variant); + } + return value; +} + +static guint64 +scanner1_proxy_get_update_id (Scanner1 *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + GVariant *variant; + guint64 value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UpdateID"); + if (variant != NULL) + { + value = g_variant_get_uint64 (variant); + g_variant_unref (variant); + } + return value; +} + +static GVariant * +scanner1_proxy_get_categories (Scanner1 *object) +{ + Scanner1Proxy *proxy = SCANNER1_PROXY (object); + GVariant *variant; + GVariant *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Categories"); + value = variant; + if (variant != NULL) + g_variant_unref (variant); + return value; +} + +static void +scanner1_proxy_init (Scanner1Proxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = scanner1_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_SCANNER1_PROXY, Scanner1ProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), scanner1_interface_info ()); +} + +static void +scanner1_proxy_class_init (Scanner1ProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = scanner1_proxy_finalize; + gobject_class->get_property = scanner1_proxy_get_property; + gobject_class->set_property = scanner1_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = scanner1_proxy_g_signal; + proxy_class->g_properties_changed = scanner1_proxy_g_properties_changed; + + scanner1_override_properties (gobject_class, 1); + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (Scanner1ProxyPrivate)); +#endif +} + +static void +scanner1_proxy_iface_init (Scanner1Iface *iface) +{ + iface->get_data_base_path = scanner1_proxy_get_data_base_path; + iface->get_is_scanning = scanner1_proxy_get_is_scanning; + iface->get_write_locked = scanner1_proxy_get_write_locked; + iface->get_update_id = scanner1_proxy_get_update_id; + iface->get_categories = scanner1_proxy_get_categories; +} + +/** + * scanner1_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.lightmediascanner.Scanner1. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_proxy_new_finish() to get the result of the operation. + * + * See scanner1_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +scanner1_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_SCANNER1_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.lightmediascanner.Scanner1", NULL); +} + +/** + * scanner1_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with scanner1_proxy_new(). + * + * Returns: (transfer full) (type Scanner1Proxy): The constructed proxy object or %NULL if @error is set. + */ +Scanner1 * +scanner1_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return SCANNER1 (ret); + else + return NULL; +} + +/** + * scanner1_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.lightmediascanner.Scanner1. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See scanner1_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type Scanner1Proxy): The constructed proxy object or %NULL if @error is set. + */ +Scanner1 * +scanner1_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_SCANNER1_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.lightmediascanner.Scanner1", NULL); + if (ret != NULL) + return SCANNER1 (ret); + else + return NULL; +} + + +/** + * scanner1_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like scanner1_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call scanner1_proxy_new_for_bus_finish() to get the result of the operation. + * + * See scanner1_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +scanner1_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_SCANNER1_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.lightmediascanner.Scanner1", NULL); +} + +/** + * scanner1_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to scanner1_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with scanner1_proxy_new_for_bus(). + * + * Returns: (transfer full) (type Scanner1Proxy): The constructed proxy object or %NULL if @error is set. + */ +Scanner1 * +scanner1_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return SCANNER1 (ret); + else + return NULL; +} + +/** + * scanner1_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like scanner1_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See scanner1_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type Scanner1Proxy): The constructed proxy object or %NULL if @error is set. + */ +Scanner1 * +scanner1_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_SCANNER1_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.lightmediascanner.Scanner1", NULL); + if (ret != NULL) + return SCANNER1 (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * Scanner1Skeleton: + * + * The #Scanner1Skeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * Scanner1SkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #Scanner1Skeleton. + */ + +struct _Scanner1SkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_scanner1_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + gsize num_params; + guint num_extra; + gsize n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_SCANNER1); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_SCANNER1); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_scanner1_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_scanner1_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_scanner1_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _scanner1_skeleton_vtable = +{ + _scanner1_skeleton_handle_method_call, + _scanner1_skeleton_handle_get_property, + _scanner1_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +scanner1_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return scanner1_interface_info (); +} + +static GDBusInterfaceVTable * +scanner1_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_scanner1_skeleton_vtable; +} + +static GVariant * +scanner1_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_scanner1_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _scanner1_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _scanner1_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _scanner1_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.lightmediascanner.Scanner1", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static gboolean _scanner1_emit_changed (gpointer user_data); + +static void +scanner1_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (_skeleton); + gboolean emit_changed = FALSE; + + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties_idle_source != NULL) + { + g_source_destroy (skeleton->priv->changed_properties_idle_source); + skeleton->priv->changed_properties_idle_source = NULL; + emit_changed = TRUE; + } + g_mutex_unlock (&skeleton->priv->lock); + + if (emit_changed) + _scanner1_emit_changed (skeleton); +} + +static void +_scanner1_on_signal_scan_progress ( + Scanner1 *object, + const gchar *arg_Category, + const gchar *arg_Path, + guint64 arg_UpToDate, + guint64 arg_Processed, + guint64 arg_Deleted, + guint64 arg_Skipped, + guint64 arg_Errors) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(ssttttt)", + arg_Category, + arg_Path, + arg_UpToDate, + arg_Processed, + arg_Deleted, + arg_Skipped, + arg_Errors)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.lightmediascanner.Scanner1", "ScanProgress", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void scanner1_skeleton_iface_init (Scanner1Iface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (Scanner1Skeleton, scanner1_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (Scanner1Skeleton) + G_IMPLEMENT_INTERFACE (TYPE_SCANNER1, scanner1_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (Scanner1Skeleton, scanner1_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_SCANNER1, scanner1_skeleton_iface_init)); + +#endif +static void +scanner1_skeleton_finalize (GObject *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + guint n; + for (n = 0; n < 5; n++) + g_value_unset (&skeleton->priv->properties[n]); + g_free (skeleton->priv->properties); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (scanner1_skeleton_parent_class)->finalize (object); +} + +static void +scanner1_skeleton_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 5); + g_mutex_lock (&skeleton->priv->lock); + g_value_copy (&skeleton->priv->properties[prop_id - 1], value); + g_mutex_unlock (&skeleton->priv->lock); +} + +static gboolean +_scanner1_emit_changed (gpointer user_data) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (user_data); + GList *l; + GVariantBuilder builder; + GVariantBuilder invalidated_builder; + guint num_changes; + + g_mutex_lock (&skeleton->priv->lock); + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as")); + for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next) + { + ChangedProperty *cp = l->data; + GVariant *variant; + const GValue *cur_value; + + cur_value = &skeleton->priv->properties[cp->prop_id - 1]; + if (!_g_value_equal (cur_value, &cp->orig_value)) + { + variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature)); + g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant); + g_variant_unref (variant); + num_changes++; + } + } + if (num_changes > 0) + { + GList *connections, *ll; + GVariant *signal_variant; + signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.lightmediascanner.Scanner1", + &builder, &invalidated_builder)); + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + for (ll = connections; ll != NULL; ll = ll->next) + { + GDBusConnection *connection = ll->data; + + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), + "org.freedesktop.DBus.Properties", + "PropertiesChanged", + signal_variant, + NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); + } + else + { + g_variant_builder_clear (&builder); + g_variant_builder_clear (&invalidated_builder); + } + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + skeleton->priv->changed_properties = NULL; + skeleton->priv->changed_properties_idle_source = NULL; + g_mutex_unlock (&skeleton->priv->lock); + return FALSE; +} + +static void +_scanner1_schedule_emit_changed (Scanner1Skeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value) +{ + ChangedProperty *cp; + GList *l; + cp = NULL; + for (l = skeleton->priv->changed_properties; l != NULL; l = l->next) + { + ChangedProperty *i_cp = l->data; + if (i_cp->info == info) + { + cp = i_cp; + break; + } + } + if (cp == NULL) + { + cp = g_new0 (ChangedProperty, 1); + cp->prop_id = prop_id; + cp->info = info; + skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp); + g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value)); + g_value_copy (orig_value, &cp->orig_value); + } +} + +static void +scanner1_skeleton_notify (GObject *object, + GParamSpec *pspec G_GNUC_UNUSED) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties != NULL && + skeleton->priv->changed_properties_idle_source == NULL) + { + skeleton->priv->changed_properties_idle_source = g_idle_source_new (); + g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT); + g_source_set_callback (skeleton->priv->changed_properties_idle_source, _scanner1_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref); + g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _scanner1_emit_changed"); + g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context); + g_source_unref (skeleton->priv->changed_properties_idle_source); + } + g_mutex_unlock (&skeleton->priv->lock); +} + +static void +scanner1_skeleton_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 5); + g_mutex_lock (&skeleton->priv->lock); + g_object_freeze_notify (object); + if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1])) + { + if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL) + _scanner1_schedule_emit_changed (skeleton, _scanner1_property_info_pointers[prop_id - 1], prop_id, &skeleton->priv->properties[prop_id - 1]); + g_value_copy (value, &skeleton->priv->properties[prop_id - 1]); + g_object_notify_by_pspec (object, pspec); + } + g_mutex_unlock (&skeleton->priv->lock); + g_object_thaw_notify (object); +} + +static void +scanner1_skeleton_init (Scanner1Skeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = scanner1_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_SCANNER1_SKELETON, Scanner1SkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); + skeleton->priv->properties = g_new0 (GValue, 5); + g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[1], G_TYPE_BOOLEAN); + g_value_init (&skeleton->priv->properties[2], G_TYPE_BOOLEAN); + g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64); + g_value_init (&skeleton->priv->properties[4], G_TYPE_VARIANT); +} + +static const gchar * +scanner1_skeleton_get_data_base_path (Scanner1 *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[0])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static gboolean +scanner1_skeleton_get_is_scanning (Scanner1 *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + gboolean value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boolean (&(skeleton->priv->properties[1])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static gboolean +scanner1_skeleton_get_write_locked (Scanner1 *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + gboolean value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boolean (&(skeleton->priv->properties[2])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static guint64 +scanner1_skeleton_get_update_id (Scanner1 *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + guint64 value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_uint64 (&(skeleton->priv->properties[3])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static GVariant * +scanner1_skeleton_get_categories (Scanner1 *object) +{ + Scanner1Skeleton *skeleton = SCANNER1_SKELETON (object); + GVariant *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_variant (&(skeleton->priv->properties[4])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static void +scanner1_skeleton_class_init (Scanner1SkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = scanner1_skeleton_finalize; + gobject_class->get_property = scanner1_skeleton_get_property; + gobject_class->set_property = scanner1_skeleton_set_property; + gobject_class->notify = scanner1_skeleton_notify; + + + scanner1_override_properties (gobject_class, 1); + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = scanner1_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = scanner1_skeleton_dbus_interface_get_properties; + skeleton_class->flush = scanner1_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = scanner1_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (Scanner1SkeletonPrivate)); +#endif +} + +static void +scanner1_skeleton_iface_init (Scanner1Iface *iface) +{ + iface->scan_progress = _scanner1_on_signal_scan_progress; + iface->get_data_base_path = scanner1_skeleton_get_data_base_path; + iface->get_is_scanning = scanner1_skeleton_get_is_scanning; + iface->get_write_locked = scanner1_skeleton_get_write_locked; + iface->get_update_id = scanner1_skeleton_get_update_id; + iface->get_categories = scanner1_skeleton_get_categories; +} + +/** + * scanner1_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.lightmediascanner.Scanner1. + * + * Returns: (transfer full) (type Scanner1Skeleton): The skeleton object. + */ +Scanner1 * +scanner1_skeleton_new (void) +{ + return SCANNER1 (g_object_new (TYPE_SCANNER1_SKELETON, NULL)); +} + diff --git a/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.h b/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.h new file mode 100644 index 0000000..4f42086 --- /dev/null +++ b/sample/mediaplayer/binding/gdbus/lightmediascanner_interface.h @@ -0,0 +1,896 @@ +/* + * Generated by gdbus-codegen 2.52.0. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __LIGHTMEDIASCANNER_INTERFACE_H__ +#define __LIGHTMEDIASCANNER_INTERFACE_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.freedesktop.DBus.Properties */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES (org_freedesktop_dbus_properties_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, OrgFreedesktopDBusProperties)) +#define IS_ORG_FREEDESKTOP_DBUS_PROPERTIES(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES)) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES, OrgFreedesktopDBusPropertiesIface)) + +struct _OrgFreedesktopDBusProperties; +typedef struct _OrgFreedesktopDBusProperties OrgFreedesktopDBusProperties; +typedef struct _OrgFreedesktopDBusPropertiesIface OrgFreedesktopDBusPropertiesIface; + +struct _OrgFreedesktopDBusPropertiesIface +{ + GTypeInterface parent_iface; + + + gboolean (*handle_get) ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + const gchar *arg_interface_name, + const gchar *arg_property_name); + + gboolean (*handle_get_all) ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + const gchar *arg_interface_name); + + gboolean (*handle_set) ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant *arg_value); + + void (*properties_changed) ( + OrgFreedesktopDBusProperties *object, + const gchar *arg_interface_name, + GVariant *arg_changed_properties, + const gchar *const *arg_invalidated_properties); + +}; + +GType org_freedesktop_dbus_properties_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *org_freedesktop_dbus_properties_interface_info (void); +guint org_freedesktop_dbus_properties_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void org_freedesktop_dbus_properties_complete_get ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + GVariant *value); + +void org_freedesktop_dbus_properties_complete_get_all ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation, + GVariant *properties); + +void org_freedesktop_dbus_properties_complete_set ( + OrgFreedesktopDBusProperties *object, + GDBusMethodInvocation *invocation); + + + +/* D-Bus signal emissions functions: */ +void org_freedesktop_dbus_properties_emit_properties_changed ( + OrgFreedesktopDBusProperties *object, + const gchar *arg_interface_name, + GVariant *arg_changed_properties, + const gchar *const *arg_invalidated_properties); + + + +/* D-Bus method calls: */ +void org_freedesktop_dbus_properties_call_get ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_properties_call_get_finish ( + OrgFreedesktopDBusProperties *proxy, + GVariant **out_value, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_properties_call_get_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant **out_value, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_properties_call_get_all ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_properties_call_get_all_finish ( + OrgFreedesktopDBusProperties *proxy, + GVariant **out_properties, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_properties_call_get_all_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + GVariant **out_properties, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_properties_call_set ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant *arg_value, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_properties_call_set_finish ( + OrgFreedesktopDBusProperties *proxy, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_properties_call_set_sync ( + OrgFreedesktopDBusProperties *proxy, + const gchar *arg_interface_name, + const gchar *arg_property_name, + GVariant *arg_value, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY (org_freedesktop_dbus_properties_proxy_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, OrgFreedesktopDBusPropertiesProxy)) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, OrgFreedesktopDBusPropertiesProxyClass)) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY, OrgFreedesktopDBusPropertiesProxyClass)) +#define IS_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY)) +#define IS_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_PROXY)) + +typedef struct _OrgFreedesktopDBusPropertiesProxy OrgFreedesktopDBusPropertiesProxy; +typedef struct _OrgFreedesktopDBusPropertiesProxyClass OrgFreedesktopDBusPropertiesProxyClass; +typedef struct _OrgFreedesktopDBusPropertiesProxyPrivate OrgFreedesktopDBusPropertiesProxyPrivate; + +struct _OrgFreedesktopDBusPropertiesProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + OrgFreedesktopDBusPropertiesProxyPrivate *priv; +}; + +struct _OrgFreedesktopDBusPropertiesProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType org_freedesktop_dbus_properties_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusPropertiesProxy, g_object_unref) +#endif + +void org_freedesktop_dbus_properties_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusProperties *org_freedesktop_dbus_properties_proxy_new_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusProperties *org_freedesktop_dbus_properties_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_properties_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusProperties *org_freedesktop_dbus_properties_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusProperties *org_freedesktop_dbus_properties_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON (org_freedesktop_dbus_properties_skeleton_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON, OrgFreedesktopDBusPropertiesSkeleton)) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON, OrgFreedesktopDBusPropertiesSkeletonClass)) +#define ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON, OrgFreedesktopDBusPropertiesSkeletonClass)) +#define IS_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON)) +#define IS_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_PROPERTIES_SKELETON)) + +typedef struct _OrgFreedesktopDBusPropertiesSkeleton OrgFreedesktopDBusPropertiesSkeleton; +typedef struct _OrgFreedesktopDBusPropertiesSkeletonClass OrgFreedesktopDBusPropertiesSkeletonClass; +typedef struct _OrgFreedesktopDBusPropertiesSkeletonPrivate OrgFreedesktopDBusPropertiesSkeletonPrivate; + +struct _OrgFreedesktopDBusPropertiesSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + OrgFreedesktopDBusPropertiesSkeletonPrivate *priv; +}; + +struct _OrgFreedesktopDBusPropertiesSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType org_freedesktop_dbus_properties_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusPropertiesSkeleton, g_object_unref) +#endif + +OrgFreedesktopDBusProperties *org_freedesktop_dbus_properties_skeleton_new (void); + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.freedesktop.DBus.Introspectable */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE (org_freedesktop_dbus_introspectable_get_type ()) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, OrgFreedesktopDBusIntrospectable)) +#define IS_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE)) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE, OrgFreedesktopDBusIntrospectableIface)) + +struct _OrgFreedesktopDBusIntrospectable; +typedef struct _OrgFreedesktopDBusIntrospectable OrgFreedesktopDBusIntrospectable; +typedef struct _OrgFreedesktopDBusIntrospectableIface OrgFreedesktopDBusIntrospectableIface; + +struct _OrgFreedesktopDBusIntrospectableIface +{ + GTypeInterface parent_iface; + + gboolean (*handle_introspect) ( + OrgFreedesktopDBusIntrospectable *object, + GDBusMethodInvocation *invocation); + +}; + +GType org_freedesktop_dbus_introspectable_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *org_freedesktop_dbus_introspectable_interface_info (void); +guint org_freedesktop_dbus_introspectable_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void org_freedesktop_dbus_introspectable_complete_introspect ( + OrgFreedesktopDBusIntrospectable *object, + GDBusMethodInvocation *invocation, + const gchar *xml_data); + + + +/* D-Bus method calls: */ +void org_freedesktop_dbus_introspectable_call_introspect ( + OrgFreedesktopDBusIntrospectable *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_introspectable_call_introspect_finish ( + OrgFreedesktopDBusIntrospectable *proxy, + gchar **out_xml_data, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_introspectable_call_introspect_sync ( + OrgFreedesktopDBusIntrospectable *proxy, + gchar **out_xml_data, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY (org_freedesktop_dbus_introspectable_proxy_get_type ()) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, OrgFreedesktopDBusIntrospectableProxy)) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, OrgFreedesktopDBusIntrospectableProxyClass)) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY, OrgFreedesktopDBusIntrospectableProxyClass)) +#define IS_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY)) +#define IS_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_PROXY)) + +typedef struct _OrgFreedesktopDBusIntrospectableProxy OrgFreedesktopDBusIntrospectableProxy; +typedef struct _OrgFreedesktopDBusIntrospectableProxyClass OrgFreedesktopDBusIntrospectableProxyClass; +typedef struct _OrgFreedesktopDBusIntrospectableProxyPrivate OrgFreedesktopDBusIntrospectableProxyPrivate; + +struct _OrgFreedesktopDBusIntrospectableProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + OrgFreedesktopDBusIntrospectableProxyPrivate *priv; +}; + +struct _OrgFreedesktopDBusIntrospectableProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType org_freedesktop_dbus_introspectable_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusIntrospectableProxy, g_object_unref) +#endif + +void org_freedesktop_dbus_introspectable_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusIntrospectable *org_freedesktop_dbus_introspectable_proxy_new_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusIntrospectable *org_freedesktop_dbus_introspectable_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_introspectable_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusIntrospectable *org_freedesktop_dbus_introspectable_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusIntrospectable *org_freedesktop_dbus_introspectable_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON (org_freedesktop_dbus_introspectable_skeleton_get_type ()) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON, OrgFreedesktopDBusIntrospectableSkeleton)) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON, OrgFreedesktopDBusIntrospectableSkeletonClass)) +#define ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON, OrgFreedesktopDBusIntrospectableSkeletonClass)) +#define IS_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON)) +#define IS_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_INTROSPECTABLE_SKELETON)) + +typedef struct _OrgFreedesktopDBusIntrospectableSkeleton OrgFreedesktopDBusIntrospectableSkeleton; +typedef struct _OrgFreedesktopDBusIntrospectableSkeletonClass OrgFreedesktopDBusIntrospectableSkeletonClass; +typedef struct _OrgFreedesktopDBusIntrospectableSkeletonPrivate OrgFreedesktopDBusIntrospectableSkeletonPrivate; + +struct _OrgFreedesktopDBusIntrospectableSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + OrgFreedesktopDBusIntrospectableSkeletonPrivate *priv; +}; + +struct _OrgFreedesktopDBusIntrospectableSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType org_freedesktop_dbus_introspectable_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusIntrospectableSkeleton, g_object_unref) +#endif + +OrgFreedesktopDBusIntrospectable *org_freedesktop_dbus_introspectable_skeleton_new (void); + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.freedesktop.DBus.Peer */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PEER (org_freedesktop_dbus_peer_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PEER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER, OrgFreedesktopDBusPeer)) +#define IS_ORG_FREEDESKTOP_DBUS_PEER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER)) +#define ORG_FREEDESKTOP_DBUS_PEER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER, OrgFreedesktopDBusPeerIface)) + +struct _OrgFreedesktopDBusPeer; +typedef struct _OrgFreedesktopDBusPeer OrgFreedesktopDBusPeer; +typedef struct _OrgFreedesktopDBusPeerIface OrgFreedesktopDBusPeerIface; + +struct _OrgFreedesktopDBusPeerIface +{ + GTypeInterface parent_iface; + + gboolean (*handle_get_machine_id) ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_ping) ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation); + +}; + +GType org_freedesktop_dbus_peer_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *org_freedesktop_dbus_peer_interface_info (void); +guint org_freedesktop_dbus_peer_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void org_freedesktop_dbus_peer_complete_ping ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation); + +void org_freedesktop_dbus_peer_complete_get_machine_id ( + OrgFreedesktopDBusPeer *object, + GDBusMethodInvocation *invocation, + const gchar *machine_uuid); + + + +/* D-Bus method calls: */ +void org_freedesktop_dbus_peer_call_ping ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_peer_call_ping_finish ( + OrgFreedesktopDBusPeer *proxy, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_peer_call_ping_sync ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_peer_call_get_machine_id ( + OrgFreedesktopDBusPeer *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean org_freedesktop_dbus_peer_call_get_machine_id_finish ( + OrgFreedesktopDBusPeer *proxy, + gchar **out_machine_uuid, + GAsyncResult *res, + GError **error); + +gboolean org_freedesktop_dbus_peer_call_get_machine_id_sync ( + OrgFreedesktopDBusPeer *proxy, + gchar **out_machine_uuid, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY (org_freedesktop_dbus_peer_proxy_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PEER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, OrgFreedesktopDBusPeerProxy)) +#define ORG_FREEDESKTOP_DBUS_PEER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, OrgFreedesktopDBusPeerProxyClass)) +#define ORG_FREEDESKTOP_DBUS_PEER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY, OrgFreedesktopDBusPeerProxyClass)) +#define IS_ORG_FREEDESKTOP_DBUS_PEER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY)) +#define IS_ORG_FREEDESKTOP_DBUS_PEER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_PEER_PROXY)) + +typedef struct _OrgFreedesktopDBusPeerProxy OrgFreedesktopDBusPeerProxy; +typedef struct _OrgFreedesktopDBusPeerProxyClass OrgFreedesktopDBusPeerProxyClass; +typedef struct _OrgFreedesktopDBusPeerProxyPrivate OrgFreedesktopDBusPeerProxyPrivate; + +struct _OrgFreedesktopDBusPeerProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + OrgFreedesktopDBusPeerProxyPrivate *priv; +}; + +struct _OrgFreedesktopDBusPeerProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType org_freedesktop_dbus_peer_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusPeerProxy, g_object_unref) +#endif + +void org_freedesktop_dbus_peer_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusPeer *org_freedesktop_dbus_peer_proxy_new_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusPeer *org_freedesktop_dbus_peer_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void org_freedesktop_dbus_peer_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +OrgFreedesktopDBusPeer *org_freedesktop_dbus_peer_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +OrgFreedesktopDBusPeer *org_freedesktop_dbus_peer_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON (org_freedesktop_dbus_peer_skeleton_get_type ()) +#define ORG_FREEDESKTOP_DBUS_PEER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON, OrgFreedesktopDBusPeerSkeleton)) +#define ORG_FREEDESKTOP_DBUS_PEER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON, OrgFreedesktopDBusPeerSkeletonClass)) +#define ORG_FREEDESKTOP_DBUS_PEER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON, OrgFreedesktopDBusPeerSkeletonClass)) +#define IS_ORG_FREEDESKTOP_DBUS_PEER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON)) +#define IS_ORG_FREEDESKTOP_DBUS_PEER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ORG_FREEDESKTOP_DBUS_PEER_SKELETON)) + +typedef struct _OrgFreedesktopDBusPeerSkeleton OrgFreedesktopDBusPeerSkeleton; +typedef struct _OrgFreedesktopDBusPeerSkeletonClass OrgFreedesktopDBusPeerSkeletonClass; +typedef struct _OrgFreedesktopDBusPeerSkeletonPrivate OrgFreedesktopDBusPeerSkeletonPrivate; + +struct _OrgFreedesktopDBusPeerSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + OrgFreedesktopDBusPeerSkeletonPrivate *priv; +}; + +struct _OrgFreedesktopDBusPeerSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType org_freedesktop_dbus_peer_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (OrgFreedesktopDBusPeerSkeleton, g_object_unref) +#endif + +OrgFreedesktopDBusPeer *org_freedesktop_dbus_peer_skeleton_new (void); + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.lightmediascanner.Scanner1 */ + +#define TYPE_SCANNER1 (scanner1_get_type ()) +#define SCANNER1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_SCANNER1, Scanner1)) +#define IS_SCANNER1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_SCANNER1)) +#define SCANNER1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_SCANNER1, Scanner1Iface)) + +struct _Scanner1; +typedef struct _Scanner1 Scanner1; +typedef struct _Scanner1Iface Scanner1Iface; + +struct _Scanner1Iface +{ + GTypeInterface parent_iface; + + + + gboolean (*handle_release_write_lock) ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_request_write_lock) ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_scan) ( + Scanner1 *object, + GDBusMethodInvocation *invocation, + GVariant *arg_specification); + + gboolean (*handle_stop) ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + + GVariant * (*get_categories) (Scanner1 *object); + + const gchar * (*get_data_base_path) (Scanner1 *object); + + gboolean (*get_is_scanning) (Scanner1 *object); + + guint64 (*get_update_id) (Scanner1 *object); + + gboolean (*get_write_locked) (Scanner1 *object); + + void (*scan_progress) ( + Scanner1 *object, + const gchar *arg_Category, + const gchar *arg_Path, + guint64 arg_UpToDate, + guint64 arg_Processed, + guint64 arg_Deleted, + guint64 arg_Skipped, + guint64 arg_Errors); + +}; + +GType scanner1_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *scanner1_interface_info (void); +guint scanner1_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void scanner1_complete_scan ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + +void scanner1_complete_stop ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + +void scanner1_complete_request_write_lock ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + +void scanner1_complete_release_write_lock ( + Scanner1 *object, + GDBusMethodInvocation *invocation); + + + +/* D-Bus signal emissions functions: */ +void scanner1_emit_scan_progress ( + Scanner1 *object, + const gchar *arg_Category, + const gchar *arg_Path, + guint64 arg_UpToDate, + guint64 arg_Processed, + guint64 arg_Deleted, + guint64 arg_Skipped, + guint64 arg_Errors); + + + +/* D-Bus method calls: */ +void scanner1_call_scan ( + Scanner1 *proxy, + GVariant *arg_specification, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean scanner1_call_scan_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error); + +gboolean scanner1_call_scan_sync ( + Scanner1 *proxy, + GVariant *arg_specification, + GCancellable *cancellable, + GError **error); + +void scanner1_call_stop ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean scanner1_call_stop_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error); + +gboolean scanner1_call_stop_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error); + +void scanner1_call_request_write_lock ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean scanner1_call_request_write_lock_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error); + +gboolean scanner1_call_request_write_lock_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error); + +void scanner1_call_release_write_lock ( + Scanner1 *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean scanner1_call_release_write_lock_finish ( + Scanner1 *proxy, + GAsyncResult *res, + GError **error); + +gboolean scanner1_call_release_write_lock_sync ( + Scanner1 *proxy, + GCancellable *cancellable, + GError **error); + + + +/* D-Bus property accessors: */ +const gchar *scanner1_get_data_base_path (Scanner1 *object); +gchar *scanner1_dup_data_base_path (Scanner1 *object); +void scanner1_set_data_base_path (Scanner1 *object, const gchar *value); + +gboolean scanner1_get_is_scanning (Scanner1 *object); +void scanner1_set_is_scanning (Scanner1 *object, gboolean value); + +gboolean scanner1_get_write_locked (Scanner1 *object); +void scanner1_set_write_locked (Scanner1 *object, gboolean value); + +guint64 scanner1_get_update_id (Scanner1 *object); +void scanner1_set_update_id (Scanner1 *object, guint64 value); + +GVariant *scanner1_get_categories (Scanner1 *object); +GVariant *scanner1_dup_categories (Scanner1 *object); +void scanner1_set_categories (Scanner1 *object, GVariant *value); + + +/* ---- */ + +#define TYPE_SCANNER1_PROXY (scanner1_proxy_get_type ()) +#define SCANNER1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_SCANNER1_PROXY, Scanner1Proxy)) +#define SCANNER1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_SCANNER1_PROXY, Scanner1ProxyClass)) +#define SCANNER1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_SCANNER1_PROXY, Scanner1ProxyClass)) +#define IS_SCANNER1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_SCANNER1_PROXY)) +#define IS_SCANNER1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_SCANNER1_PROXY)) + +typedef struct _Scanner1Proxy Scanner1Proxy; +typedef struct _Scanner1ProxyClass Scanner1ProxyClass; +typedef struct _Scanner1ProxyPrivate Scanner1ProxyPrivate; + +struct _Scanner1Proxy +{ + /*< private >*/ + GDBusProxy parent_instance; + Scanner1ProxyPrivate *priv; +}; + +struct _Scanner1ProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType scanner1_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Scanner1Proxy, g_object_unref) +#endif + +void scanner1_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +Scanner1 *scanner1_proxy_new_finish ( + GAsyncResult *res, + GError **error); +Scanner1 *scanner1_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void scanner1_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +Scanner1 *scanner1_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +Scanner1 *scanner1_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_SCANNER1_SKELETON (scanner1_skeleton_get_type ()) +#define SCANNER1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_SCANNER1_SKELETON, Scanner1Skeleton)) +#define SCANNER1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_SCANNER1_SKELETON, Scanner1SkeletonClass)) +#define SCANNER1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_SCANNER1_SKELETON, Scanner1SkeletonClass)) +#define IS_SCANNER1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_SCANNER1_SKELETON)) +#define IS_SCANNER1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_SCANNER1_SKELETON)) + +typedef struct _Scanner1Skeleton Scanner1Skeleton; +typedef struct _Scanner1SkeletonClass Scanner1SkeletonClass; +typedef struct _Scanner1SkeletonPrivate Scanner1SkeletonPrivate; + +struct _Scanner1Skeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + Scanner1SkeletonPrivate *priv; +}; + +struct _Scanner1SkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType scanner1_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Scanner1Skeleton, g_object_unref) +#endif + +Scanner1 *scanner1_skeleton_new (void); + + +G_END_DECLS + +#endif /* __LIGHTMEDIASCANNER_INTERFACE_H__ */ diff --git a/sample/mediaplayer/binding/mediaplayer-api.c b/sample/mediaplayer/binding/mediaplayer-api.c new file mode 100644 index 0000000..e81c98a --- /dev/null +++ b/sample/mediaplayer/binding/mediaplayer-api.c @@ -0,0 +1,173 @@ +/* + * Copyright 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include + +#define AFB_BINDING_VERSION 2 +#include + +#include "mediaplayer-manager.h" + +static struct afb_event media_added_event; +static struct afb_event media_removed_event; + +/* + * @brief Subscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void subscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "media_added")) { + afb_req_subscribe(request, media_added_event); + } else if(!strcasecmp(value, "media_removed")) { + afb_req_subscribe(request, media_removed_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Unsubscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void unsubscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "media_added")) { + afb_req_unsubscribe(request, media_added_event); + } else if(!strcasecmp(value, "media_removed")) { + afb_req_unsubscribe(request, media_removed_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +static json_object *new_json_object_from_device(GList *list) +{ + json_object *jarray = json_object_new_array(); + json_object *jresp = json_object_new_object(); + json_object *jstring = NULL; + GList *l; + + for (l = list; l; l = l->next) + { + jstring = json_object_new_string(l->data); + json_object_array_add(jarray, jstring); + } + + if (jstring == NULL) + return NULL; + + json_object_object_add(jresp, "Media", jarray); + + return jresp; +} + +static void media_results_get (struct afb_req request) +{ + GList *list; + json_object *jresp = NULL; + + ListLock(); + list = media_lightmediascanner_scan(); + list = media_local_scan(list); + if (list == NULL) { + afb_req_fail(request, "failed", "media scan error"); + ListUnlock(); + return; + } + + jresp = new_json_object_from_device(list); + g_list_free(list); + ListUnlock(); + + if (jresp == NULL) { + afb_req_fail(request, "failed", "media parsing error"); + return; + } + + afb_req_success(request, jresp, "Media Results Displayed"); +} + +static void media_broadcast_device_added (GList *list) +{ + json_object *jresp = new_json_object_from_device(list); + + if (jresp != NULL) { + afb_event_push(media_added_event, jresp); + } +} + +static void media_broadcast_device_removed (const char *obj_path) +{ + json_object *jresp = json_object_new_object(); + json_object *jstring = json_object_new_string(obj_path); + + json_object_object_add(jresp, "Path", jstring); + + afb_event_push(media_removed_event, jresp); +} + +static const struct afb_verb_v2 binding_verbs[] = { + { "media_result", media_results_get, NULL, "Media scan result", AFB_SESSION_CHECK }, + { "subscribe", subscribe, NULL, "Subscribe for an event", AFB_SESSION_CHECK }, + { "unsubscribe", unsubscribe, NULL, "Unsubscribe for an event", AFB_SESSION_CHECK }, + { NULL } +}; + +static int preinit() +{ + Binding_RegisterCallback_t API_Callback; + API_Callback.binding_device_added = media_broadcast_device_added; + API_Callback.binding_device_removed = media_broadcast_device_removed; + BindingAPIRegister(&API_Callback); + + return MediaPlayerManagerInit(); +} + +static int init() +{ + media_added_event = afb_daemon_make_event("media_added"); + media_removed_event = afb_daemon_make_event("media_removed"); + + return 0; +} + +const struct afb_binding_v2 afbBindingV2 = { + .api = "media-manager", + .specification = "mediaplayer API", + .preinit = preinit, + .init = init, + .verbs = binding_verbs, +}; diff --git a/sample/mediaplayer/binding/mediaplayer-manager.c b/sample/mediaplayer/binding/mediaplayer-manager.c new file mode 100644 index 0000000..38e5cab --- /dev/null +++ b/sample/mediaplayer/binding/mediaplayer-manager.c @@ -0,0 +1,294 @@ +/* + * Copyright 2017 Konsulko Group + * + * Based on bluetooth-manager.c + * Copyright 2016 ALPS ELECTRIC CO., LTD. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "mediaplayer-manager.h" + +static Binding_RegisterCallback_t g_RegisterCallback = { 0 }; +static stMediaPlayerManage MediaPlayerManage = { 0 }; + +/* ------ LOCAL FUNCTIONS --------- */ +void ListLock() { + g_mutex_lock(&(MediaPlayerManage.m)); +} + +void ListUnlock() { + g_mutex_unlock(&(MediaPlayerManage.m)); +} + +void DebugTraceSendMsg(int level, gchar* message) +{ +#ifdef LOCAL_PRINT_DEBUG + switch (level) + { + case DT_LEVEL_ERROR: + g_print("[E]"); + break; + + case DT_LEVEL_WARNING: + g_print("[W]"); + break; + + case DT_LEVEL_NOTICE: + g_print("[N]"); + break; + + case DT_LEVEL_INFO: + g_print("[I]"); + break; + + case DT_LEVEL_DEBUG: + g_print("[D]"); + break; + + default: + g_print("[-]"); + break; + } + + g_print("%s",message); +#endif + + if (message) { + g_free(message); + } + +} + +GList* media_local_scan(GList *list) +{ + gchar *path = g_strconcat(g_get_home_dir(), "/", "Music", NULL); + gchar *tmp = NULL; + GDir *dir; + + dir = g_dir_open(path, 0, NULL); + if (dir == NULL) + { + LOGE("Cannot open media path %s\n", path); + return list; + } + + while ((tmp = (gchar *) g_dir_read_name(dir)) != NULL) + { + list = g_list_append(list, g_strdup_printf("file://%s/%s", path, tmp)); + } + + g_free(path); + g_dir_close(dir); + + return list; +} + +GList* media_lightmediascanner_scan(void) +{ + sqlite3 *conn; + sqlite3_stmt *res; + GList *list = NULL; + const char *tail; + const gchar *db_path; + int ret = 0; + + db_path = scanner1_get_data_base_path(MediaPlayerManage.lms_proxy); + + ret = sqlite3_open(db_path, &conn); + if (ret) { + LOGE("Cannot open SQLITE database: '%s'\n", db_path); + return NULL; + } + + ret = sqlite3_prepare_v2(conn, SQL_QUERY, strlen(SQL_QUERY) + 1, &res, &tail); + if (ret) { + LOGE("Cannot execute query '%s'\n", SQL_QUERY); + return NULL; + } + + while (sqlite3_step(res) == SQLITE_ROW) { + struct stat buf; + const char *path = (const char *) sqlite3_column_text(res, 0); + + ret = stat(path, &buf); + if (ret) + continue; + + list = g_list_append(list, g_strdup_printf("file://%s", path)); + } + + return list; +} + + +static void +on_interface_proxy_properties_changed (GDBusProxy *proxy, + GVariant *changed_properties, + const gchar* const *invalidated_properties) +{ + GVariantIter iter; + const gchar *key; + GVariant *subValue; + const gchar *pInterface; + GList *list; + + pInterface = g_dbus_proxy_get_interface_name (proxy); + + if (0 != g_strcmp0(pInterface, LIGHTMEDIASCANNER_INTERFACE)) + return; + + g_variant_iter_init (&iter, changed_properties); + while (g_variant_iter_next (&iter, "{&sv}", &key, &subValue)) + { + gboolean val; + if (0 == g_strcmp0(key,"IsScanning")) { + g_variant_get(subValue, "b", &val); + if (val == TRUE) + return; + } else if (0 == g_strcmp0(key, "WriteLocked")) { + g_variant_get(subValue, "b", &val); + if (val == TRUE) + return; + } + } + + ListLock(); + + list = media_lightmediascanner_scan(); + + if (list != NULL && g_RegisterCallback.binding_device_added) + g_RegisterCallback.binding_device_added(list); + + g_list_free_full(list, g_free); + + ListUnlock(); +} + +static int MediaPlayerDBusInit(void) +{ + GError *error = NULL; + + MediaPlayerManage.lms_proxy = scanner1_proxy_new_for_bus_sync( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, LIGHTMEDIASCANNER_SERVICE, + LIGHTMEDIASCANNER_PATH, NULL, &error); + + if (MediaPlayerManage.lms_proxy == NULL) { + LOGE("Create LightMediaScanner Proxy failed\n"); + return -1; + } + + g_signal_connect (MediaPlayerManage.lms_proxy, + "g-properties-changed", + G_CALLBACK (on_interface_proxy_properties_changed), + NULL); + + return 0; +} + +static void *media_event_loop_thread(void *unused) +{ + GMainLoop *loop = g_main_loop_new(NULL, FALSE); + int ret; + + ret = MediaPlayerDBusInit(); + if (ret == 0) { + LOGD("g_main_loop_run\n"); + g_main_loop_run(loop); + } + + g_main_loop_unref(loop); + + return NULL; +} + +void +unmount_cb (GFileMonitor *mon, + GFile *file, + GFile *other_file, + GFileMonitorEvent event, + gpointer udata) +{ + gchar *path = g_file_get_path(file); + gchar *uri = g_strconcat("file://", path, NULL); + g_free(path); + + ListLock(); + + if (g_RegisterCallback.binding_device_removed && + event == G_FILE_MONITOR_EVENT_DELETED) { + g_RegisterCallback.binding_device_removed(uri); + } + + ListUnlock(); + g_free(uri); +} + +/* + * Create MediaPlayer Manager Thread + * Note: mediaplayer-api should do MediaPlayerManagerInit() before any other + * API calls + * Returns: 0 - success or error conditions + */ +int MediaPlayerManagerInit() { + pthread_t thread_id; + GFile *file; + GFileMonitor *mon; + + g_mutex_init(&(MediaPlayerManage.m)); + + file = g_file_new_for_path("/media"); + g_assert(file != NULL); + + mon = g_file_monitor (file, G_FILE_MONITOR_NONE, NULL, NULL); + g_assert(mon != NULL); + g_signal_connect (mon, "changed", G_CALLBACK(unmount_cb), NULL); + + pthread_create(&thread_id, NULL, media_event_loop_thread, NULL); + + return 0; +} + +/* + * Register MediaPlayer Manager Callback functions + */ +void BindingAPIRegister(const Binding_RegisterCallback_t* pstRegisterCallback) +{ + if (NULL != pstRegisterCallback) + { + if (NULL != pstRegisterCallback->binding_device_added) + { + g_RegisterCallback.binding_device_added = + pstRegisterCallback->binding_device_added; + } + + if (NULL != pstRegisterCallback->binding_device_removed) + { + g_RegisterCallback.binding_device_removed = + pstRegisterCallback->binding_device_removed; + } + } +} diff --git a/sample/mediaplayer/binding/mediaplayer-manager.h b/sample/mediaplayer/binding/mediaplayer-manager.h new file mode 100644 index 0000000..5864867 --- /dev/null +++ b/sample/mediaplayer/binding/mediaplayer-manager.h @@ -0,0 +1,103 @@ +/* + * Copyright 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MEDIAPLAYER_MANAGER_H +#define MEDIAPLAYER_MANAGER_H + +#include +#include +#include + +#include "lightmediascanner_interface.h" + + /* Debug Trace Level */ +#define DT_LEVEL_ERROR (1 << 1) +#define DT_LEVEL_WARNING (1 << 2) +#define DT_LEVEL_NOTICE (1 << 3) +#define DT_LEVEL_INFO (1 << 4) +#define DT_LEVEL_DEBUG (1 << 5) +//#define _DEBUG + +#define LOGE(fmt, args...) \ + DebugTraceSendMsg(DT_LEVEL_ERROR, g_strdup_printf("[%d:%s]" fmt, __LINE__, __FUNCTION__, ## args)) +#define LOGW(fmt, args...) \ + DebugTraceSendMsg(DT_LEVEL_WARNING, g_strdup_printf("[%d:%s]" fmt, __LINE__, __FUNCTION__, ## args)) +#define LOGN(fmt, args...) \ + DebugTraceSendMsg(DT_LEVEL_NOTICE, g_strdup_printf("[%d:%s]" fmt, __LINE__, __FUNCTION__, ## args)) +#define LOGI(fmt, args...) \ + DebugTraceSendMsg(DT_LEVEL_INFO, g_strdup_printf("[%d:%s]" fmt, __LINE__, __FUNCTION__, ## args)) +#define LOGD(fmt, args...) \ + DebugTraceSendMsg(DT_LEVEL_DEBUG, g_strdup_printf("[%d:%s]" fmt, __LINE__, __FUNCTION__, ## args)) + +#ifdef _DEBUG + #define _DEBUG_PRINT_DBUS + #define LOCAL_PRINT_DEBUG +#endif + +#ifdef LOCAL_PRINT_DEBUG +#define D_PRINTF(fmt, args...) \ + g_print("[DEBUG][%d:%s]"fmt, __LINE__, __FUNCTION__, ## args) +#define D_PRINTF_RAW(fmt, args...) \ + g_print(""fmt, ## args) +#else +#define D_PRINTF(fmt, args...) +#define D_PRINTF_RAW(fmt, args...) +#endif /* ifdef _DEBUG */ + +void DebugTraceSendMsg(int level, gchar* message); + +//service +#define AGENT_SERVICE "org.agent" + +//remote service +#define LIGHTMEDIASCANNER_SERVICE "org.lightmediascanner" + +//object path +#define LIGHTMEDIASCANNER_PATH "/org/lightmediascanner/Scanner1" + +//interface +#define LIGHTMEDIASCANNER_INTERFACE "org.lightmediascanner.Scanner1" +#define UDISKS_INTERFACE "org.freedesktop.UDisks" +#define FREEDESKTOP_PROPERTIES "org.freedesktop.DBus.Properties" + +//sqlite +#define SQL_QUERY "SELECT files.path FROM files LEFT JOIN audios " \ + "WHERE audios.id = files.id ORDER BY " \ + "audios.artist_id, audios.album_id, audios.trackno" + +typedef struct { + GList *list; + GMutex m; + Scanner1 *lms_proxy; +} stMediaPlayerManage; + +typedef struct tagBinding_RegisterCallback +{ + void (*binding_device_added)(GList *list); + void (*binding_device_removed)(const char *obj_path); +} Binding_RegisterCallback_t; + +/* ------ PUBLIC PLUGIN FUNCTIONS --------- */ +void BindingAPIRegister(const Binding_RegisterCallback_t* pstRegisterCallback); +int MediaPlayerManagerInit(void); + +void ListLock(); +void ListUnlock(); + +GList* media_lightmediascanner_scan(void); +GList* media_local_scan(GList *list); + +#endif diff --git a/sample/mediaplayer/mediaplayer.pro b/sample/mediaplayer/mediaplayer.pro new file mode 100644 index 0000000..80f6d6c --- /dev/null +++ b/sample/mediaplayer/mediaplayer.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS = app binding package +package.depends += app binding diff --git a/sample/mediaplayer/package/config.xml b/sample/mediaplayer/package/config.xml new file mode 100644 index 0000000..367791f --- /dev/null +++ b/sample/mediaplayer/package/config.xml @@ -0,0 +1,19 @@ + + + MediaPlayer + + + This is a demo application for multimedia + Tasuku Suzuki <tasuku.suzuki@qt.io> + APL 2.0 + + + + + + + + + + + diff --git a/sample/mediaplayer/package/icon.svg b/sample/mediaplayer/package/icon.svg new file mode 100644 index 0000000..91661a7 --- /dev/null +++ b/sample/mediaplayer/package/icon.svg @@ -0,0 +1,279 @@ + + + +image/svg+xmlMULTIMEDIA + \ No newline at end of file diff --git a/sample/mediaplayer/package/package.pro b/sample/mediaplayer/package/package.pro new file mode 100644 index 0000000..47996f5 --- /dev/null +++ b/sample/mediaplayer/package/package.pro @@ -0,0 +1,19 @@ + +DISTFILES = icon.svg config.xml + +copy_icon.target = $$OUT_PWD/root/icon.svg +copy_icon.depends = $$_PRO_FILE_PWD_/icon.svg +copy_icon.commands = $(COPY_FILE) \"$$replace(copy_icon.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_icon.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_icon +PRE_TARGETDEPS += $$copy_icon.target + +copy_config.target = $$OUT_PWD/root/config.xml +copy_config.depends = $$_PRO_FILE_PWD_/config.xml +copy_config.commands = $(COPY_FILE) \"$$replace(copy_config.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_config.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_config +PRE_TARGETDEPS += $$copy_config.target + +wgt.target = package +wgt.commands = wgtpkg-pack -f -o mediaplayer.wgt root + +QMAKE_EXTRA_TARGETS += wgt diff --git a/sample/radio/COPYING b/sample/radio/COPYING new file mode 100644 index 0000000..d511905 --- /dev/null +++ b/sample/radio/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/sample/radio/LICENSE b/sample/radio/LICENSE new file mode 100644 index 0000000..31c692a --- /dev/null +++ b/sample/radio/LICENSE @@ -0,0 +1,54 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/sample/radio/app/PresetDataObject.cpp b/sample/radio/app/PresetDataObject.cpp new file mode 100644 index 0000000..6e69626 --- /dev/null +++ b/sample/radio/app/PresetDataObject.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2016 by Scott Murray + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "PresetDataObject.h" + +PresetDataObject::PresetDataObject(QObject *parent) : QObject(parent) +{ +} + +PresetDataObject::PresetDataObject(const QString &title, const quint32 &frequency, const quint32 &band, QObject *parent) + : QObject(parent), m_title(title), m_frequency(frequency), m_band(band) +{ +} + +QString PresetDataObject::title() const +{ + return m_title; +} + +void PresetDataObject::setTitle(const QString &title) +{ + if (title != m_title) { + m_title = title; + emit titleChanged(); + } +} + +quint32 PresetDataObject::frequency() const +{ + return m_frequency; +} + +void PresetDataObject::setFrequency(const quint32 &frequency) { + if (frequency != m_frequency) { + m_frequency = frequency; + emit frequencyChanged(); + } +} + +quint32 PresetDataObject::band() const +{ + return m_band; +} + +void PresetDataObject::setBand(const quint32 &band) { + if (band != m_band) { + m_band = band; + emit bandChanged(); + } +} diff --git a/sample/radio/app/PresetDataObject.h b/sample/radio/app/PresetDataObject.h new file mode 100644 index 0000000..a43b853 --- /dev/null +++ b/sample/radio/app/PresetDataObject.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2016 by Scott Murray + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRESETDATAOBJECT_H +#define PRESETDATAOBJECT_H + +#include + +class PresetDataObject : public QObject +{ + Q_OBJECT + + Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged) + Q_PROPERTY(quint32 frequency READ frequency WRITE setFrequency NOTIFY frequencyChanged) + Q_PROPERTY(quint32 band READ band WRITE setBand NOTIFY bandChanged) + +public: + PresetDataObject(QObject *parent = Q_NULLPTR); + PresetDataObject(const QString &title, const quint32 &frequency, const quint32 &band, QObject *parent = Q_NULLPTR); + + QString title() const; + + void setTitle(const QString &title); + + quint32 frequency() const; + + void setFrequency(const quint32 &frequency); + + quint32 band() const; + + void setBand(const quint32 &band); + +signals: + void titleChanged(); + void frequencyChanged(); + void bandChanged(); + +private: + QString m_title; + quint32 m_frequency; + quint32 m_band; +}; + +#endif // PRESETDATAOBJECT_H diff --git a/sample/radio/app/Radio.qml b/sample/radio/app/Radio.qml new file mode 100644 index 0000000..54d4844 --- /dev/null +++ b/sample/radio/app/Radio.qml @@ -0,0 +1,350 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * Copyright (C) 2017 Toyota Motor Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtQuick.Layouts 1.1 +import QtQuick.Controls 2.0 +import AGL.Demo.Controls 1.0 +import 'api' as API + +ApplicationWindow { + id: root + + API.Binding { + id: radio + + property string title + + onBandChanged: frequency = minimumFrequency + onStationFound: title = stationId + onFrequencyChanged: { + title = '' + slider.value = frequency + } + } + property int sourceID + property int connectionID + + function slotReply(msg){ + var jstr = JSON.stringify(msg) + console.log("radio: Json jstr:" + jstr) + var content = JSON.parse(jstr); + var verb = content.response.verb + var err = content.response.error + console.log("radio: verb: " + verb) + console.log("radio: content.response.error: " + err) + switch(verb) + { + case "connect": + console.log("radio: replied by connect") + if(err == 0){ + connectionID = content.response.mainConnectionID + console.log("radio: mainConnectionID is " + connectionID) + } + break; + case "registerSource": + console.log("radio: replied by registerSource") + if(err == 0){ + sourceID = content.response.sourceID + } + default: + break; + } + } + + function slotEvent(event,msg){ + var jstr = JSON.stringify(msg) + var content = JSON.parse(jstr); + var eventName = content.event + console.log("radio: event qml: event" + eventName + " msg: " + jstr) + switch(eventName) + { + case "soundmanager\/asyncSetSourceState": + console.log("radio: soundmanager\/asyncSetSourceState") + console.log("radio: my soundID:" + sourceID + "handle:" + content.data.handle + ",sourceID:" + content.data.sourceID + ",sourceState:" + content.data.sourceState) + if(sourceID == content.data.sourceID){ + console.log("radio: call ackSetSourceState") + var arg = JSON.stringify({handle:content.data.handle, error:0}) + smw.call("ackSetSourceState", arg) + switch(content.data.sourceState){ + case "on": + radio.start() + break; + case "off": + radio.stop() + break; + case "paused": + + radio.stop() + break; + } + } + break; + case "soundmanager\/asyncConnect": + // In reality, device shall be opened in this timing + if(connectionID == content.data.connectionID){ + //radio.open_device() + } + break; + case "soundmanager\/asyncDisconnect": + // In reality, device shall be closed in this timing + if(connectionID == content.data.connectionID){ + // radio.close_device() + } + break; + default: + break; + } + } + + ColumnLayout { + anchors.fill: parent + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 3 + clip: true + Image { + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + fillMode: Image.PreserveAspectFit + source: './images/HMI_Radio_Equalizer.svg' + } + Item { + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + height :307 + Rectangle { + anchors.fill: parent + color: 'black' + opacity: 0.75 + } + + ColumnLayout { + anchors.fill: parent + anchors.margins: root.width * 0.02 + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Row { + spacing: 20 + Image { + source: './images/FM_Icons_FM.svg' + } +// ToggleButton { +// offImage: './images/FM_Icons_FM.svg' +// onImage: './images/FM_Icons_AM.svg' +// onCheckedChanged: { +// radio.band = checked ? radio.amBand : radio.fmBand +// radio.frequency = radio.minimumFrequency +// } +// } + } + ColumnLayout { + anchors.fill: parent + Label { + id: label + Layout.alignment: Layout.Center + text: radio.freq2str(radio.frequency) + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + } + Label { + id: artist + Layout.alignment: Layout.Center + text: radio.title + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + font.pixelSize: label.font.pixelSize * 0.6 + } + } + } + Slider { + id: slider + Layout.fillWidth: true + from: radio.minimumFrequency + to: radio.maximumFrequency + stepSize: radio.frequencyStep + snapMode: Slider.SnapOnRelease + onValueChanged: radio.frequency = value + Label { + anchors.left: parent.left + anchors.bottom: parent.top + font.pixelSize: 32 + text: radio.freq2str(radio.minimumFrequency) + } + Label { + anchors.right: parent.right + anchors.bottom: parent.top + font.pixelSize: 32 + text: radio.freq2str(radio.maximumFrequency) + } + } + RowLayout { + Layout.fillHeight: true + + Label { + text: 'TUNE' + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_BackArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.tuneDown() + } + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_ForwardArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.tuneUp() + } + } + + Item { Layout.fillWidth: true } + + ImageButton { + id: play + offImage: './images/AGL_MediaPlayer_Player_Play.svg' + onClicked: { + var JsonArg = JSON.stringify({sourceID:sourceID, sinkID:1}) + console.log(JsonArg) + smw.call("connect",JsonArg) + } + states: [ + State { + when: radio.state === radio.activeState + PropertyChanges { + target: play + offImage: './images/AGL_MediaPlayer_Player_Pause.svg' + onClicked: { + var JsonDisConArg = JSON.stringify({mainConnectionID:connectionID}); + console.log(JsonDisConArg) + smw.call("disconnect",JsonDisConArg) + //radio.stop() + } + } + } + ] + } + + Item { Layout.fillWidth: true } + + Label { + //Layout.fillWidth: true + text: 'SCAN' + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_BackArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.scanDown() + } + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_ForwardArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.scanUp() + } + } + + } + } + } + } + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 2 + ListView { + anchors.fill: parent + anchors.leftMargin: 50 + anchors.rightMargin: 50 + clip: true + header: Label { text: 'PRESETS'; opacity: 0.5 } + model: presetModel + + delegate: MouseArea { + width: ListView.view.width + height: ListView.view.height / 4 + + onClicked: { + radio.band = model.modelData.band + radio.frequency = model.modelData.frequency + radio.title = model.modelData.title + } + + RowLayout { + anchors.fill: parent + Image { + source: './images/Radio_Active_Icon.svg' + } + ColumnLayout { + Layout.fillWidth: true + Label { + Layout.fillWidth: true + text: model.title + } + Label { + Layout.fillWidth: true + text: radio.freq2str(model.frequency) + color: '#59FF7F' + font.pixelSize: 32 + } + } + Image { + source: { + switch (model.modelData.band) { + case radio.fmBand: + return './images/FM_Icons_FM.svg' + case radio.amBand: + return './images/FM_Icons_AM.svg' + } + return null + } + } + } + } + } + } + Component.onCompleted: { + var JsonRegArg = JSON.stringify({appname:"radio"}) + console.log(JsonRegArg) + smw.call("registerSource", JsonRegArg) + } + } +} diff --git a/sample/radio/app/api/Binding.qml b/sample/radio/app/api/Binding.qml new file mode 100644 index 0000000..55c6224 --- /dev/null +++ b/sample/radio/app/api/Binding.qml @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtWebSockets 1.0 + +WebSocket { + id: root + active: true + url: bindingAddress + + property string apiString: "radio" + property var verbs: [] + property string payloadLength: "9999" + + readonly property var msgid: { + "call": 2, + "retok": 3, + "reterr": 4, + "event": 5 + } + + readonly property int amBand: 0 + readonly property int fmBand: 1 + + readonly property int stoppedState: 0 + readonly property int activeState: 1 + + property int band: fmBand + property int frequency + property int frequencyStep + property int minimumFrequency + property int maximumFrequency + property int state: stoppedState + property int scanningState: stoppedState + property bool scanningFreqUpdate: false + property string stationId: "" + + signal stationFound + + property Connections c : Connections { + target: root + + onFrequencyChanged: { + if(scanningState != activeState) { + // Not scanning, push update + sendSocketMessage("frequency", { value: frequency }) + } else if(!scanningFreqUpdate) { + // External change, stop scanning + sendSocketMessage("scan_stop", 'None') + scanningState = stoppedState + sendSocketMessage("frequency", { value: frequency }) + } else { + // This update was from scanning, clear state + scanningFreqUpdate = false + } + } + + onBandChanged: { + sendSocketMessage("band", { value: band }) + updateFrequencyRange(band) + updateFrequencyStep(band) + frequency = minimumFrequency + } + } + + onTextMessageReceived: { + var json = JSON.parse(message) + //console.debug("Raw response: " + message) + var request = json[2].request + var response = json[2].response + + switch (json[0]) { + case msgid.call: + break + case msgid.retok: + var verb = verbs.shift() + if (verb == "frequency_range") { + minimumFrequency = response.min + maximumFrequency = response.max + } else if (verb == "frequency_step") { + frequencyStep = response.step + } + break + case msgid.event: + var event = JSON.parse(JSON.stringify(json[2])) + if (event.event === "radio/frequency") { + if(scanningState == activeState) { + scanningFreqUpdate = true + frequency = event.data.value + } + } else if (event.event === "radio/station_found") { + if(scanningState == activeState) { + scanningState = stoppedState + stationId = freq2str(event.data.value) + root.stationFound() + } + } + break + case msg.reterr: + console.debug("Bad return value, binding probably not installed") + break + case MessageId.event: + break + } + } + + onStatusChanged: { + switch (status) { + case WebSocket.Open: + // Initialize band values now that we're connected to the + // binding + //smw.call("registerSource", { appname: radio }) + updateFrequencyRange(band) + updateFrequencyStep(band) + frequency = minimumFrequency + sendSocketMessage("subscribe", { value: "frequency" }) + sendSocketMessage("subscribe", { value: "station_found" }) + break + case WebSocket.Error: + console.debug("WebSocket error: " + root.errorString) + break + } + } + + function freq2str(freq) { + if (freq > 5000000) { + return '%1 MHz'.arg((freq / 1000000).toFixed(1)) + } else { + return '%1 kHz'.arg((freq / 1000).toFixed(0)) + } + } + + function sendSocketMessage(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, apiString + '/' + + verb, parameter ] + //console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + verbs.push(verb) + sendTextMessage(JSON.stringify(requestJson)) + } + + function start() { + console.log("start radio") + sendSocketMessage("start", 'None') + state = activeState + } + + function stop() { + console.log("stop radio") + sendSocketMessage("stop", 'None') + state = stoppedState + } + + function tuneUp() { + frequency += frequencyStep + if(frequency > maximumFrequency) { + frequency = minimumFrequency + } + } + + function tuneDown() { + frequency -= frequencyStep + if(frequency < minimumFrequency) { + frequency = maximumFrequency + } + } + + function scanUp() { + scanningState = activeState + sendSocketMessage("scan_start", { direction: "forward" }) + } + + function scanDown() { + scanningState = activeState + sendSocketMessage("scan_start", { direction: "backward" }) + } + + function updateFrequencyRange(band) { + sendSocketMessage("frequency_range", { band: band }) + } + + function updateFrequencyStep(band) { + sendSocketMessage("frequency_step", { band: band }) + } +} diff --git a/sample/radio/app/app.pri b/sample/radio/app/app.pri new file mode 100644 index 0000000..b6f2f91 --- /dev/null +++ b/sample/radio/app/app.pri @@ -0,0 +1,12 @@ +TEMPLATE = app + +load(configure) +qtCompileTest(libhomescreen) + +config_libhomescreen { + CONFIG += link_pkgconfig + PKGCONFIG += homescreen soundmanager + DEFINES += HAVE_LIBHOMESCREEN HAVE_SOUNDMANAGER +} + +DESTDIR = $${OUT_PWD}/../package/root/bin diff --git a/sample/radio/app/app.pro b/sample/radio/app/app.pro new file mode 100644 index 0000000..f8f70e0 --- /dev/null +++ b/sample/radio/app/app.pro @@ -0,0 +1,14 @@ +TARGET = radio +QT = quickcontrols2 + +HEADERS = PresetDataObject.h libsoundmanager.hpp libsmwrapper.h +SOURCES = main.cpp PresetDataObject.cpp libsmwrapper.cpp + +CONFIG += link_pkgconfig +PKGCONFIG += soundmanager libsystemd + +RESOURCES += \ + radio.qrc \ + images/images.qrc + +include(app.pri) diff --git a/sample/radio/app/config.tests/libhomescreen/libhomescreen.cpp b/sample/radio/app/config.tests/libhomescreen/libhomescreen.cpp new file mode 100644 index 0000000..d698b05 --- /dev/null +++ b/sample/radio/app/config.tests/libhomescreen/libhomescreen.cpp @@ -0,0 +1,8 @@ +#include + +int main(int argc,char **argv) +{ + LibHomeScreen libHomeScreen; + return 0; +} + diff --git a/sample/radio/app/config.tests/libhomescreen/libhomescreen.pro b/sample/radio/app/config.tests/libhomescreen/libhomescreen.pro new file mode 100644 index 0000000..eb4e8f3 --- /dev/null +++ b/sample/radio/app/config.tests/libhomescreen/libhomescreen.pro @@ -0,0 +1,5 @@ +SOURCES = libhomescreen.cpp + +CONFIG -= qt +CONFIG += link_pkgconfig +PKGCONFIG += homescreen diff --git a/sample/radio/app/images/AGL_MediaPlayer_BackArrow.svg b/sample/radio/app/images/AGL_MediaPlayer_BackArrow.svg new file mode 100644 index 0000000..c49b519 --- /dev/null +++ b/sample/radio/app/images/AGL_MediaPlayer_BackArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/AGL_MediaPlayer_ForwardArrow.svg b/sample/radio/app/images/AGL_MediaPlayer_ForwardArrow.svg new file mode 100644 index 0000000..56576ac --- /dev/null +++ b/sample/radio/app/images/AGL_MediaPlayer_ForwardArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/AGL_MediaPlayer_Player_Pause.svg b/sample/radio/app/images/AGL_MediaPlayer_Player_Pause.svg new file mode 100644 index 0000000..ee55213 --- /dev/null +++ b/sample/radio/app/images/AGL_MediaPlayer_Player_Pause.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/AGL_MediaPlayer_Player_Play.svg b/sample/radio/app/images/AGL_MediaPlayer_Player_Play.svg new file mode 100644 index 0000000..c296f8a --- /dev/null +++ b/sample/radio/app/images/AGL_MediaPlayer_Player_Play.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/FM_Icons_AM.svg b/sample/radio/app/images/FM_Icons_AM.svg new file mode 100644 index 0000000..ea6e5e1 --- /dev/null +++ b/sample/radio/app/images/FM_Icons_AM.svg @@ -0,0 +1,71 @@ + + + +image/svg+xmlFM +AM | + \ No newline at end of file diff --git a/sample/radio/app/images/FM_Icons_FM.svg b/sample/radio/app/images/FM_Icons_FM.svg new file mode 100644 index 0000000..0f3ae59 --- /dev/null +++ b/sample/radio/app/images/FM_Icons_FM.svg @@ -0,0 +1,65 @@ + + + +image/svg+xmlFM +AM | + \ No newline at end of file diff --git a/sample/radio/app/images/HMI_Radio_Equalizer.svg b/sample/radio/app/images/HMI_Radio_Equalizer.svg new file mode 100644 index 0000000..6959144 --- /dev/null +++ b/sample/radio/app/images/HMI_Radio_Equalizer.svg @@ -0,0 +1,335 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/Radio_Active_Icon.svg b/sample/radio/app/images/Radio_Active_Icon.svg new file mode 100644 index 0000000..383f2cd --- /dev/null +++ b/sample/radio/app/images/Radio_Active_Icon.svg @@ -0,0 +1,299 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio/app/images/images.qrc b/sample/radio/app/images/images.qrc new file mode 100644 index 0000000..9161221 --- /dev/null +++ b/sample/radio/app/images/images.qrc @@ -0,0 +1,12 @@ + + + AGL_MediaPlayer_BackArrow.svg + AGL_MediaPlayer_ForwardArrow.svg + AGL_MediaPlayer_Player_Pause.svg + AGL_MediaPlayer_Player_Play.svg + FM_Icons_AM.svg + FM_Icons_FM.svg + HMI_Radio_Equalizer.svg + Radio_Active_Icon.svg + + diff --git a/sample/radio/app/libsmwrapper.cpp b/sample/radio/app/libsmwrapper.cpp new file mode 100644 index 0000000..54b94d8 --- /dev/null +++ b/sample/radio/app/libsmwrapper.cpp @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "libsmwrapper.h" +using namespace std; + +static int create_json_object(const QJsonObject& obj, struct json_object* jobj); +static bool put_val_to_jobj(const char* key, const QJsonValue& val, struct json_object* jobj); +static bool put_array_to_jobj(const char* key, const QJsonArray& qarray, struct json_object* jobj); + +LibSMWrapper::LibSMWrapper(QObject *parent) : + QObject(parent) +{ + /* This is not enabled */ + //libsm = new LibSoundmanager(); +} + +LibSMWrapper::LibSMWrapper(const int port, const QString& token, QObject *parent) : + QObject(parent) +{ + libsm = new LibSoundmanager(port, token.toStdString()); +} + +LibSMWrapper::~LibSMWrapper() +{ + delete libsm; +} + +int LibSMWrapper::call(const QString &verb, const QString &arg) +{ + // translate QJsonObject to struct json_object + struct json_object* jobj = json_object_new_object(); + QJsonDocument jsonDoc = QJsonDocument::fromJson(arg.toUtf8()); + const QJsonObject jsonObj = jsonDoc.object(); + int ret = create_json_object(jsonObj, jobj); + if(ret < 0) + { + return -1; + } + return libsm->call(verb.toStdString().c_str(), jobj); +} + +static int create_json_object(const QJsonObject& obj, struct json_object* jobj) +{ + try{ + for(auto itr = obj.begin(); itr != obj.end();++itr) + { + string key = itr.key().toStdString(); + //const char* key = itr.key().toStdString().c_str(); // Do not code like this. string is removed if size is over 16!! + + bool ret = put_val_to_jobj(key.c_str(), itr.value(),jobj); + if(!ret){ + /*This is not implemented*/ + qDebug("JsonArray can't parse for now"); + return -1; + // ToDo + // For now, array may not be inputted for soundmanager + // But use case absolutely exists + /*QJsonArray qarray = itr.value().toArray(); + ret = put_array_to_jobj(key, qarray, jobj);*/ + } + } + } + catch(...){ + qDebug("Json parse error occured"); + return -1; + } + return 0; +} + +static bool put_val_to_jobj(const char* key, const QJsonValue& val, struct json_object* jobj) +{ + if(val.isArray()){ + return false; // Array can't input + } + if(val.isString()){ + string value = val.toString().toStdString(); + json_object_object_add(jobj, key, json_object_new_string(value.c_str())); + } + else{ + const int value = val.toInt(); + json_object_object_add(jobj, key, json_object_new_int(value)); + } + return true; +} + +static bool put_array_to_jobj(const char* key, const QJsonArray& qarray, struct json_object* jobj) +{ + // ToDo Fix this !! +/* struct json_object* jarray = json_object_new_array(); + + bool ret; + for(auto jitr = qarray.begin(); jitr != qarray.end(); ++jitr){ + struct json_object* tmp = json_object_new_object(); + ret = put_val_to_jobj(key,jitr,tmp); + if(!ret) + { + put_array_to_jobj(key,jitr,tmp); + } + json_object_array_add(jarray, tmp); + } + json_object_object_add(jobj, key, jarray); + return true;*/ +} + +void LibSMWrapper::wrapper_registerCallback( + void (*event_func)(const string& event, struct json_object* event_contents), + void (*reply_func)(struct json_object* reply_contents)) +{ + libsm->register_callback(event_func, reply_func); +} + +void LibSMWrapper::subscribe(const QString event_name) +{ + std::string str = event_name.toStdString(); + libsm->subscribe(str); +} + +void LibSMWrapper::unsubscribe(const QString event_name) +{ + std::string str = event_name.toStdString(); + libsm->unsubscribe(str); +} + +void LibSMWrapper::run_eventloop() +{ + libsm->run_eventloop(); +} + +void LibSMWrapper::print(const QString &str) +{ + qDebug("%s is called", str.toStdString().c_str()); +} + +void LibSMWrapper::emit_event(const QString &event, const QJsonObject &msg) +{ + qDebug("emit smEvent signal @%s", __FUNCTION__); + emit smEvent(event, msg); +} +void LibSMWrapper::emit_reply(const QJsonObject &msg) +{ + qDebug("emit smReply signal @%s", __FUNCTION__); + emit smReply(msg); +} \ No newline at end of file diff --git a/sample/radio/app/libsmwrapper.h b/sample/radio/app/libsmwrapper.h new file mode 100644 index 0000000..3954a29 --- /dev/null +++ b/sample/radio/app/libsmwrapper.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef SIGNALER_H +#define SIGNALER_H + + #include + #include + #include + #include + #include + #include + #include + + +class LibSMWrapper : public QObject +{ + Q_OBJECT +public: // method + explicit LibSMWrapper(QObject *parent = nullptr); + LibSMWrapper(const int port, const QString& token, QObject *parent = nullptr); + ~LibSMWrapper(); + + void wrapper_registerCallback( + void (*event_func)(const std::string& event, struct json_object* event_contents), + void (*reply_func)(struct json_object* reply_contents) + ); + void subscribe(const QString event_name); + void unsubscribe(const QString event_name); + void run_eventloop(); + + void emit_event(const QString &event, const QJsonObject &msg); + void emit_reply(const QJsonObject &msg); +public slots: + int call(const QString &verb, const QString &arg); + void print(const QString &str); +signals: + void smEvent(const QVariant &event, const QVariant &msg); + void smReply(const QVariant &msg); + +private: + LibSoundmanager* libsm; +}; + + +#endif /*SIGNALER_H*/ \ No newline at end of file diff --git a/sample/radio/app/main.cpp b/sample/radio/app/main.cpp new file mode 100644 index 0000000..94e40d3 --- /dev/null +++ b/sample/radio/app/main.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2016, 2017 Konsulko Group + * Copyright (C) 2016, 2017 Toyota Motor Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "PresetDataObject.h" +#include "libsmwrapper.h" +#include + +LibSMWrapper* smw; + +static void onRep(struct json_object* reply_contents); +static void onEv(const std::string& event, struct json_object* event_contents); + +int main(int argc, char *argv[]) +{ + #ifdef HAVE_LIBHOMESCREEN + LibHomeScreen libHomeScreen = new LibHomeScreen(); + + if (!libHomeScreen.renderAppToAreaAllowed(0, 1)) { + qWarning() << "renderAppToAreaAllowed is denied"; + return -1; + } +#endif + QGuiApplication app(argc, argv); + + QQuickStyle::setStyle("AGL"); + + QCommandLineParser parser; + parser.addPositionalArgument("port", app.translate("main", "port for binding")); + parser.addPositionalArgument("secret", app.translate("main", "secret for binding")); + parser.addHelpOption(); + parser.addVersionOption(); + parser.process(app); + QStringList positionalArguments = parser.positionalArguments(); + + qDebug("started libsoundmanger"); + // Read presets from configuration file + // + // If HOME is set, use $HOME/app-data/radio/presets.conf, else fall back + // to the QSettings default locations with organization "AGL" and a + // file name of radio-presets.conf. See: + // + // http://doc.qt.io/qt-5/qsettings.html#platform-specific-notes + // + // for details on the locations and their order of priority. + // + QSettings *pSettings = NULL; + char *p = getenv("HOME"); + if(p) { + QString confPath = p; + confPath.append("/app-data/radio/presets.conf"); + pSettings = new QSettings(confPath, QSettings::NativeFormat); + } else { + pSettings = new QSettings("AGL", "radio-presets"); + } + QList presetDataList; + int size = pSettings->beginReadArray("fmPresets"); + for (int i = 0; i < size; ++i) { + pSettings->setArrayIndex(i); + presetDataList.append(new PresetDataObject(pSettings->value("title").toString(), + pSettings->value("frequency").toInt(), + 1)); + } + pSettings->endArray(); + + QQmlApplicationEngine engine; + QQmlContext *context = engine.rootContext(); + context->setContextProperty("presetModel", QVariant::fromValue(presetDataList)); + if (positionalArguments.length() == 2) { + int port = positionalArguments.takeFirst().toInt(); + QString secret = positionalArguments.takeFirst(); + QUrl bindingAddress; + bindingAddress.setScheme(QStringLiteral("ws")); + bindingAddress.setHost(QStringLiteral("localhost")); + bindingAddress.setPort(port); + bindingAddress.setPath(QStringLiteral("/api")); + QUrlQuery query; + query.addQueryItem(QStringLiteral("token"), secret); + bindingAddress.setQuery(query); + context->setContextProperty(QStringLiteral("bindingAddress"), bindingAddress); + + smw = new LibSMWrapper(port, secret); + smw->wrapper_registerCallback(onEv, onRep); + smw->subscribe(QString("newMainConnection")); + smw->subscribe(QString("mainConnectionStateChanged")); + smw->subscribe(QString("removedMainConnection")); + smw->subscribe(QString("asyncSetSourceState")); + smw->subscribe(QString("asyncConnect")); + smw->run_eventloop(); + engine.rootContext()->setContextProperty("smw",smw); + } + //qmlRegisterType("LibSMWrapper",1,0, "LibSMWrapper"); // if you would like to use not in cpp but in QML + + + + engine.load(QUrl(QStringLiteral("qrc:/Radio.qml"))); + + QObject *root = engine.rootObjects().first(); + QObject::connect(smw, SIGNAL(smEvent(QVariant, QVariant)), + root, SLOT(slotEvent(QVariant, QVariant))); + QObject::connect(smw, SIGNAL(smReply(QVariant)), + root, SLOT(slotReply(QVariant))); + + return app.exec(); +} + +static void onRep(struct json_object* reply_contents) +{ + qDebug("%s is called", __FUNCTION__); + QString str = QString(json_object_get_string(reply_contents)); + QJsonParseError error; + QJsonDocument jdoc = QJsonDocument::fromJson(str.toUtf8(), &error); + QJsonObject jobj = jdoc.object(); + + smw->emit_reply(jobj); + json_object_put(reply_contents); +} + +static void onEv(const std::string& event, struct json_object* event_contents) +{ + qDebug("%s is called", __FUNCTION__); + const QString event_name = QString(event.c_str()); + QString str = QString(json_object_get_string(event_contents)); + QJsonParseError error; + QJsonDocument jdoc = QJsonDocument::fromJson(str.toUtf8(), &error); + const QJsonObject jobj = jdoc.object(); + smw->emit_event(event_name, jobj); + + json_object_put(event_contents); +} diff --git a/sample/radio/app/radio.qrc b/sample/radio/app/radio.qrc new file mode 100644 index 0000000..38ce4f8 --- /dev/null +++ b/sample/radio/app/radio.qrc @@ -0,0 +1,6 @@ + + + Radio.qml + api/Binding.qml + + diff --git a/sample/radio/binding/binding.pri b/sample/radio/binding/binding.pri new file mode 100644 index 0000000..3448a56 --- /dev/null +++ b/sample/radio/binding/binding.pri @@ -0,0 +1,6 @@ +TEMPLATE = lib +CONFIG += plugin use_c_linker +CONFIG -= qt +QMAKE_CFLAGS += -Wextra -Wconversion -Wno-unused-parameter -Werror=maybe-uninitialized -Werror=implicit-function-declaration -ffunction-sections -fdata-sections -Wl,--as-needed -Wl,--gc-sections + +DESTDIR = $${OUT_PWD}/../package/root/lib diff --git a/sample/radio/binding/binding.pro b/sample/radio/binding/binding.pro new file mode 100644 index 0000000..d8c5a93 --- /dev/null +++ b/sample/radio/binding/binding.pro @@ -0,0 +1,11 @@ +TARGET = radio-binding + +HEADERS = radio_impl.h radio_output.h rtl_fm.h convenience/convenience.h +SOURCES = radio-binding.c radio_output.c radio_impl_rtlsdr.c rtl_fm.c convenience/convenience.c + +LIBS += -Wl,--version-script=$$PWD/export.map + +CONFIG += link_pkgconfig +PKGCONFIG += json-c afb-daemon librtlsdr glib-2.0 libpulse-simple + +include(binding.pri) diff --git a/sample/radio/binding/convenience/convenience.c b/sample/radio/binding/convenience/convenience.c new file mode 100644 index 0000000..517dc4e --- /dev/null +++ b/sample/radio/binding/convenience/convenience.c @@ -0,0 +1,304 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* a collection of user friendly tools + * todo: use strtol for more flexible int parsing + * */ + +#include +#include +#include + +#ifndef _WIN32 +#include +#else +#include +#include +#include +#define _USE_MATH_DEFINES +#endif + +#include + +#include "rtl-sdr.h" + +double atofs(char *s) +/* standard suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'g': + case 'G': + suff *= 1e3; + case 'm': + case 'M': + suff *= 1e3; + case 'k': + case 'K': + suff *= 1e3; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atoft(char *s) +/* time suffixes, returns seconds */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'h': + case 'H': + suff *= 60; + case 'm': + case 'M': + suff *= 60; + case 's': + case 'S': + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atofp(char *s) +/* percent suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case '%': + suff *= 0.01; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain) +{ + int i, r, err1, err2, count, nearest; + int* gains; + r = rtlsdr_set_tuner_gain_mode(dev, 1); + if (r < 0) { + fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); + return r; + } + count = rtlsdr_get_tuner_gains(dev, NULL); + if (count <= 0) { + return 0; + } + gains = malloc(sizeof(int) * count); + count = rtlsdr_get_tuner_gains(dev, gains); + nearest = gains[0]; + for (i=0; i= 0 && device < device_count) { + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string exact match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strcmp(s, serial) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string prefix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strncmp(s, serial, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string suffix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + offset = strlen(serial) - strlen(s); + if (offset < 0) { + continue;} + if (strncmp(s, serial+offset, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + fprintf(stderr, "No matching devices found.\n"); + return -1; +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/sample/radio/binding/convenience/convenience.h b/sample/radio/binding/convenience/convenience.h new file mode 100644 index 0000000..1faa2af --- /dev/null +++ b/sample/radio/binding/convenience/convenience.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* a collection of user friendly tools */ + +/*! + * Convert standard suffixes (k, M, G) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofs(char *s); + +/*! + * Convert time suffixes (s, m, h) to double + * + * \param s a string to be parsed + * \return seconds as double + */ + +double atoft(char *s); + +/*! + * Convert percent suffixe (%) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofp(char *s); + +/*! + * Find nearest supported gain + * + * \param dev the device handle given by rtlsdr_open() + * \param target_gain in tenths of a dB + * \return 0 on success + */ + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain); + +/*! + * Set device frequency and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param frequency in Hz + * \return 0 on success + */ + +int verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency); + +/*! + * Set device sample rate and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param samp_rate in samples/second + * \return 0 on success + */ + +int verbose_set_sample_rate(rtlsdr_dev_t *dev, uint32_t samp_rate); + +/*! + * Enable or disable the direct sampling mode and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param on 0 means disabled, 1 I-ADC input enabled, 2 Q-ADC input enabled + * \return 0 on success + */ + +int verbose_direct_sampling(rtlsdr_dev_t *dev, int on); + +/*! + * Enable offset tuning and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_offset_tuning(rtlsdr_dev_t *dev); + +/*! + * Enable auto gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_auto_gain(rtlsdr_dev_t *dev); + +/*! + * Set tuner gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param gain in tenths of a dB + * \return 0 on success + */ + +int verbose_gain_set(rtlsdr_dev_t *dev, int gain); + +/*! + * Set the frequency correction value for the device and report status on stderr. + * + * \param dev the device handle given by rtlsdr_open() + * \param ppm_error correction value in parts per million (ppm) + * \return 0 on success + */ + +int verbose_ppm_set(rtlsdr_dev_t *dev, int ppm_error); + +/*! + * Reset buffer + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_reset_buffer(rtlsdr_dev_t *dev); + +/*! + * Find the closest matching device. + * + * \param s a string to be parsed + * \return dev_index int, -1 on error + */ + +int verbose_device_search(char *s); + diff --git a/sample/radio/binding/export.map b/sample/radio/binding/export.map new file mode 100644 index 0000000..52c1b4a --- /dev/null +++ b/sample/radio/binding/export.map @@ -0,0 +1 @@ +{ global: afbBindingV1*; local: *; }; diff --git a/sample/radio/binding/radio-binding.c b/sample/radio/binding/radio-binding.c new file mode 100644 index 0000000..12ed966 --- /dev/null +++ b/sample/radio/binding/radio-binding.c @@ -0,0 +1,493 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "radio_impl.h" + +static const struct afb_binding_interface *interface; + +static struct afb_event freq_event; +static struct afb_event scan_event; + +static void freq_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(freq_event, json_object_get(jresp)); +} + +static void scan_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(scan_event, json_object_get(jresp)); +} + +/* + * Binding verb handlers + */ + +/* + * @brief Get (and optionally set) frequency + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + uint32_t frequency; + + if(value) { + char *p; + frequency = strtoul(value, &p, 10); + if(frequency && *p == '\0') { + radio_impl_set_frequency(frequency); + } else { + afb_req_fail(request, "failed", "Invalid scan direction"); + return; + } + } + ret_json = json_object_new_object(); + frequency = radio_impl_get_frequency(); + json_object_object_add(ret_json, "frequency", json_object_new_int((int32_t) frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get (and optionally set) frequency band + * + * @param struct afb_req : an afb request structure + * + */ +static void band(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_band_t band; + char band_name[4]; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_band(band); + } else { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + } + ret_json = json_object_new_object(); + band = radio_impl_get_band(); + sprintf(band_name, "%s", band == BAND_AM ? "AM" : "FM"); + json_object_object_add(ret_json, "band", json_object_new_string(band_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Check if band is supported + * + * @param struct afb_req : an afb request structure + * + */ +static void band_supported(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + json_object_object_add(ret_json, + "supported", + json_object_new_int(radio_impl_band_supported(band))); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency range for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_range(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t min_frequency; + uint32_t max_frequency; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + min_frequency = radio_impl_get_min_frequency(band); + max_frequency = radio_impl_get_max_frequency(band); + json_object_object_add(ret_json, "min", json_object_new_int((int32_t) min_frequency)); + json_object_object_add(ret_json, "max", json_object_new_int((int32_t) max_frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency step size (Hz) for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_step(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t step; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + step = radio_impl_get_frequency_step(band); + json_object_object_add(ret_json, "step", json_object_new_int((int32_t) step)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Start radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void start(struct afb_req request) +{ + radio_impl_start(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Stop radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void stop(struct afb_req request) +{ + radio_impl_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Scan for a station in the specified direction + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_start(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "direction"); + int valid = 0; + radio_scan_direction_t direction; + + if(value) { + if(!strcasecmp(value, "forward")) { + direction = SCAN_FORWARD; + valid = 1; + } else if(!strcasecmp(value, "backward")) { + direction = SCAN_BACKWARD; + valid = 1; + } else { + char *p; + direction = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(direction) { + case SCAN_FORWARD: + case SCAN_BACKWARD: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid direction"); + return; + } + radio_impl_scan_start(direction, scan_callback, NULL); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Stop station scan + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_stop(struct afb_req request) +{ + radio_impl_scan_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Get (and optionally set) stereo mode + * + * @param struct afb_req : an afb request structure + * + */ +static void stereo_mode(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_stereo_mode_t mode; + char mode_name[4]; + + if(value) { + if(!strcasecmp(value, "mono")) { + mode = MONO; + valid = 1; + } else if(!strcasecmp(value, "stereo")) { + mode = STEREO; + valid = 1; + } else { + char *p; + mode = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(mode) { + case MONO: + case STEREO: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_stereo_mode(mode); + } else { + afb_req_fail(request, "failed", "Invalid mode"); + return; + } + } + ret_json = json_object_new_object(); + mode = radio_impl_get_stereo_mode(); + sprintf(mode_name, "%s", mode == MONO ? "mono" : "stereo"); + json_object_object_add(ret_json, "mode", json_object_new_string(mode_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Subscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void subscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_subscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_subscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Unsubscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void unsubscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_unsubscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_unsubscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +static const struct afb_verb_desc_v1 verbs[]= { + { "frequency", AFB_SESSION_CHECK, frequency, "Get/Set frequency" }, + { "band", AFB_SESSION_CHECK, band, "Get/Set band" }, + { "band_supported", AFB_SESSION_CHECK, band_supported, "Check band support" }, + { "frequency_range", AFB_SESSION_CHECK, frequency_range, "Get frequency range" }, + { "frequency_step", AFB_SESSION_CHECK, frequency_step, "Get frequency step" }, + { "start", AFB_SESSION_CHECK, start, "Start radio playback" }, + { "stop", AFB_SESSION_CHECK, stop, "Stop radio playback" }, + { "scan_start", AFB_SESSION_CHECK, scan_start, "Start station scan" }, + { "scan_stop", AFB_SESSION_CHECK, scan_stop, "Stop station scan" }, + { "stereo_mode", AFB_SESSION_CHECK, stereo_mode, "Get/Set stereo_mode" }, + { "subscribe", AFB_SESSION_CHECK, subscribe, "Subscribe for an event" }, + { "unsubscribe", AFB_SESSION_CHECK, unsubscribe, "Unsubscribe for an event" }, + { NULL } +}; + +static const struct afb_binding binding_desc = { + .type = AFB_BINDING_VERSION_1, + .v1 = { + .info = "radio service", + .prefix = "radio", + .verbs = verbs + } +}; + +const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) +{ + interface = itf; + + return &binding_desc; +} + +int afbBindingV1ServiceInit(struct afb_service service) +{ + int rc; + + freq_event = afb_daemon_make_event(interface->daemon, "frequency"); + scan_event = afb_daemon_make_event(interface->daemon, "station_found"); + + rc = radio_impl_init(); + if(rc == 0) { + radio_impl_set_frequency_callback(freq_callback, NULL); + } + + return rc; +} diff --git a/sample/radio/binding/radio_impl.h b/sample/radio/binding/radio_impl.h new file mode 100644 index 0000000..79e91a4 --- /dev/null +++ b/sample/radio/binding/radio_impl.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_IMPL_H +#define _RADIO_IMPL_H + +#include + +typedef enum { + BAND_AM = 0, + BAND_FM +} radio_band_t; + +typedef enum { + SCAN_FORWARD = 0, + SCAN_BACKWARD +} radio_scan_direction_t; + +typedef void (*radio_scan_callback_t)(uint32_t frequency, void *data); + +typedef void (*radio_freq_callback_t)(uint32_t frequency, void *data); + +typedef enum { + MONO = 0, + STEREO +} radio_stereo_mode_t; + +int radio_impl_init(void); + +uint32_t radio_impl_get_frequency(void); + +void radio_impl_set_frequency(uint32_t frequency); + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data); + +radio_band_t radio_impl_get_band(void); + +void radio_impl_set_band(radio_band_t band); + +int radio_impl_band_supported(radio_band_t band); + +uint32_t radio_impl_get_min_frequency(radio_band_t band); + +uint32_t radio_impl_get_max_frequency(radio_band_t band); + +uint32_t radio_impl_get_frequency_step(radio_band_t band); + +void radio_impl_start(void); + +void radio_impl_stop(void); + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data); + +void radio_impl_scan_stop(void); + +radio_stereo_mode_t radio_impl_get_stereo_mode(void); + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode); + +#endif /* _RADIO_IMPL_H */ diff --git a/sample/radio/binding/radio_impl_rtlsdr.c b/sample/radio/binding/radio_impl_rtlsdr.c new file mode 100644 index 0000000..4364fd5 --- /dev/null +++ b/sample/radio/binding/radio_impl_rtlsdr.c @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "radio_impl.h" +#include "radio_output.h" +#include "rtl_fm.h" + +// Structure to describe FM band plans, all values in Hz. +typedef struct { + char *name; + uint32_t min; + uint32_t max; + uint32_t step; +} fm_band_plan_t; + +static fm_band_plan_t known_fm_band_plans[5] = { + { .name = "US", .min = 87900000, .max = 107900000, .step = 200000 }, + { .name = "JP", .min = 76100000, .max = 89900000, .step = 100000 }, + { .name = "EU", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-1", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-2", .min = 87900000, .max = 107900000, .step = 50000 } +}; + +static unsigned int bandplan; +static bool present; +static bool active; +static uint32_t current_frequency; + +static void rtl_output_callback(int16_t *result, int result_len, void *ctx) +{ + if(active) + radio_output_write((char*) result, result_len * 2); +} + +int radio_impl_init(void) +{ + GKeyFile* conf_file; + int conf_file_present = 0; + char *value_str; + + if(present) + return -1; + + // Load settings from configuration file if it exists + conf_file = g_key_file_new(); + if(conf_file && + g_key_file_load_from_dirs(conf_file, + "AGL.conf", + (const gchar**) g_get_system_config_dirs(), + NULL, + G_KEY_FILE_KEEP_COMMENTS, + NULL) == TRUE) { + conf_file_present = 1; + + // Set band plan if it is specified + value_str = g_key_file_get_string(conf_file, + "radio", + "fmbandplan", + NULL); + if(value_str) { + unsigned int i; + for(i = 0; + i < sizeof(known_fm_band_plans) / sizeof(fm_band_plan_t); + i++) { + if(!strcasecmp(value_str, known_fm_band_plans[i].name)) { + bandplan = i; + break; + } + } + } + } + fprintf(stderr, "Using FM Bandplan: %s\n", known_fm_band_plans[bandplan].name); + + current_frequency = radio_impl_get_min_frequency(BAND_FM); + if(rtl_fm_init(current_frequency, 200000, 48000, rtl_output_callback, NULL) < 0) { + return -1; + } + + if(conf_file_present) { + GError *error = NULL; + int n; + + // Allow over-riding scanning parameters just in case a demo + // setup needs to do so to work reliably. + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_level", + &error); + //error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && + //error->code != G_KEY_FILE_ERROR_INVALID_VALUE) { + if(!error) { + fprintf(stderr, "Scanning squelch level set to %d\n", n); + rtl_fm_scan_set_squelch_level(n); + } + + error = NULL; + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_limit", + &error); + if(!error) { + fprintf(stderr, "Scanning squelch limit set to %d\n", n); + rtl_fm_scan_set_squelch_limit(n); + } + + g_key_file_free(conf_file); + } + + present = true; + return 0; +} + +uint32_t radio_impl_get_frequency(void) +{ + return current_frequency; +} + +void radio_impl_set_frequency(uint32_t frequency) +{ + if(!present) + return; + + if(frequency < known_fm_band_plans[bandplan].min || + frequency > known_fm_band_plans[bandplan].max) + return; + + radio_impl_scan_stop(); + current_frequency = frequency; + rtl_fm_set_freq(frequency); +} + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data) +{ + rtl_fm_set_freq_callback(callback, data); +} + +radio_band_t radio_impl_get_band(void) +{ + return BAND_FM; +} + +void radio_impl_set_band(radio_band_t band) +{ + // We only support FM, so do nothing +} + +int radio_impl_band_supported(radio_band_t band) +{ + if(band == BAND_FM) + return 1; + return 0; +} + +uint32_t radio_impl_get_min_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].min; +} + +uint32_t radio_impl_get_max_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].max; +} + +uint32_t radio_impl_get_frequency_step(radio_band_t band) +{ + uint32_t ret = 0; + + switch (band) { + case BAND_AM: + ret = 1000; // 1 kHz + break; + case BAND_FM: + ret = known_fm_band_plans[bandplan].step; + break; + default: + break; + } + return ret; +} + +void radio_impl_start(void) +{ + if(!present) + return; + + if(!active) { + if(radio_output_start() != 0) + return; + + rtl_fm_start(); + active = true; + } +} + +void radio_impl_stop(void) +{ + if(!present) + return; + + if(active) { + active = false; + radio_output_stop(); + rtl_fm_stop(); + + } +} + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data) +{ + rtl_fm_scan_start(direction == SCAN_FORWARD ? 0 : 1, + callback, + data, + radio_impl_get_frequency_step(BAND_FM), + radio_impl_get_min_frequency(BAND_FM), + radio_impl_get_max_frequency(BAND_FM)); +} + +void radio_impl_scan_stop(void) +{ + rtl_fm_scan_stop(); +} + +radio_stereo_mode_t radio_impl_get_stereo_mode(void) +{ + return STEREO; +} + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode) +{ + // We only support stereo, so do nothing +} diff --git a/sample/radio/binding/radio_output.c b/sample/radio/binding/radio_output.c new file mode 100644 index 0000000..a49687b --- /dev/null +++ b/sample/radio/binding/radio_output.c @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "radio_output.h" +#include "rtl_fm.h" + +static pa_threaded_mainloop *mainloop; +static pa_context *context; +static pa_stream *stream; + +static unsigned int extra; +static int16_t extra_buf[1]; +static unsigned char *output_buf; + +static void pa_context_state_cb(pa_context *c, void *data) { + pa_operation *o; + + assert(c); + switch (pa_context_get_state(c)) { + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + case PA_CONTEXT_READY: + break; + case PA_CONTEXT_TERMINATED: + pa_threaded_mainloop_stop(mainloop); + break; + case PA_CONTEXT_FAILED: + default: + fprintf(stderr, "PA connection failed: %s\n", + pa_strerror(pa_context_errno(c))); + pa_threaded_mainloop_stop(mainloop); + break; + } + pa_threaded_mainloop_signal(mainloop, 0); +} + +int radio_output_open(void) +{ + pa_context *c; + pa_mainloop_api *mapi; + char *client; + + if(context) + return 0; + + if (!(mainloop = pa_threaded_mainloop_new())) { + fprintf(stderr, "pa_mainloop_new() failed.\n"); + return -1; + } + + pa_threaded_mainloop_set_name(mainloop, "pa_mainloop"); + mapi = pa_threaded_mainloop_get_api(mainloop); + + client = pa_xstrdup("radio"); + if (!(c = pa_context_new(mapi, client))) { + fprintf(stderr, "pa_context_new() failed.\n"); + goto exit; + } + + pa_context_set_state_callback(c, pa_context_state_cb, NULL); + if (pa_context_connect(c, NULL, 0, NULL) < 0) { + fprintf(stderr, "pa_context_connect(): %s", pa_strerror(pa_context_errno(c))); + goto exit; + } + + if (pa_threaded_mainloop_start(mainloop) < 0) { + fprintf(stderr, "pa_mainloop_run() failed.\n"); + goto exit; + } + + context = c; + + extra = 0; + output_buf = malloc(sizeof(unsigned char) * RTL_FM_MAXIMUM_BUF_LENGTH); + + return 0; + +exit: + if (c) + pa_context_unref(c); + + if (mainloop) + pa_threaded_mainloop_free(mainloop); + + pa_xfree(client); + return -1; +} + +int radio_output_start(void) +{ + int error = 0; + pa_sample_spec *spec; + + if(stream) + return 0; + + if(!context) { + error = radio_output_open(); + if(error != 0) + return error; + } + + while(pa_context_get_state(context) != PA_CONTEXT_READY) + pa_threaded_mainloop_wait(mainloop); + + spec = (pa_sample_spec*) calloc(1, sizeof(pa_sample_spec)); + spec->format = PA_SAMPLE_S16LE; + spec->rate = 24000; + spec->channels = 2; + if (!pa_sample_spec_valid(spec)) { + fprintf(stderr, "%s\n", + pa_strerror(pa_context_errno(context))); + return -1; + } + + pa_threaded_mainloop_lock(mainloop); + pa_proplist *props = pa_proplist_new(); + pa_proplist_sets(props, PA_PROP_MEDIA_ROLE, "radio"); + stream = pa_stream_new_with_proplist(context, "radio-output", spec, 0, props); + if(!stream) { + fprintf(stderr, "Error creating stream %s\n", + pa_strerror(pa_context_errno(context))); + pa_proplist_free(props); + free(spec); + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + pa_proplist_free(props); + free(spec); + + if(pa_stream_connect_playback(stream, + NULL, + NULL, + (pa_stream_flags_t) 0, + NULL, + NULL) < 0) { + fprintf(stderr, "Error connecting to PulseAudio : %s\n", + pa_strerror(pa_context_errno(context))); + pa_stream_unref(stream); + stream = NULL; + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + + pa_threaded_mainloop_unlock(mainloop); + + while(pa_stream_get_state(stream) != PA_STREAM_READY) + pa_threaded_mainloop_wait(mainloop); + + return error; +} + +void radio_output_stop(void) +{ + if(stream) { + pa_threaded_mainloop_lock(mainloop); + + pa_stream_set_state_callback(stream, 0, 0); + pa_stream_set_write_callback(stream, 0, 0); + pa_stream_set_underflow_callback(stream, 0, 0); + pa_stream_set_overflow_callback(stream, 0, 0); + pa_stream_set_latency_update_callback(stream, 0, 0); + + pa_operation *o = pa_stream_flush(stream, NULL, NULL); + if(o) + pa_operation_unref(o); + + pa_stream_disconnect(stream); + pa_stream_unref(stream); + stream = NULL; + + pa_threaded_mainloop_unlock(mainloop); + } +} + +void radio_output_suspend(int state) +{ + if(stream) { + pa_stream_cork(stream, state, NULL, NULL); + } +} + +void radio_output_close(void) +{ + radio_output_stop(); + + if(context) { + pa_context_disconnect(context); + pa_context_unref(context); + context = NULL; + } + + if(mainloop) { + pa_threaded_mainloop_stop(mainloop); + pa_threaded_mainloop_free(mainloop); + mainloop = NULL; + } + + free(output_buf); + output_buf = NULL; +} + +int radio_output_write(void *buf, int len) +{ + int rc = -EINVAL; + int error; + size_t n = len; + size_t avail; + int samples = len / 2; + void *p; + + if(!stream) { + return -1; + } + + if(!buf) { + fprintf(stderr, "Error: buf == null!\n"); + return rc; + } + + pa_threaded_mainloop_lock(mainloop); + + avail = pa_stream_writable_size(stream); + if(avail < n) { + /* + * NOTE: Definitely room for improvement here,but for now just + * check for the no space case that happens when the + * stream is corked. + */ + if(!avail) { + rc = 0; + goto exit; + } + } + + /* + * Handle the rtl_fm code giving us an odd number of samples, which + * PA does not like. This extra buffer copying approach is not + * particularly efficient, but works for now. It looks feasible to + * hack in something in the demod and output thread routines in + * rtl_fm.c to handle it there if more performance is required. + */ + p = output_buf; + if(extra) { + memcpy(output_buf, extra_buf, sizeof(int16_t)); + if((extra + samples) % 2) { + // We still have an extra sample, n remains the same, store the extra + memcpy(output_buf + sizeof(int16_t), buf, n - 2); + memcpy(extra_buf, ((unsigned char*) buf) + n - 2, sizeof(int16_t)); + } else { + // We have an even number of samples, no extra + memcpy(output_buf + sizeof(int16_t), buf, n); + n += 2; + extra = 0; + } + } else if(samples % 2) { + // We have an extra sample, store it, and decrease n + n -= 2; + memcpy(output_buf + sizeof(int16_t), buf, n); + memcpy(extra_buf, ((unsigned char*) buf) + n, sizeof(int16_t)); + extra = 1; + } else { + p = buf; + } + + if ((rc = pa_stream_write(stream, p, n, NULL, 0, PA_SEEK_RELATIVE)) < 0) { + fprintf(stderr, "Error writing %d bytes to PulseAudio : %s\n", + n, pa_strerror(pa_context_errno(context))); + } +exit: + pa_threaded_mainloop_unlock(mainloop); + + return rc; +} diff --git a/sample/radio/binding/radio_output.h b/sample/radio/binding/radio_output.h new file mode 100644 index 0000000..2192811 --- /dev/null +++ b/sample/radio/binding/radio_output.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_OUTPUT_H +#define _RADIO_OUTPUT_H + +int radio_output_open(void); + +int radio_output_start(void); + +void radio_output_stop(void); + +void radio_output_close(void); + +int radio_output_write(void *buf, int len); + +#endif /* _RADIO_OUTPUT_H */ + diff --git a/sample/radio/binding/rtl_fm.c b/sample/radio/binding/rtl_fm.c new file mode 100644 index 0000000..1c6a6b2 --- /dev/null +++ b/sample/radio/binding/rtl_fm.c @@ -0,0 +1,1267 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2012 by Steve Markgraf + * Copyright (C) 2012 by Hoernchen + * Copyright (C) 2012 by Kyle Keen + * Copyright (C) 2013 by Elias Oenal + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* + * Note that this version replaces the standalone main() with separate + * init/start/stop API calls to allow building into another application. + * Other than removing the separate controller thread and adding an output + * function callback, other changes have been kept to a minimum to + * potentially allow using other rtl_fm features by modifying rtl_fm_init. + * + * December 2016, Scott Murray + */ + +/* + * written because people could not do real time + * FM demod on Atom hardware with GNU radio + * based on rtl_sdr.c and rtl_tcp.c + * + * lots of locks, but that is okay + * (no many-to-many locks) + * + * todo: + * sanity checks + * scale squelch to other input parameters + * test all the demodulations + * pad output on hop + * frequency ranges could be stored better + * scaled AM demod amplification + * auto-hop after time limit + * peak detector to tune onto stronger signals + * fifo for active hop frequency + * clips + * noise squelch + * merge stereo patch + * merge soft agc patch + * merge udp patch + * testmode to detect overruns + * watchdog to reset bad dongle + * fix oversampling + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rtl-sdr.h" +#include "rtl_fm.h" +#include "convenience/convenience.h" + +#define DEFAULT_SAMPLE_RATE 24000 +#define DEFAULT_BUF_LENGTH RTL_FM_DEFAULT_BUF_LENGTH +#define MAXIMUM_OVERSAMPLE RTL_FM_MAXIMUM_OVERSAMPLE +#define MAXIMUM_BUF_LENGTH RTL_FM_MAXIMUM_BUF_LENGTH +#define AUTO_GAIN -100 +#define BUFFER_DUMP 4096 + +#define FREQUENCIES_LIMIT 1000 + +#define DEFAULT_SQUELCH_LEVEL 140 +#define DEFAULT_CONSEQ_SQUELCH 10 + +static volatile int do_exit = 0; +static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1}; +static int ACTUAL_BUF_LENGTH; + +static int *atan_lut = NULL; +static int atan_lut_size = 131072; /* 512 KB */ +static int atan_lut_coef = 8; + +struct dongle_state +{ + int exit_flag; + pthread_t thread; + rtlsdr_dev_t *dev; + int dev_index; + uint32_t freq; + uint32_t rate; + int gain; + uint16_t buf16[MAXIMUM_BUF_LENGTH]; + uint32_t buf_len; + int ppm_error; + int offset_tuning; + int direct_sampling; + int mute; + struct demod_state *demod_target; +}; + +struct demod_state +{ + int exit_flag; + pthread_t thread; + int16_t lowpassed[MAXIMUM_BUF_LENGTH]; + int lp_len; + int16_t lp_i_hist[10][6]; + int16_t lp_q_hist[10][6]; + int16_t result[MAXIMUM_BUF_LENGTH]; + int16_t droop_i_hist[9]; + int16_t droop_q_hist[9]; + int result_len; + int rate_in; + int rate_out; + int rate_out2; + int now_r, now_j; + int pre_r, pre_j; + int prev_index; + int downsample; /* min 1, max 256 */ + int post_downsample; + int output_scale; + int squelch_level, conseq_squelch, squelch_hits, terminate_on_squelch; + int downsample_passes; + int comp_fir_size; + int custom_atan; + int deemph, deemph_a; + int now_lpr; + int prev_lpr_index; + int dc_block, dc_avg; + void (*mode_demod)(struct demod_state*); + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; + struct output_state *output_target; +}; + +struct output_state +{ + int exit_flag; + pthread_t thread; + rtl_fm_output_fn_t output_fn; + void *output_fn_data; + int16_t result[MAXIMUM_BUF_LENGTH]; + int result_len; + int rate; + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; +}; + +struct controller_state +{ + int exit_flag; + pthread_t thread; + uint32_t freqs[FREQUENCIES_LIMIT]; + int freq_len; + int freq_now; + int edge; + int wb_mode; + pthread_cond_t hop; + pthread_mutex_t hop_m; + + void (*freq_callback)(uint32_t, void*); + void *freq_callback_data; + + int scanning; + int scan_direction; + void (*scan_callback)(uint32_t, void*); + void *scan_callback_data; + uint32_t scan_step; + uint32_t scan_min; + uint32_t scan_max; + int scan_squelch_level; + int scan_squelch_count; +}; + +// multiple of these, eventually +struct dongle_state dongle; +struct demod_state demod; +struct output_state output; +struct controller_state controller; + +#if 0 +static void sighandler(int signum) +{ + fprintf(stderr, "Signal caught, exiting!\n"); + do_exit = 1; + rtlsdr_cancel_async(dongle.dev); +} +#endif + +/* more cond dumbness */ +#define safe_cond_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m) +#define safe_cond_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m) + +/* {length, coef, coef, coef} and scaled by 2^15 + for now, only length 9, optimal way to get +85% bandwidth */ +#define CIC_TABLE_MAX 10 +int cic_9_tables[][10] = { + {0,}, + {9, -156, -97, 2798, -15489, 61019, -15489, 2798, -97, -156}, + {9, -128, -568, 5593, -24125, 74126, -24125, 5593, -568, -128}, + {9, -129, -639, 6187, -26281, 77511, -26281, 6187, -639, -129}, + {9, -122, -612, 6082, -26353, 77818, -26353, 6082, -612, -122}, + {9, -120, -602, 6015, -26269, 77757, -26269, 6015, -602, -120}, + {9, -120, -582, 5951, -26128, 77542, -26128, 5951, -582, -120}, + {9, -119, -580, 5931, -26094, 77505, -26094, 5931, -580, -119}, + {9, -119, -578, 5921, -26077, 77484, -26077, 5921, -578, -119}, + {9, -119, -577, 5917, -26067, 77473, -26067, 5917, -577, -119}, + {9, -199, -362, 5303, -25505, 77489, -25505, 5303, -362, -199}, +}; + +void rotate_90(unsigned char *buf, uint32_t len) +/* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j + or [0, 1, -3, 2, -4, -5, 7, -6] */ +{ + uint32_t i; + unsigned char tmp; + for (i=0; ilp_len) { + d->now_r += d->lowpassed[i]; + d->now_j += d->lowpassed[i+1]; + i += 2; + d->prev_index++; + if (d->prev_index < d->downsample) { + continue; + } + d->lowpassed[i2] = d->now_r; // * d->output_scale; + d->lowpassed[i2+1] = d->now_j; // * d->output_scale; + d->prev_index = 0; + d->now_r = 0; + d->now_j = 0; + i2 += 2; + } + d->lp_len = i2; +} + +int low_pass_simple(int16_t *signal2, int len, int step) +// no wrap around, length must be multiple of step +{ + int i, i2, sum; + for(i=0; i < len; i+=step) { + sum = 0; + for(i2=0; i2rate_out; + int slow = s->rate_out2; + while (i < s->result_len) { + s->now_lpr += s->result[i]; + i++; + s->prev_lpr_index += slow; + if (s->prev_lpr_index < fast) { + continue; + } + s->result[i2] = (int16_t)(s->now_lpr / (fast/slow)); + s->prev_lpr_index -= fast; + s->now_lpr = 0; + i2 += 1; + } + s->result_len = i2; +} + +void fifth_order(int16_t *data, int length, int16_t *hist) +/* for half of interleaved data */ +{ + int i; + int16_t a, b, c, d, e, f; + a = hist[1]; + b = hist[2]; + c = hist[3]; + d = hist[4]; + e = hist[5]; + f = data[0]; + /* a downsample should improve resolution, so don't fully shift */ + data[0] = (a + (b+e)*5 + (c+d)*10 + f) >> 4; + for (i=4; i> 4; + } + /* archive */ + hist[0] = a; + hist[1] = b; + hist[2] = c; + hist[3] = d; + hist[4] = e; + hist[5] = f; +} + +void generic_fir(int16_t *data, int length, int *fir, int16_t *hist) +/* Okay, not at all generic. Assumes length 9, fix that eventually. */ +{ + int d, temp, sum; + for (d=0; d> 15 ; + hist[0] = hist[1]; + hist[1] = hist[2]; + hist[2] = hist[3]; + hist[3] = hist[4]; + hist[4] = hist[5]; + hist[5] = hist[6]; + hist[6] = hist[7]; + hist[7] = hist[8]; + hist[8] = temp; + } +} + +/* define our own complex math ops + because ARMv5 has no hardware float */ + +void multiply(int ar, int aj, int br, int bj, int *cr, int *cj) +{ + *cr = ar*br - aj*bj; + *cj = aj*br + ar*bj; +} + +int polar_discriminant(int ar, int aj, int br, int bj) +{ + int cr, cj; + double angle; + multiply(ar, aj, br, -bj, &cr, &cj); + angle = atan2((double)cj, (double)cr); + return (int)(angle / 3.14159 * (1<<14)); +} + +int fast_atan2(int y, int x) +/* pre scaled for int16 */ +{ + int yabs, angle; + int pi4=(1<<12), pi34=3*(1<<12); // note pi = 1<<14 + if (x==0 && y==0) { + return 0; + } + yabs = y; + if (yabs < 0) { + yabs = -yabs; + } + if (x >= 0) { + angle = pi4 - pi4 * (x-yabs) / (x+yabs); + } else { + angle = pi34 - pi4 * (x+yabs) / (yabs-x); + } + if (y < 0) { + return -angle; + } + return angle; +} + +int polar_disc_fast(int ar, int aj, int br, int bj) +{ + int cr, cj; + multiply(ar, aj, br, -bj, &cr, &cj); + return fast_atan2(cj, cr); +} + +int atan_lut_init(void) +{ + int i = 0; + + atan_lut = malloc(atan_lut_size * sizeof(int)); + + for (i = 0; i < atan_lut_size; i++) { + atan_lut[i] = (int) (atan((double) i / (1< 0) + {return 1 << 13;} + if (cr == 0 && cj < 0) + {return -(1 << 13);} + if (cj == 0 && cr > 0) + {return 0;} + if (cj == 0 && cr < 0) + {return 1 << 14;} + } + + /* real range -32768 - 32768 use 64x range -> absolute maximum: 2097152 */ + x = (cj << atan_lut_coef) / cr; + x_abs = abs(x); + + if (x_abs >= atan_lut_size) { + /* we can use linear range, but it is not necessary */ + return (cj > 0) ? 1<<13 : -1<<13; + } + + if (x > 0) { + return (cj > 0) ? atan_lut[x] : atan_lut[x] - (1<<14); + } else { + return (cj > 0) ? (1<<14) - atan_lut[-x] : -atan_lut[-x]; + } + + return 0; +} + +void fm_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + pcm = polar_discriminant(lp[0], lp[1], + fm->pre_r, fm->pre_j); + fm->result[0] = (int16_t)pcm; + for (i = 2; i < (fm->lp_len-1); i += 2) { + switch (fm->custom_atan) { + case 0: + pcm = polar_discriminant(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 1: + pcm = polar_disc_fast(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 2: + pcm = polar_disc_lut(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + } + fm->result[i/2] = (int16_t)pcm; + } + fm->pre_r = lp[fm->lp_len - 2]; + fm->pre_j = lp[fm->lp_len - 1]; + fm->result_len = fm->lp_len/2; +} + +void am_demod(struct demod_state *fm) +// todo, fix this extreme laziness +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + // hypot uses floats but won't overflow + //r[i/2] = (int16_t)hypot(lp[i], lp[i+1]); + pcm = lp[i] * lp[i]; + pcm += lp[i+1] * lp[i+1]; + r[i/2] = (int16_t)sqrt(pcm) * fm->output_scale; + } + fm->result_len = fm->lp_len/2; + // lowpass? (3khz) highpass? (dc) +} + +void usb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] + lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void lsb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] - lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void raw_demod(struct demod_state *fm) +{ + int i; + for (i = 0; i < fm->lp_len; i++) { + fm->result[i] = (int16_t)fm->lowpassed[i]; + } + fm->result_len = fm->lp_len; +} + +void deemph_filter(struct demod_state *fm) +{ + static int avg; // cheating... + int i, d; + // de-emph IIR + // avg = avg * (1 - alpha) + sample * alpha; + for (i = 0; i < fm->result_len; i++) { + d = fm->result[i] - avg; + if (d > 0) { + avg += (d + fm->deemph_a/2) / fm->deemph_a; + } else { + avg += (d - fm->deemph_a/2) / fm->deemph_a; + } + fm->result[i] = (int16_t)avg; + } +} + +void dc_block_filter(struct demod_state *fm) +{ + int i, avg; + int64_t sum = 0; + for (i=0; i < fm->result_len; i++) { + sum += fm->result[i]; + } + avg = sum / fm->result_len; + avg = (avg + fm->dc_avg * 9) / 10; + for (i=0; i < fm->result_len; i++) { + fm->result[i] -= avg; + } + fm->dc_avg = avg; +} + +int mad(int16_t *samples, int len, int step) +/* mean average deviation */ +{ + int i=0, sum=0, ave=0; + if (len == 0) + {return 0;} + for (i=0; i len2) { + tick -= len2; + i++; + } + if (i >= len1) { + i = len1 - 1; + tick = len2; + } + } +} + +void arbitrary_downsample(int16_t *buf1, int16_t *buf2, int len1, int len2) +/* fractional boxcar lowpass, len1 > len2 */ +{ + int i = 1; + int j = 0; + int tick = 0; + double remainder = 0; + double frac; // use integers... + buf2[0] = 0; + while (j < len2) { + frac = 1.0; + if ((tick + len2) > len1) { + frac = (double)(len1 - tick) / (double)len2;} + buf2[j] += (int16_t)((double)buf1[i] * frac + remainder); + remainder = (double)buf1[i] * (1.0-frac); + tick += len2; + i++; + if (tick > len1) { + j++; + buf2[j] = 0; + tick -= len1; + } + if (i >= len1) { + i = len1 - 1; + tick = len1; + } + } + for (j=0; jdownsample_passes; + if (ds_p) { + for (i=0; i < ds_p; i++) { + fifth_order(d->lowpassed, (d->lp_len >> i), d->lp_i_hist[i]); + fifth_order(d->lowpassed+1, (d->lp_len >> i) - 1, d->lp_q_hist[i]); + } + d->lp_len = d->lp_len >> ds_p; + /* droop compensation */ + if (d->comp_fir_size == 9 && ds_p <= CIC_TABLE_MAX) { + generic_fir(d->lowpassed, d->lp_len, + cic_9_tables[ds_p], d->droop_i_hist); + generic_fir(d->lowpassed+1, d->lp_len-1, + cic_9_tables[ds_p], d->droop_q_hist); + } + } else { + low_pass(d); + } + /* power squelch */ + if (d->squelch_level) { + sr = rms(d->lowpassed, d->lp_len, 1); + if (sr < d->squelch_level) { + d->squelch_hits++; + for (i=0; i< d->lp_len; i++) { + d->lowpassed[i] = 0; + } + } else { + d->squelch_hits = 0; + } + } + d->mode_demod(d); /* lowpassed -> result */ + if (d->mode_demod == &raw_demod) { + return; + } + /* todo, fm noise squelch */ + // use nicer filter here too? + if (d->post_downsample > 1) { + d->result_len = low_pass_simple(d->result, d->result_len, d->post_downsample);} + if (d->deemph) { + deemph_filter(d);} + if (d->dc_block) { + dc_block_filter(d);} + if (d->rate_out2 > 0) { + low_pass_real(d); + //arbitrary_resample(d->result, d->result, d->result_len, d->result_len * d->rate_out2 / d->rate_out); + } +} + +static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx) +{ + int i; + struct dongle_state *s = ctx; + struct demod_state *d = s->demod_target; + + if (do_exit) { + return;} + if (!ctx) { + return;} + if (s->mute) { + for (i=0; imute; i++) { + buf[i] = 127;} + s->mute = 0; + } + if (!s->offset_tuning) { + rotate_90(buf, len);} + for (i=0; i<(int)len; i++) { + s->buf16[i] = (int16_t)buf[i] - 127;} + pthread_rwlock_wrlock(&d->rw); + memcpy(d->lowpassed, s->buf16, 2*len); + d->lp_len = len; + pthread_rwlock_unlock(&d->rw); + safe_cond_signal(&d->ready, &d->ready_m); +} + +static void *dongle_thread_fn(void *arg) +{ + struct dongle_state *s = arg; + fprintf(stderr, "dongle_thread_fn running\n"); + rtlsdr_read_async(s->dev, rtlsdr_callback, s, 0, s->buf_len); + fprintf(stderr, "dongle_thread_fn exited!\n"); + return 0; +} + +static void rtl_fm_scan_callback(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = rtl_fm_get_freq(); + + if(!s->scanning) + return; + + if(!s->scan_direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); +} + +static void rtl_fm_scan_end_callback(void) +{ + struct controller_state *s = &controller; + + if(!s->scanning) + return; + + rtl_fm_scan_stop(); + + if(s->scan_callback) + s->scan_callback(rtl_fm_get_freq(), s->scan_callback_data); +} + +static void *demod_thread_fn(void *arg) +{ + struct demod_state *d = arg; + struct output_state *o = d->output_target; + fprintf(stderr, "demod_thread_fn running\n"); + while (!do_exit) { + safe_cond_wait(&d->ready, &d->ready_m); + pthread_rwlock_wrlock(&d->rw); + full_demod(d); + pthread_rwlock_unlock(&d->rw); + if (d->exit_flag) { + do_exit = 1; + } + if (d->squelch_level) { + if(d->squelch_hits > d->conseq_squelch) { + d->squelch_hits = d->conseq_squelch + 1; /* hair trigger */ + //safe_cond_signal(&controller.hop, &controller.hop_m); + rtl_fm_scan_callback(); + continue; + } else if(!d->squelch_hits) { + rtl_fm_scan_end_callback(); + } + } + pthread_rwlock_wrlock(&o->rw); + memcpy(o->result, d->result, 2*d->result_len); + o->result_len = d->result_len; + pthread_rwlock_unlock(&o->rw); + safe_cond_signal(&o->ready, &o->ready_m); + } + fprintf(stderr, "demod_thread_fn exited!\n"); + return 0; +} + +static void *output_thread_fn(void *arg) +{ + struct output_state *s = arg; + fprintf(stderr, "output_thread_fn running\n"); + while (!do_exit) { + // use timedwait and pad out under runs + safe_cond_wait(&s->ready, &s->ready_m); + pthread_rwlock_rdlock(&s->rw); + if(s->output_fn) { + s->output_fn(s->result, s->result_len, s->output_fn_data); + } + pthread_rwlock_unlock(&s->rw); + } + fprintf(stderr, "output_thread_fn exited!\n"); + return 0; +} + +static void optimal_settings(int freq, int rate) +{ + // giant ball of hacks + // seems unable to do a single pass, 2:1 + int capture_freq, capture_rate; + struct dongle_state *d = &dongle; + struct demod_state *dm = &demod; + struct controller_state *cs = &controller; + dm->downsample = (1000000 / dm->rate_in) + 1; + if (dm->downsample_passes) { + dm->downsample_passes = (int)log2(dm->downsample) + 1; + dm->downsample = 1 << dm->downsample_passes; + } + capture_freq = freq; + capture_rate = dm->downsample * dm->rate_in; + if (!d->offset_tuning) { + capture_freq = freq + capture_rate/4;} + capture_freq += cs->edge * dm->rate_in / 2; + dm->output_scale = (1<<15) / (128 * dm->downsample); + if (dm->output_scale < 1) { + dm->output_scale = 1;} + if (dm->mode_demod == &fm_demod) { + dm->output_scale = 1;} + d->freq = (uint32_t)capture_freq; + d->rate = (uint32_t)capture_rate; +} + + +void frequency_range(struct controller_state *s, char *arg) +{ + char *start, *stop, *step; + int i; + start = arg; + stop = strchr(start, ':') + 1; + stop[-1] = '\0'; + step = strchr(stop, ':') + 1; + step[-1] = '\0'; + for(i=(int)atofs(start); i<=(int)atofs(stop); i+=(int)atofs(step)) + { + s->freqs[s->freq_len] = (uint32_t)i; + s->freq_len++; + if (s->freq_len >= FREQUENCIES_LIMIT) { + break;} + } + stop[-1] = ':'; + step[-1] = ':'; +} + +void dongle_init(struct dongle_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->gain = AUTO_GAIN; // tenths of a dB + s->mute = 0; + s->direct_sampling = 0; + s->offset_tuning = 0; + s->demod_target = &demod; +} + +void demod_init(struct demod_state *s) +{ + s->rate_in = DEFAULT_SAMPLE_RATE; + s->rate_out = DEFAULT_SAMPLE_RATE; + s->squelch_level = 0; + s->conseq_squelch = DEFAULT_CONSEQ_SQUELCH; + s->terminate_on_squelch = 0; + s->squelch_hits = DEFAULT_CONSEQ_SQUELCH + 1; + s->downsample_passes = 0; + s->comp_fir_size = 0; + s->prev_index = 0; + s->post_downsample = 1; // once this works, default = 4 + s->custom_atan = 0; + s->deemph = 0; + s->rate_out2 = -1; // flag for disabled + s->mode_demod = &fm_demod; + s->pre_j = s->pre_r = s->now_r = s->now_j = 0; + s->prev_lpr_index = 0; + s->deemph_a = 0; + s->now_lpr = 0; + s->dc_block = 0; + s->dc_avg = 0; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); + s->output_target = &output; +} + +void demod_cleanup(struct demod_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void output_init(struct output_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->output_fn = NULL; + s->output_fn_data = NULL; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); +} + +void output_cleanup(struct output_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void controller_init(struct controller_state *s) +{ + s->freqs[0] = 100000000; + s->freq_len = 0; + s->edge = 0; + s->wb_mode = 0; + pthread_cond_init(&s->hop, NULL); + pthread_mutex_init(&s->hop_m, NULL); +} + +void controller_cleanup(struct controller_state *s) +{ + pthread_cond_destroy(&s->hop); + pthread_mutex_destroy(&s->hop_m); +} + +void sanity_checks(void) +{ + if (controller.freq_len == 0) { + fprintf(stderr, "Please specify a frequency.\n"); + exit(1); + } + + if (controller.freq_len >= FREQUENCIES_LIMIT) { + fprintf(stderr, "Too many channels, maximum %i.\n", FREQUENCIES_LIMIT); + exit(1); + } + + if (controller.freq_len > 1 && demod.squelch_level == 0) { + fprintf(stderr, "Please specify a squelch level. Required for scanning multiple frequencies.\n"); + exit(1); + } + +} + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data) +{ + int r = 0; + + dongle_init(&dongle); + demod_init(&demod); + output_init(&output); + controller_init(&controller); + + /* + * Simulate the effects of command line arguments: + * + * -W wbfm -s -r + */ + + /* Set initial frequency */ + controller.freqs[0] = freq; + controller.freq_len++; + + /* Set mode to wbfm */ + controller.wb_mode = 1; + demod.mode_demod = &fm_demod; + demod.rate_in = 170000; + demod.rate_out = 170000; + demod.rate_out2 = 32000; + demod.custom_atan = 1; + //demod.post_downsample = 4; + demod.deemph = 1; + controller.scan_squelch_count = DEFAULT_CONSEQ_SQUELCH; + controller.scan_squelch_level = DEFAULT_SQUELCH_LEVEL; + demod.squelch_level = 0; + + /* Adjust frequency for wb mode */ + controller.freqs[0] += 16000; + + /* Set sample rate */ + demod.rate_in = sample_rate; + demod.rate_out = sample_rate; + + /* Set resample rate */ + output.rate = (int) resample_rate; + demod.rate_out2 = (int) resample_rate; + + /* Set output function pointer */ + if(output_fn) { + output.output_fn = output_fn; + output.output_fn_data = output_fn_data; + } + + /* quadruple sample_rate to limit to Δθ to ±π/2 */ + demod.rate_in *= demod.post_downsample; + + if (!output.rate) { + output.rate = demod.rate_out; + } + + sanity_checks(); + + if (controller.freq_len > 1) { + demod.terminate_on_squelch = 0; + } + + ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH; + + dongle.dev_index = verbose_device_search("0"); + if (dongle.dev_index < 0) { + return -1; + } + + r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); + if (r < 0) { + fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dongle.dev_index); + return r; + } + + if (demod.deemph) { + demod.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(demod.rate_out * 75e-6))))); + } + + /* Set the tuner gain */ + if (dongle.gain == AUTO_GAIN) { + verbose_auto_gain(dongle.dev); + } else { + dongle.gain = nearest_gain(dongle.dev, dongle.gain); + verbose_gain_set(dongle.dev, dongle.gain); + } + + verbose_ppm_set(dongle.dev, dongle.ppm_error); + + //r = rtlsdr_set_testmode(dongle.dev, 1); + + return r; +} + +void rtl_fm_start(void) +{ + struct controller_state *s = &controller; + + /* + * A bunch of the following is pulled from the controller_thread_fn, + * which has been removed. + */ + + /* Reset endpoint before we start reading from it (mandatory) */ + verbose_reset_buffer(dongle.dev); + + /* set up primary channel */ + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.direct_sampling) { + verbose_direct_sampling(dongle.dev, 1);} + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev);} + + /* Set the frequency */ + verbose_set_frequency(dongle.dev, dongle.freq); + fprintf(stderr, "Oversampling input by: %ix.\n", demod.downsample); + fprintf(stderr, "Oversampling output by: %ix.\n", demod.post_downsample); + fprintf(stderr, "Buffer size: %0.2fms\n", + 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate); + + /* Set the sample rate */ + verbose_set_sample_rate(dongle.dev, dongle.rate); + fprintf(stderr, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample); + usleep(100000); + + rtl_fm_scan_stop(); + + do_exit = 0; + pthread_create(&output.thread, NULL, output_thread_fn, (void *)(&output)); + pthread_create(&demod.thread, NULL, demod_thread_fn, (void *)(&demod)); + pthread_create(&dongle.thread, NULL, dongle_thread_fn, (void *)(&dongle)); +} + +void rtl_fm_set_freq(uint32_t freq) +{ + struct controller_state *s = &controller; + + if(s->freqs[0] == freq) + return; + + s->freqs[0] = freq; + s->freq_len = 1; + + if (s->wb_mode) { + s->freqs[0] += 16000; + } + + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev); + } + rtlsdr_set_center_freq(dongle.dev, dongle.freq); + + // It does not look like refreshing the sample rate is desirable + // (e.g. the scanning code in the removed controller thread function + // did not do it), and behavior seemed a bit less robust with it + // present. However, I am leaving this here as a reminder to revisit + // via some more testing. + //rtlsdr_set_sample_rate(dongle.dev, dongle.rate); + + // This triggers a mute during the frequency change + dongle.mute = BUFFER_DUMP; + + if(s->freq_callback) + s->freq_callback(freq, s->freq_callback_data); +} + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data) +{ + struct controller_state *s = &controller; + + s->freq_callback = callback; + s->freq_callback_data = data; +} + +uint32_t rtl_fm_get_freq(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = s->freqs[0]; + + if (s->wb_mode) + frequency -= 16000; + + return frequency; +} + +void rtl_fm_stop(void) +{ + rtl_fm_scan_stop(); + + rtlsdr_cancel_async(dongle.dev); + do_exit = 1; + pthread_join(dongle.thread, NULL); + safe_cond_signal(&demod.ready, &demod.ready_m); + pthread_join(demod.thread, NULL); + safe_cond_signal(&output.ready, &output.ready_m); + pthread_join(output.thread, NULL); +} + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + uint32_t frequency = rtl_fm_get_freq(); + + if(s->scanning && s->scan_direction == direction) + return; + + s->scanning = 1; + s->scan_direction = direction; + s->scan_callback = callback; + s->scan_callback_data = data; + s->scan_step = step; + s->scan_min = min; + s->scan_max = max; + + /* Start scan by stepping in the desired direction */ + if(!direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); + + dm->conseq_squelch = s->scan_squelch_count; + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = s->scan_squelch_level; +} + +void rtl_fm_scan_stop(void) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + + s->scanning = 0; + + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = 0; +} + +void rtl_fm_scan_set_squelch_level(int level) +{ + struct controller_state *s = &controller; + + s->scan_squelch_level = level; +} + +void rtl_fm_scan_set_squelch_limit(int count) +{ + struct controller_state *s = &controller; + + s->scan_squelch_count = count; +} + +void rtl_fm_cleanup(void) +{ + //dongle_cleanup(&dongle); + demod_cleanup(&demod); + output_cleanup(&output); + controller_cleanup(&controller); + + rtlsdr_close(dongle.dev); +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/sample/radio/binding/rtl_fm.h b/sample/radio/binding/rtl_fm.h new file mode 100644 index 0000000..f5b2a86 --- /dev/null +++ b/sample/radio/binding/rtl_fm.h @@ -0,0 +1,70 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef RTL_FM_H +#define RTL_FM_H + +#include + +#define RTL_FM_DEFAULT_BUF_LENGTH (1 * 16384) +#define RTL_FM_MAXIMUM_OVERSAMPLE 16 +#define RTL_FM_MAXIMUM_BUF_LENGTH (RTL_FM_MAXIMUM_OVERSAMPLE * RTL_FM_DEFAULT_BUF_LENGTH) + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*rtl_fm_output_fn_t)(int16_t *result, int result_len, void *data); + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data); + +void rtl_fm_start(void); + +void rtl_fm_set_freq(uint32_t freq); + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data); + +uint32_t rtl_fm_get_freq(void); + +void rtl_fm_stop(void); + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max); + +void rtl_fm_scan_stop(void); + +void rtl_fm_scan_set_squelch_level(int level); + +void rtl_fm_scan_set_squelch_limit(int count); + +void rtl_fm_cleanup(void); + +#ifdef __cplusplus +} +#endif + +#endif /* RTL_FM_H */ diff --git a/sample/radio/compose_dummy.sh b/sample/radio/compose_dummy.sh new file mode 100755 index 0000000..a571a1a --- /dev/null +++ b/sample/radio/compose_dummy.sh @@ -0,0 +1,19 @@ +#/bin/sh +if test -d dummy;then + rm -rf dummy +fi +mkdir dummy +target=`pwd`/dummy + +cd image/usr/AGL/apps +unzip radio.wgt +cp -r bin lib ${target} +rm -rf bin lib + +cd ${target}/../git +cp package_media/config_media.xml ${target} +cp package/icon.svg ${target} + +cd ${target} +mv config_media.xml config.xml +zip -q -r radio_media.wgt . diff --git a/sample/radio/package/config.xml b/sample/radio/package/config.xml new file mode 100644 index 0000000..ac5a238 --- /dev/null +++ b/sample/radio/package/config.xml @@ -0,0 +1,19 @@ + + + Radio + + + This is a demo Radio application + Qt + APL 2.0 + + + + + + + + + + + diff --git a/sample/radio/package/icon.svg b/sample/radio/package/icon.svg new file mode 100644 index 0000000..b49b495 --- /dev/null +++ b/sample/radio/package/icon.svg @@ -0,0 +1,14329 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + eJzsveluHcmVLvoE8Q77/mjAddDazIiMHMK30cCe2KcOPMFl93HfxoFAS6wqHkuiWqLsdj/9/b4V +Q8aQm6RKNchuMsApdw6RMazxW2v9w//zm6+e7V7e/vH6Wb/tNuof/uHw7vrq7vbdzzdydPPlq1cf +3t+946Gf/faLjZ62HU7afTk/Dyf+6/W79ze3b36+MXrbyYeXvPpnu9dXb15ebQ63316/+WLzsy/w +we9u7l5d46P/+csvn+/evv3F1Yc3L769fvf8t1cvb26ff/nm6sXdzZ+vt+///M0XsSO48/HqDheZ +To/PtH5m7Gb4eT9tfvNLnnL15s9X79/f/BdO0GM/9zi2v/3w5uXNm2/2t/+JqzbPTO/QtX5jLD78 +nze/vX5fnrHth24Yp27AD9wc589bN099Z8d5GnCp2Y7W2d44yx8b08vHxg3a9b2dcNfj7YsPr6/f +3P3m3e2L6/fvD7evbt+9//nm8NerN5tfXn2DT642/3b96tXtXzb7V1cv/pRdcnn75g6n/vb2j7d3 +t89+e/3Nh1dX77LPf3V9/fL65Zmzdl8Ozy9vXl1jwF9f3W10z+HffanN8/2Hm1cvf/Xh9R+vMRXG +9DzcP5eO/f49eoTO8W8enp5/+RpHvrq+u8OY4Cmcwt/+yz5/GRyU9rN/x7NvZDlgYv7PF+G2727f +vr569ydc+2ww2wFjOE745X/yiD/vd9ev377CZMq4644fPvO/8n/CuXgtOe+Znjt+Zscev3o38MZT +F89bhv76zzfXf/n55le3b679yOze3X3lV4a1Xed/+k9+++HV9bvfv7nhmBoecn5ofnn78voVzk/X +X766khGRppef/oTfXb375voOC+r21Yc72QJzfAKG/hdXf73mKtCjzMn0fI+he4MHvblDf5/ffP38 +z37nPP/m7ud68k91z3/99vrN727/Vd7lmZ70dnbD2A1Gu8lurLXbedZuGFxnTDduuu04jrjWmnkz +W/wxSyfHje1Tr/XyM/Rk9+ru+t0bzETszY/36NObl88Dxbh+mT9+kMfz4XHgxvA1hd9Ylr/BQv31 +uxuM48+faeew3Lrer+F/eXfzclnCk9nM/odM1xbzwi+tnekc9vAjjzj5mkY9zHjNxxzxA4llc4f3 +CisJ2/Hwy2x7ddtffoV3wUgcbl9z7b4n1eLiwJZ7dfuN/yz9LZ/g8g9v1b+r3l38x4fbu+v3uNer +640bL755d/Xn640288Xu5c31O3zy/mL3Dh9fHF5cv7x59erq4nT14sPd9cWv7kATri9+HU9TF79P +V1z5U67kbhdXL27eYVt9/er6Py+ulnP89Vdy8xfx5tdypbq49pdeZ5dep0tv/O1v/Dk32Tk36Zw3 +cnt1cevPvfXn3mbn3qZzb31XPvhTP/hTPyynqosP6dyXV998c/3u4iU6eH198QLjffEey/8V3+L9 +9Qtu3Is/fnj16vru4u3VO47A228vcAXZ1x9fYZTeCcnD3V5evLh9+1csv2/vLkACX16T6F34PqTH +bd/c3r28/vpid7r49ftXV++/VenQW3DS1zdvPiwnxd9/vX5z8fpDfVg158Xft+9efn2NW928uebf +r6/ev/jwiv/EE65wPDz9Pz5cv+dLvrz9y5uL6/988erqtfyJ1XXz4uoVLkhXfQ0aePOm7cY34Cav +rl/fgnt/fbf850cCfO3mLd/8/durF9cXOz8Zu7DYwq/TxS3XCASC999eXL+WX7KQMcRy0/iPv6f8 +txz3B1/e/PmGCyQNWhrzf0t/ff3uys/o6cO7W+mp7JTUb/lPbqcuvr7BC4flgSdfvMVzbl9ygchc +L/vsj1fvr1MH5R+cevft7Yf3WCLqYpct0VP2986vjFPq3MkPzZf++Jf5cv0ynfSlP+nX/qRfZ/eL +7/1rf8bv/Rm/z2/ze//RS84UxKKL7Go/Ea+vXrzjege3lNOuXsiG8Fva72h18e2HN99cvfvw+tXV +hzvsQ1DqP128uMJ16ncnIdXD/3r+u/dguwu37T13O715cUvJ6ueb56WsUosu/35RnXBRne85yO/+ +P39z0MN4683v3n24/t1f316rf9ejDtsaYml/geG5/o8PV6/wz3hx8+ZrbI+7v2abjkMiJ4BmQrLE +ePMfpWfNvYe9f3dz9erlzddfX+DdXouEc/H23e3LDy9AGW5wxzvSONx+dhe/fn39zdVGgR1egBBw +H23AJS+u3uKC/wy9cPPF8foVRD+jbVi82HT/df3mm2sIox1PfoXl/Pyrv77+4+2r5xf+d/HmQxAa +MMy/wRyRg6hfvVUifv/m1Qd89C/vbj+8/fLN17fqZ15e/wXIwMZ/tpEPIXvLMbzfX27f/Qn/fvny ++moRG7dXN2+/uPeWX/3p+u7Ft/VNw9Hvftt/BfEFvfmv65ebX//x/+If3oOiKKYYHOjNN/g/nfPw +7Y7XX+PBoZe41B89vfnz9avbt9fLcX/ew/f7zaurN1iI8XXj6ILZ/uYKU7HckCde3/3h4TtCLHiX +dUT+jb8f0R8IRW+vRUOqp+LBE7KPHvGgq7tvoaeAWL9P9/b/Ln3nOPhjD9/vcAUOIWz15sVm/+7D ++283v7u9fZXuvfJ5ek7+mXzEKx+xYl9QAHu39rTyo/SgcPgze8Zv5II3v37j56R9UjihfhJUF3/N +Z/qsdM3ac/Dh38ozPMm+ef96mfrsyG/IUl68uv7qrxAfH0NxwgBDYgDRO7PJ7z3nq79cgSb/4uaP +925LviS440us0K8+3NxdLzvx9vVb2kY2X3179fZa3iCe+VW64SA6XMaRnj1TZrN/k/GrfyFPhFzx +883PfnX9l038d+O7t6EUvTFfqPs+BAvETV9C5fknNfehmaLprJX/6bnzbbqUdkI7pnZQ0wFtX7RD +avtpl5qTNqcWv8ayKfxYDg7SbNZ6NBOaTq3zbbys2mk8Kf4Yj9IOaPtxr/5ZdRiLgz2Yg95f7k/7 +w363d/sZvR/2dt/vzb7bXe5Ou8Nuv9vtZvR/3Nldv9Pu0h3dwe2gp85udIOzrnd6vpxP80HN+3k3 +z3i5cbYyjJ0MFkdhlpdi97V06yg9ceMMZXwY+9GMeuyG03AcDsN+cMOM9x7VMAz9YAZtL+0J7WD3 +dmdnDMNoB9tbSD79ZX/qj/2h3/UO0zr2tu9703fm0pzMwezNzjgM1WgGY41RRptOX+qTxntrvI2e +w1jgkb7tirYv2qFox6KdyqaGy7yNXdF00UzR+qLZ2JT8GopWf5UraS6aKxqmU/FHaHvfMBb/pC4f +/jp9TFMrB4+f0hR+HD6x7fOmyn/lEEdiusS+Jz3osZwHDOKExe2wxPfzYT5ixV+6zmlnsAMsls6I +/U0Tzs7tsUOO7uQud91O7wz2jcViGhW20bxz2FB7bKwjttflvttrbLYem27ABEzYgg5bcY8NecS2 +vDx0B41N2mOrDti802E+uMPusD8cDsfDSR0uj91RH82xP1oswhEkaT664+64Px6Ox+PpeHnqTvpk +Tj22zwA6MJ3mkzvtTvvT4XQ8nU6Xl92lvjSX/aXlKlWgcHirS3QMg4SrLy8xEnbzD8/30LNUt7Wm +wwp10yDjIVa6beeMBQ0YsOu6fvDHrHZjN82216BWw4AjLv5jXYcPNxo0WW/GzdBtdNfxCV+pf3j+ +Az5h/x79Bylx0zjOnSFF8nfiXumGbhyNc3iMHOv9PeIDaPrbWjd3vTN6wG4ytObHu2e9/4Huj77v +j4lhRja3ziV//+bN1WvoQd9EZjgNYI9rRwu+qIUP+pXu17pvc1jzXPV7Wfl+7WP1x4Zd0MlOiA07 +QmFT+GZTG1aaLX7b4rfNf6vsRo9p8fEmtaV/0luV/bPSltdr2qn6LzS1/Fm0Y9MOK23fHlNy+GPb +7nxTxb/uTLv/a8qbKv/9xIZ1r+bx+21/wzcUHtRptO/xS32fN3u64dMN//vd0EvJJ4hIDiqWhTZx +giy1h1w1Q76ykLY6SKl7SGETJDIL6UxD5DxBZNtDdJshxI0Q53qIdV3QvfZ7pyD3DUH50kH5OkJK +dEH5GiBCGihfpzX1S7gVGc2ifw0KnLwXFewSKtgpKKNRDaNOSf3Ra4xeGaMi4BUyqmRWlBGvoHRe +ozmK2rMXxch5zXTgl4WSRjXNDBBzRFWL6hoVNqps5MjoT1JmBqpvChocdThjNVoHXe4kulxsB2kY +D+h2bF5xpwJMzWjq5am93KSXLwXFzzfNBhXwUtTAsh1D24e2k7b8tROVUZoS3TG2XEsbsmards+X +Cr9126CVnm+n1YZPVHbS8ZPawTcV//i+2o93w6DJyyZwcRvILjBhH9AY4feBCzthEJOEt6R0mWEi +7gXI8kpUbRtsFNwMl2KnOGZ7YZa9MBa7QafdcLKgAsteUGEzTGkr2HIn9Jdi1TilXRD3gBMbx7IH +wg5QYQOkld93YgCJq9+v94OYQ5Z17te4t3/lCxxdV2lVxx1VLtuObWVxVmtJ72NTepfaIofnVrbM +llUaR/RQNOubin/ovmmru+vMVxebWv5cWnf5yHZqm1o7+EA73tfU/R9/fPvxbigcU4xmoxgxpqDg +ODFm0JyxF5PGQcwaR/BKtkuxbnRi4dBi5TBi6aCtA00Fy5s3bUaLrNewnLSdtH1ocudj/DpJCyYl +P/pKbCW+RW7Rp2ZDW0x8Y2hTaovS59iU/3XaZW2ftUPWjkUrv5LZTPHHyvprOYZZaX3blBh+zrXh +3tbYmtlUc2j66FZo1+q8Gv4dGgQoxR/fZ/sbvqHsS6wADVJvwYcmcKYdGNURc9+BD/RgZyOYmxPb +90nM2DRQD2JrdmI4PmILXIJqGzClgb4LBda6Ey/IsTCglubTjzCeKm89DcbT2nyaG1AXE2o0ogYz +ajCkelNqr8SaOiRS5IJNdZ+Rn8tgWtUF0RkSrYlURiiMSgQmkpZEVDJqslCRhX7kdCMjFqqiESVV +CNSg2f5rWz3sZVVs53P7c2W7ZG2XNxX+aCznYjk+3+616id6/EktfD3GkfFRXz/eDUubO/UqSEVQ +LCBo9pPYj3UH6VTP1k4a0p71VvKhyyzIPS3i02inbphnA4HUWbGId96mPJotdKjO2R5XQcjKTNg/ +yuO8Nb4bIJhb3NjpfrS8acc/LSVnEAWCYh1OnyGOQq5zk6CBtxCZ80fTxJ6s/mJRxxGT90SbYEzX +4xYawQTRHCInhOnCdP8ZdOZBO3+N3jL6rLf88kogbl/96a9fqPyfxeqPrrp51NA4oK3owU040rsB +OhEUH7wEFCNoVGhbyNk6m1xxpBSTzXuVs5+v4Ooxm+YxHqhWP2bTPGbTPGZZYoUX6Ud7oqzjH/Zp +rZfpR3rex3idfv3u6s031/8YQlOw4qoDuN0QfU3dkLXoE4//0xA0rLRx9dhI0IPiHyLLNG7T6DRN +LtOgT5jCX1p7S5O/VJE5y53Flre0ISkf/Gmb1hfNZJ/466C9UIURC/8PYbeUOxcqxQ== + + + YaXtV9pupblMn5E7e8tIZhaJRhFvEgnwDTGGiCFEzCDHgN9wCcFhxeqBhaxo8PDS6GG17R/ZdnVT +8iPxUwy37cQ8IgvNhv9s0ZaFWP5t1xap9DqItw6i7TEItlGspVAbRFoItEQCeEnWS7FehvXyq5dd +RW6NSy5fdFHDHZtji7bL35RM45n+7/D/D7PaxBgepc1c3SwV0txYUspr+VdYrHLTZNQ+PGDRW7fn +ldY8iC9B2Sna6Ww7nm3FwixWlreL9c26WvvL/xePLc3fQf5S6U+/XJeT5HL/PlM/Q3TYo18nHNPY +UF6Rm7HR9thyJ8j9WlQ5i+1IVAVBTUfoAFpUOVuocpdq6jB2PUZxxIg6jGyuxvlnBvhMlOVL6f5U +HaOTZIKa4dUO/uz9akhOk0kFPWgEzeXYa9zhGMw1O1m2NOuuPG3ROBbFJFdYFkUmV3IyS8WiEeVm +D28ZEZMVXTVDcNbo4K45isMmwuXGBJhbvDaEzOV+mx5arN517lIF980+OHCm5MIhOsHvpe4ADnWC +UtdprY3uwcNp9xwhks/a6Z3eQ4890vqPpaKNMb2xZhDL7WRm48SXcYDSeoIa2PWaTpG+h9wtPhO/ +XHZYMAcumf6yWMAB+UCwYwQUhpb/Pa7y4qEgjn6FVnS1prM5BT7XTN5U+e+5VhM6mnJ7odh8Eb6e +63bdXmyLJ3xowjhbGeUJo7yXUeY4X8o4d951Q0v4EAabRnMnwx3dR95A6ZV9r4XHt4hmdJu1QQXz +fWzTevOsYMZOOGB3adkhEcm1YLkWE0E0DeQmgT4z52VmuilT/+fwPQXFf15T+s/r/DWE7oz6H/fy ++a/vpPK3EMNPAhiWxoj7TgvMj8yuC6zsKHLVTrzBs1C1QWw+PZYFbUGdXHkSS9FB7EaecUe2PapM +qPTCoxE7lCxXGUUvvXkK6b/2oe1Cc1mbVQUrmtab5yf7AKSdxL3kwbTiURJf0jH4kHbiOZoCsHYQ +R5F3EEXHkHcGibNun9w+0dGzOHYWD07up6ndL5mHpPYxHNZbaUHpoLHPBBBSzaGK7rrJmamD7DoP +1PTnXk9DD2qsHZ3Yovt32LliEegnUetdhi3sCO3bmgJvSAifMVNmDpjOQBw/j+6I5trp2UEn7Cyu +Gw1tFSA50zyjc2MPzsNnz5iinmICaNQ4O9+b0XYUeDWuFsMIDRuLbkk04wLORId4JJg/wllu6c08 +b3EsG5/PqFNhlDBbI0bTQeexU9CjwTjAl8GEaQlCh6zBjHEfdHbwKE83FD3gdYWyrc/ahmgyG7cz +FkE+LD9hL/w4dBAVOzy7wzRYrlSjIUD2WL/zDPFSCwp3HJ3t3ITFilXne5BQrbIcOaE51NXKCj/X +AzNvOyhR2Tj8lL3w49CPzBDCIH3dzX6UZzuK1tsNk5t767M7rIy9yTdpN4cnmDm37/xA9/8Ye85X +H94ypOf26zufZmTzrzffvLm+u7v+Qt3zGZ7VJ9sidAb0Qxuo+sxm0G0xaz1fq3eT0VDIcMRy5Wpm +SIF+ohVJ36ihTKPvWNzOcrBzGjbS0lhNEo/kBledbI+fRSdWxmLTdGPTdGPTdGPTdGNlwTbdiObK +ERcbtxmmLc0umS3xs+uaN6n+tN3a4gYGFGHc9Ho7j12/mdx2mvTnM3Dne/hZjJ8b1qzyn1GnPimk +Qq9FVGgauW00covtYBQ/sw0WBBNwUV2wJJwya4JvTtocLAvetmC9fUEJkKoTI4M3MxwlOm8v5oad +eMZnMTpMYngYJYDNSuvFBCFGCJohxApxVEFB2Is5Yudzz4hRYpIYMYnLEKUAV3a4xsNO+YGHnJ7E +LpeC/QRnusfVk1jhaIE7hSA/2oqJJw0Bfgo9m4dRkHI6mIZ3gg5lUJ8WIChNvktAnw7hfF7voM7R +SyQf4/h2elbQKQbRIbRoCwe+plgxBjEvmGSpfNCeSbC9kZ/UQIx8G7EfmGR66xdbhpIn0B4yi4WE +xoWdmBf8T//XPv3cp58HMUDEn0mdUeW/3kYRfp74clSLghpt90U73NNWXBSpJWiTWv5M7T540H1W +INHu1KBXWwGf9Q6FUQIWvR3yEEAlXYCVWA8sCQZJjyw53R+cp1YAJvfG5j0UmqceE5vnfVCd7FQj +1y64FG/dj9iUBZ1yFDJwKVqrR6j4WyaIigpwuRylEnEqESKnQxDgOkolouA8QOWkMnyKzpApOSZl +zu2C3owQLARiFMJGLLZT+080QfvZnXziLa5bkvws8q1fHiPWDdoyvI8J8zH6iOMYCBP2Z7WR/eOg +/IJ6QAz2D0woJX8rmVBOaYWsmA3JBnFOfdd5Obsj+zHkLiN2vI/g61vFoQw1pAqfR+/Ni+Lg5i3Y +z5jhDH7Eh3pRYIYqiH+HAefKnUBUu3kee3rgRquDt7jUlsln7aaZrkwzNFCwC4Hoh31O8LR3hKLw +F3iFSBCmn8ehGyeHu8kRrImpx3roSZUn7Y/ouYcqRSO5Fi2ptgPYQhPU93ZIb8nlcnf859MpGSVa +2TqC0EEUB3nYOExkpPMEQXEa5elmwMTg5py2OZiYaJMSgxxNB1uzSFSYL6rHfbMEx7LPa2iFz6I3 +nybudavyXlcIfAHUvhMrp//Lhb9bkHsJeJ8Sa4yWUasHVSLeV+DuJnyfh70X4HdVY94XC+sK3L1E +pkfD6j7IMtJUEHNcOlSF0BbNO5TmxpU0JnjHqFZ8ScMZZ1F0tvrv4qUWt4/qVoMnPSOT0F8J5j2m +wNk5eJlHiYLuY26QLO/HPqXxmETS7SWSCjtYyYudQjjVQSQZJ4GcgfsJWKJPAVWXKYZkiSKZJa9D +iCJRIahKi7h1CggKH0YSI0hiDIkNMSQ+jsq7tsvIEbyMCoEj9Db1i2U/2PZPKSpqlyJDpmDdH5J9 +Xwf7Pj2QIRRnHyz8c1rXY1qusvjSevLmei8JL57GuASCxzBOrg7SeAIZ0EtrQrTdIXhY6F3pQ8Td +KXhUvD9lEjcKXSgaj/XRdy6PvlMh9ckxeXPHIv7uWCQ/GZIX92wEng/XXnAKAaUQkqAcAkphDAiF +LiAUPD5hTjpSTINyHPYqQWl8VFEJpSGQZsoCiPJkKN6LM0mQXPDh0A+oggNncd9E14133Jwkdmcf +5tLTIU9aMIlpBvdhq+PFlEydDUqWKeYr7NC1uJr19sDX33DE6Od+Q+9jLoJhMvS6bqJiysiYPDom +w7erKkymDpaZqjwJLmu7tZgZ9VFhMyUkfDVaRjWhMiU86Hw0zJkQF9Vg6M/i5+/xl1d+6DVo+z/7 +TFa2yNbhM3W4kKmjyNMRsnOYoA37JBtjCLrwaYd3SixBh6Aen6THnYTsGVGTvaI8iGlpElNTDMbY +i9P5KJN1uQRlqHs14H2hAV8mDdjrv33Sf7MgDRWCxdb033NRGilGIwvPSMqvCrlx+rBqk/abFuGC +rTiFbDldWDR9QlXEJTD7SJs4uYcUyuDna4HkFIicCo8jIC4TYFyjaNFOoFyHAObqIpxLSXDOJOE5 +OwnQOYYQnYjsGj7OqqIeNqt8XM4j9RjDysfkPFJ+0o/fW84jJdN3T86jf1KCsUpBr1ng6ymEvh5F +FvJhrzH4dZ+EIoyVtwqtCxmnYMN1GKYHRIyYdmABuESKkMNe9gkFx33v6VOEuMlvz5tbDNcaGMvU +AKwKY1UGZFbRmGUc5r4IkUpBUou15r7l+qAJ0G+wmM0vy/mTxfTvUsS/b4eshdjSfN4DIiwqZV5p +i4qdb/sMJ3YI6+CUEGOd4PPQPLWOeyfuHO6bXcIFayGwQ4YM9lsl3yhhm/h1MGXsZc5mfDm+y1b0 +qUJYZVirJcvMemvnvkChVmh9D8NPkKdeRAWBPSXgUwt9ysBPNfbJj91jIvnP4n5zpLpfJ/kq2J1p +7kwrskYW1sSsUEEW+FSb/+4/y6MLnDPToJ3VHXHlgteY5r53Y9cNYy94IMZQUf/sO5w2TWIwIRSk +A9MwA4EK3XZuvGRDgxnSbWzL1gYAjNlyw2WohM+rXzJWUF+JhrCmG2ctQKGeC6QDzSBREdTH0JkB +2xjcspcjHej5PGJTgwWPgqOZCxTQuGpayo2xXe/uMQd+Rn3y62kaGLeHPjgGB3G8JZMeLsTdsMdl +3kA29QiGM4/QB71JzhJe06OrrhNsUZWfjqGCNcBKFx1atwd+Jv35NIugXbUIWiJgkkUwaFc6BAUM +CYDsAgA5uvcWsHcfQMhzxl4S2FsVeO8p8LqI917Ey0XAXEDfUcyMgqaImkqMNF7a9PIm2yzpenbB +b5icgMFvx0ACK6LnKElPRAEJmVIPKiVGPYmF6zJkO415TWMK05isdA7sPuYgPQjbPwZl8dLHI3TB +SGpEbO1FGrAhM65Pdeq/fBY5l7WdyApLQl5wGCVGvEUJzaOfK4NllQYY7ZwLueaY0V1cuIqDLTMZ +O2P8mgrw+jl9z8mC2rqRvev4EH5G7/Bl8A5finc4dEQLtF3LyjLBQEx7zhAEGxtszWMScBYxZwpv +LKhdFSTZfSX1xN+HkPYly0sUZSD81rksJCtY0vDqlFcmZplZciktzuE831KehylnwyFR05rMd04S +LNr5WY3fOsECarlIZ5JylIrkWyVxOp/85ffQ2czEvYQzLgtjDOTC/zWpZC6fU2zGslZdWDRzZnx3 +K39ni0sVK81l62z5ndv34xkus/QX1v/cHbDvSpfArmgunbWvPtmFo/vlhudO2J+5PPYmhRqcJGxo +L0LyHIKR7D2o/YjZzxH7ybasAlh/MS/3gs/vAi7/GNK87ZKxeYkgijFEMYpIkD8qQH4WwE8fwon0 +CtYn4nymYJQeAr4nQ/eoCPCp0D1zhe2JSVJjatSY8zSmLI1pSfcqyxa6ZACNPpJBrFC2yKqe5U1P +5DUS3ESD8yzpS9tVzZUt2FKC8hIDwvZhdl0K9opqr01hiSEIMYUcxphYiXlVIcjVh2xMwn6GTItZ +12OiJrPoMkmbUVmw5lCoNEtAh04BHW1IRx7O4bztKw/eGBO2LOLLbAhIjCptQpoFtNllWHcRdXZU +opHHyJH4taugaBGOFls+V2PWwPxVkSvdrrYzUbvLrF5elhE8dahfGeZXh/eNhcFjUGVIXxaf2sSl +rkSjtoHTe7USJb0YrRdT9iJf5KbvPD18sJSrbIUt6yy20vheZgqrQ5FCZ1Uyhrdfh5W2P9N2sanl +z6K5h1tpRyuMirOESq8ZFCNQKwVNB5NitEBH67NTwfCc5wHqk61kLLIA0fTXNWbFmPonJP7JjYsL +mmpI1uS5siSH7GHBMdIXZmQPoQqpA4LlyduZfFigERmdUjr9c6NE/zHmyomzNkrpSU4Pkb1BTFci +pU9BSvdhvkFOl6SDRuIJKaUvEvouCOaX6F0Xsjj1QRSfGc7v5W++6qVIFyYJ2ZNQXu74I8l4SBRu +Q8j7JGxhLxzjUvhIz+TfwcyYgx+95Lqwd//zkH4eKkgkpVuvIkVJ96AyUOTyM/7lLw== + + + WB60Kx60S51xCx6zlDByycYFF2f83/81JVTDFCR1L7sn2U2FhADfh7Ou8ND9LdzQF014RCj+o5NH +9INRj8kfEfAO68GLeejijrrCnAqCBNd3iFdMNUEy57d3fV9mrm8XQAsRWqzjm4vYtia4HQqI9j2i +Wym5qUZwW8Q2L7QtIlsU2PZBVoty2pgkNMhmKgESLoMJ9Rikr10wpM6hIs0QZq8PZWZiaZlTqCKz +9ylS1eidG8mGO2diTy74rIo+Z4Wfg2rlnzPiTyv6ZILPIvQoL/MkgScXdnIhZxFrcimmDyJ5nF3M +r8qhpP+kgofJNSnbjtEXnXkOc99h6U5OAdmlfd9lTuP8O7qO62jseGYUlXZ0TK7Kxx4INYg7Ygpc +l4vu6DmvkMXo/R3EPTHJGuYXVzXXN9Y517sEJ3B8eiVcOHp9BxlSDq1LPDkioHcyFfw+yvdBsmGf +ZM4uybP9t+JUhu94EH97QjsEQjx3PqQ/4tli6oRoS+PmPoJTd2J58CY02g44qzScBaOZEn4c3bIH +by1LTtnaJUt23wWW6xlu45FV6y7ZdS5xv/Nlcbvk6Y9iNgNGPVfJI+IYjKKQ+VFYEkdYsanMIp4c +IcF4z7QNwghf/qhE+vDJIfnWklFkKBDYbVfP+YfyXBJTmrXMHlFq91F5ibEQUfTNAIvymjqZuExC +Q6YcwSWuUuxb3uXoKmzeGLI8e4xeTH3eCW+6FJn9mPKfR7yeR+xNvlJVhO0tydB1SgGdJ4GOaaCX +pOhTBuNKmaBVSopeJIMOEQbCXE4JohYjf6p0IyI835NvJObXUQ+m2DmXNPsMZ1frrP0+dxnN8n2/ +JSwx8xXce1JIITjajtPPiFnJ2qfHwWBWDINnjQSZMUJn6CB1W0yoB9zbxgc15cBqicqfqwSHSyyw +22Kh5SkTf8JOyCg4ZoMbO8cZNk5cITM6YrANHemZBM1p592X2hAmvYZAZ5+KjHH9eci53joIV5vR +bvE+mffrp++KH5FRvEfYTB0oLp1M09DPzO0yTZwCJw/oLKmxNSMTDtDFppldgbWaMH0et189ss0Y +gKuqIOyyW0UE5OfVrU9zgY2rLrCRoPi+cIEZYQJTZNHCnK0wpZ13bzG/DnbJKCl19sGTRXY8Ztmt +SA+typJbeeZrAuP1TPeQpbYag3PpkMGechTJATp9t9glxsIuEa0SNsGccpDTqQkeo1wkBgnVgJxq +i8ROZJ0l7ivHvNkiQ7rAntTZiK+IelvSCrbom12Dvkk2ohLv2eY8X8t2vgreVAV20zUpBQ/3QDbX +8p2f1BqGczXz+blW5UNXj0yR/lArEqd/r+3v8IaLlJgn4JrF/uKTb12K6NaLhEbP404IgpdRtTBO +ClJzkNMPAmEX2bIX/3b0ay/WsssKOunJxGWRA29MWfBEg2RZm1OS0Icit/k+0A4tBrFeBJ8x+Jh3 +ooqKAznVzhMsrhIpKlrFDgJt7kJKyD4Bb+dk5dwX2lapb4nGpULBNq90HSRrJGS/ICd7hdSrqF5p +9db5aL2P9vxo6Q/a8Cmpj7Fah0lJDfPI4TG1PFmUK9pOpcRTS4Bq/lUanVN1h9X84ELYVG4lyKrU +mEe3KsZZ3RcA/WAb2qbWDn5K+zu84ZqOG6N4TaXdRtf5WjbWxVuOn22MWJ4heOxKfMWUHcm10MzN +rrKPc5+8rf6q0xCXN/Z9lTdRSR8ukQNd9d/67+XKLv5VhtIYn84A47SEzZjsb12M9nr8W6G7t+aH ++0wSqy0HkK7BhcvTVzI7NvDiVcTpx7R7b+jbejbKR2aoVN+pV/e0v8MbLhiMY0gEK+lfIcuF1K8S +vRfzve4gso4+Yg+cgKZgXy1vCLXyYqjerEKZcrPXCULvLeve/OGNH97wEc0eudGjTils1YPmjtrg +kZs8ojsjOjTMqFWyG5EORpuRyyqFjYWx6EFTkcpsRXndsMxiFKqH6bBiKYGVyYzzTNo+L3YoKRbL +isXSYrG82FJibCm0l4rtpYpjoamqDFexEhpJui7Klxfmi2D8rG7Z+bZ/ZCPO6zwE7KNagpSpFXz4 +J7W/wxtGYIePTJmlYGYkAT6IdxI4hA/h9WTAhcKZMXTXkwK6gEZPDJQAqTyIKiZiztMwl5ZR2kVL +q2hpEwV5UJVZNE88vtCJaBntMz/aKRCMQ+lFU4JLrd1oOrnRIg1JrrTCID0VBmkxSauAhAxW6UBf +LoN2fgx0JtqnvYV6l8psB6RWqNkp9EelUPNot47kqE8W7NiWzD15wFAZH9lkD6ql6LW0RGdgQj5r +lbK71fb4IuBz2VR94KPa1Da1dvBT2t/hDRe8Xo7CrHGYEYkZMXll/uSIxjQRgKcCxOmQBfzPAZUZ +I4gWf3OeN/kYEJr75FoWt7JqvMr9Ssq2CKFbXMlnHcnqjC+59CZHf7JOcNbotl0QZsGEpxYVewHp +7fIvl7W80HuJqBxjU+GPoWpre66tqxFTymVNZf/oB9t55G5qqgDnfA+V8NTKwdOnNPVpl/+3uOHi +9etC09KyPFxuYLKrmYEd88j0V8z5CG48jR2+Q85HrUcJWzZ6dNqXINNjns95LYPSmPvThmHjY4JW +UlP+dF3Yv1c+M9a40f3GJrdieTCetZ2mKqCqPvxpTp151akzP8U1PcU1PcU1PcU1PcU1PcU1PcU1 +PcU1PcU1PcU1PcU1PcU1PcU1PcU1fcrX38QNn+KanuKa/hvHNbmQgjOvMnkKKMs8pimvMLkUksxz +XR6UiD4JeXpPHchHft1XSvI73pA93K05KLw0tR4yJRA+We5c9jYw9FlgwS4kyDylQCktWD0boqOm +vVNFQFSABsc4J5n8PpQzzwHCO2H0s7D6/PtA0LDH3Xmk3UmYvyzM8Jf/7kUg8EJB/K88ZoLQQERe +WNWlMH+Qb8KUUzRWrIKyF74lBpxUypbNIz33EfotphSTGf84hAcvKaqAAx8ECb5gPZdEmTne00mE +UojLylNlSuVjictSC/AzJMxcUmYuEVqjGPBK813IR5iQ5F6MmFSQI1wwyR1FmkgFk+ezNd7vy7W3 +2FxssqyNyZw208aRgWirWsGjVLB1+RAn+6pH2PvhZchbH6LdnPLxXtQlQhHpUeCztJRS+urFMurt +oSeRs6yMkqDrg1hFZCxRsSd0ETR5ANndBenJivTLdIcx2eEjxYlHoc/WcGj3osvOtu8EeXo8jCyr +iXy2cM56eFpEF50LTWsD0xaY0cBcsUVQWoUzWgLS1pPKmyoW7cjAwEOQS3YBPhRBQ0OCCK2ll4/l +Y30G8qyErBID6ZkqspRglsi3ywzfURfaXkN5nIt9g3yhHiwv/5HRbyoJgI8QAR8jAaq+zOneCIF/ +L0F1/bB1w08cUxf68BOH1M3DFhNtPoeQutgVPyI9g4BxO2aolJK76I9GF7RUXjW+Ii12GtYv1j74 +Yqjn18/gMDOmzEezdZVDFDPbFbVdeGQu8l/eG1L3WXXr07yvbtX76r6QjRq8rwnYsZgvl+LeUV8K +Wksw3MVk9IVXxIWCNSqlhjeub5pN6eJjG7M2hZ+xiUKngl43p7Z8eWq8AFW8GX8vokHWWuEgx7ev +8fdzDHlMfqdBpfIzkxg8XOGvKYPOD1kJBF0EmccA8yFW6FmK+LjUIqxnCVxZuhq/hB17bYLawz6M +hZOxGwKv6r0LQ2ZRnBZgU2OoLkI25VVesigXGBQYjPIFRkSzPQpnmkSAEJYU6s7shRmxBqNJVRgP +WRXG3mpwnqOvwqikDGMswujLME6+CKOUgjkwflWqvhipE3IUg8KcjAm+aBvdVsGZPU/L15hahCdG +6FifNPUIn9Rx9oJF/KQSlvIYpPR9QlTuwiqdK1yll6YybGUmVRG5XYhWObayRlYumMoxq9vjJf7k +xFi0+aX1VcsRzTpr2XJURYqPU+7xSO3QuD3ucXyoyu9R+DwqV8fi0ihgaz45ty85sSvKThxT2Ymu +KjuRF53YhYoTizUcSotKYbV58YAsJ3pVQGCthEBRREAVVQR8/YiPLCNQVQ20EGkhIXK546cwVq59 +bFMwBSipegqiSM4/pIJfnuXakv0OReLrVBF52oKO2Txp8o/5UOH2IySHru/HAdutF5apoWd3mEsz +OzPEEnY4rYfCj01A0YpR500O5rGp9zdXR3jWtALK+gn78El83KzWBza6CI3PvPFr9atociTl6cUO +oxOENTriczd8n0DxobLwsbAFcptNApEfKrtfQp4mzOlxgZiqDFeaI0kX2OgCDc1xJxm+s0RZqmAF +jpbg6MePvvylCvFSiTh69sfg3y/w3So5+6PD3yS3f966upVFegI44ER98JRwAmU7rLb9Q03Nu09t +np34omWsWMYgKBfinzqJftqFUqlGop72MnqTDAxf9JCKNAt4ARothAXlJQWwVy1Cwj5UIRuFJ3ox +4VLY3i4Vax6CCYE6Kw0H3mgwe5FBidIqQUhiJTiK42In8oOPLvLGgRg1FIOCTkmkWKrOUWMZlQhI +vRR61plJ4DKZBGKZlaXq4hyQXrH2HCW1gBnrLpU4xGM2oRZn01YtrGsUVqVSFihU3daNSw/at74H +31Ws5uHDG33SjX3AYhrByI0inh7ELNgnTFrIAiXd1yG43meB2vcnlXy1Riyt85ILKthZbYqsn0Ia +jn1IxbGYVoeEjXRKwJFHH11Piyq+exH4onN2TJjHiHUMoMYEYDSh/pVUwFIiElPOc5k8sihJiypU +KESZSqRzlcgZldShXP0Zm7YoPgvZyvWd9KUyBahth6atAQ9KFekRSIUHWpDJZbp9OaqIqnUZqjbh +arNVYBavfYDXcuYCwFaJ736f6o6nQuKpMLjJfPlWxOaIuvVefT/cu4C+3atkrj8GmfwyYXC7kNnL +JCxuHwR7G8T8MaFyIzJXgAFxCneZnX+x9R+CTrGAdgNwN6XqS4okCY5KSqApWl+1NjxmWGnopsrU +orI9/mvOmyr//fgWsExnEmmcKz12rvhYquik0jaPRZ2Wsk4RVxPLkMVCZPtFxyg0DEHaqJCuJ+7J +XUjbc4hpNlYL2+Wl7ZbidqJ5REDOIUCEQpW7BM6Jxd5NkKtsSn44hDXlFawoEjhV5OWIX4vyFtW5 +RcnLCwVmOmHUE1XK4FG3WtFs83ustlJ7/Q4tLJZKOKxCf1aDcFpatyiuO5WRzFxQXFqOqRwLwTFv +ZwTIWoz8DsKkqiXKqrWC5f0CpuTme6SsmYoY3y9O3vux+/imvstFeSvxdMGDfQz6edTO56CZe73c +F/cb4yKLddMOkhVHh0w4xMrtZD9digPdHsbHOB0LeHxgkWewOatuGe/AW0cBrTqB/FtcpmC/Glgz +B50raVw/qjliq/sVzfzHfKh3PrBgFm/l+g6jJzcaZovNixE2dvI14+3kIL2aecI0+Q4YSZ9XVBNj +V5e6UXaITjDTbyczz3zs4lz4UR8rb0rjqAXNwnWQ1sV40c9O4yEGC63rR++/25qisg== + + + lTzQ1cFoY3UOz8KvuiLXj/fITzKr9MOaWQVHcWNTBafl6tXyd77Hq8+XbRs3bfTaxgLcJnhrva92 +TtQACu9Sm9N/eaD3qcE4nRL0+xg+P17uY0RHWxd4rSZwUw7Yk4/76qzeU2VVLo6FSkOE1BQip4YQ +UdWHGCsfc9UJbFACs0o6hNGkVwWrZjCdJKk0EN5oihh7KOCOW93NIBLYNfSljDTfbaRAXr2GupxC +aLs4aKdx24HQZrXkfsSHcnfKkp+gL3d04EyjeGOdGw2WzQSBdXDe0VqUprM8aaycznQvFh7HLLVr +D9oBgrE47H/Eh37SDl2timcL92XaefcFj94XOpoFjhLVpDLk2BI0ulZp+aFayz5CFOprKLW8kjVw +yRv4EbWWVVW/1pX1ax+TCdx7OON37uMcQlrFLPCSTWVhl2UYXIxi897OJVb3GJB6XUiurXWXRVha +FZyeNoVWTmFWYl3cOURS7kOy9boirg6xkkZCJI2SyEgboiGHFPbrxBD4qODFPPn44hHWDTwrBauq +Bq1Vp3orU7uFEMX0M0YppghFVYQhllGHc6UmlFj8+F1+tldFsGLC8ydc/0cE/50P/SudDc5HdcWw +vyXor/Y0xHA/XTgZYv6dGOMnGXhUAdIqIVrn0vCspiaP2KwHagCvB8/tiuC5JXQuBs+VoXNF4BxV +UZWFzeVBc1keklTQOA+Wq8sZL8WMH5WNZEpunaFKQ9Il32/w9qrMwTNnsZbBzfO44LP7Qs+qwDOO +nWrCzoqQsyrgrAw2K6PMgsavquCyMqjMFpFkZQRZGTOWAsRUERVWxn1hzT0EmCtE43Of/2QwuVIL ++4k68GkywqpzFEc/SkrwjKtFPs8B+VzICMaqQkbYxSTjS92PrOjHvm/wRzr1JE92EGtvVEkvkvSi +A/MMvVOhg3MlyhxDUgGd+WNGM69nT104Xhmcv56p1MfZL1kYJDh+YTj79L1EnCVJgN/fF78puM1x +Uh/HbcoUUnUvHgp6PxP2ripf+1rYewxzQK8e4jDngrPL0OyFv0jv1Bn+sgRkF8HY3x/lMv0AbZ8x +ldb0VoAV+M8ZbHWIxJP2+pBj6W0ItgZLp/dZZqqSAjQdlIhIUo780HCGdP1kPfg02mVWaZehBWJJ +jxNdwDEH6j+p4NF0Ivd7jT2lSZYo3LjREpsVVivgwAgKFPlIDoV8nwGUnxtP/UNjvOI4Ddmj5BGs +QJHrvXwAAzM8vN779aobmsapnbu573N8912es9jEeIolJ69A+im6ROExT95YZ3T18iJlxSgpxmyu +e0iIHuHQQ50KsiElw7Brl0QKU6AZY7ZLF/rlM1LukiwSt2QnFOwkuLCQKiOlmvvho2L9O5wtbbBa +yaDNxl9la1RZ9bEQcrLmpsvV1l2hti4x71PyyxVx7yoEvgvcz8eLG4Fz2JD+Js/zVGZ66lIUua2U +96i+iwKvkg4PaaeyRXng2DxR8rGUZ6ybrO5peLcgMhSMZnREOm8stHCfzcsNhflSkPa1TcWck4zc +vAWnz41TP2UvhM4zY9kwzUTr0hvBHgyQCGb2glcKEA7UZB6xg6aZ5g7fg8aq29VpzUxu5tXj0oHR +bHGgz4fhp+uEH4UOHAT0EgxGjwL+k9A9yFigIr3U3Jl7CE+OXcREnXn80Bwx5xjNqLfYMVNup/yp +uhBGAItwBgsSswntgJORDuDRYzfL2oSWTQu3s1QW3OihlXhITzcHZkVMqWUACV9D54tVVJC++FqT +TT6X/nySLLDqjBieEuU9Jcp7SpT3lCjvKVHeU6K8p0R5T4nynhLlPSXKe0qU95Qo7ylR3lOivE/5 ++pu44VOivKdEeU+J8p4S5T0lyntKlPeUKO8pUd5TorynRHlPifK+ZwDeMG4nq8efFgUYO/GUKu8p +Vd5PkipvWEWRDrqIBVvyrz3YVmA1uRvLN1X4sdrWp+RuNrXakRWdWGJEUSHkITqn9slQdAjVj70l +8DKYjbxjN+JihiJng+BjVGFBKm1Ia4kb5sKMdBCJcMnUYKh9R39vEAy9n1c0u8tCGhRLUkipsE9u +3CgFJjSRCo7aGlCkk13JJ/KoYEU+UG18dJse01T4o3Ty5tHeS8HKVKkzyz1zKLyfB31SHs7rWbJn +zcH9mVyfye+5LI8pLQyXBcFwNexUEASWpXAKS6ETkcGkBdEXi2FKWkBhTRQ2iaVgwmKwwkGHkL/D +L4ODcNlj8Pl7a+ISBTUkj7/zGoISpu3DofJEHLYIiNrl8DIuCj+fj/+6Z9ctTYU/ylLkNmtLKeN2 +qcwpjWPEaDuVnN67yt3Nn6dAOU5BO1vimzi73q+dBzgR1J2mmYLdXjSMvYh7J7ENc3ZPCcOhRXbJ +U7PUyVkgXx5F7Flys1Ai8plVppCpZydSk5/TUzOnNsypE7lrpzCpHr9xGVS+UuHzgW4uU/lkTv/7 +Gj1/mhue14lLFU30qAVdMDVBFHW4pfUAJG/WOz26nf/KvE1qxeW07lNaEmNMhUVxTLBpUclUYVh8 +jGlxX0RbuWRTDPZEtVL9uct89kvV512IfFtshjG5XmEDVo33Pk/okGliSRdbouJybSzpYyp56Gt9 +7Gx0nBSkl/msnYbn26NmWq06Ftdn91FzqzKD8eNn9pBmdpfF0cm8qnuqendNQN3+nni6AMpQmXH/ +lBn3W9N+Muwns34EY0SLvkf0BwzGEvS4pmk3MyvzWTiO72/mbMtczOpBT/PaMqjnPY+1y6b7YceA +qea4nGGZX1VP8JnZLed2bc+GHasavE05r7tiXu0SwbqyX2VWVWY+WQtlPWM/qXK6QNQiFnrQdh4N +VS7bO0h74NZiURSka29pW4GmDwlBdHzcWPCVEzHl1NzsmH9Ru7NNBg/b5EFdjTT8TDok2jV0/KHr +ma9k7GYBBs+QZWYmRNDj6JM5jIPziuzEoBDR6OcmF83cmEDmVR1/6rdd3085gvkn7MOn6c2rKRpw +9CP05gf15FpJVtk/j9WQM3Bnqx6rQj9+tHZ8XjmOQGhTpTWMAnTMaHhM+rGu4NBRPXbebaKSSnRe +Q649JUvETR5zE5RklXJf5lrySvhNSmqps6TbSzY8QdU8Rpt+lAadK84q05vnpDfHZPi7pDc3WnNS +mk/Rnu2VZpWWzEfpzGGhrKjMKuhVuc5sM93KZzxttOYMg2MKBWtUq3pz1LF0gcRZcoi4iJZfgPLR +s6ZSqtSh0p89OueU5Z+sQ7QWu0qwrDxGx36UXp2r0yrTpsekTU8P69JJlT4UdpSjSrr0R2nS4hNZ +VaRVIgsnulQSWfCEIdekSwvJyVtIMryV8TOtRJeexM/n0kyfwkxrmeklmemYSEGc5dJ/quMsx6Qx +ZeKYQ9SpQ+BDzJYZgx6mImFmnOWfSg39u77hfZ7nXMsuHZVjiPEJyWFaPbvUtGOwzy4mzKm80D4z +8+Ex+viD+netnKkV/ewhzfte5UwV2tmjte7zypl6pHa26N3d/aB5leln5yT56AdtdO9CmC8y09Ty +fKN/B3/oA4i4x2jpj5v7wupyv0b+mPnu8/lW96DX79HFzyprWq3o4vV8Tyva+DLfp3K+1ao+Xs73 +OY188X1nKrk6o7+VWvm6B7yZ8cfo7g/q6rWiru7V0u/R0Svk3tTaYj5KQz+voKuH0hmdme8Vq5qf +bdVs77HS0vWZuZ4ylEOGc1D3aurrlrWzWIdSox+17ZyDJAJxcRCXvEU3ZguJgDlTg+bbdbPDKSOE +9UnSoE7MwzlrM4xQGPvNWsJN2zhjbe547cYzKv1n06OfSKdnWlL7E+v0qQ+fpNPPayr9TI1+8Bp9 +FyVEnXIYjQJlz/Mt6lQgYspAcccgjXv5O6IOIZKoKl3D4n+sEzVcpiwNXrcekzC9aNXQq1WQprX4 +pmzwTY1FDIPLJGqRqbMaAEsFgJD3X6W0/3mm/32KcziWWf1DNv9YaqxO2Z8l5Z+bSOM8YG0Jaztm +7ZS3GLSpzkca5/GtqfVn2hCbWv7M2vjo1nyp9tCjv75D+vHvUh7n7/OGi1bn9+wobjvu1pNEdfdY +8rPfo1JT0O9OJ+Yx70AOgNWIV8UW7FXYfbtQvMUrr15pdalki99MEd7rfJUW2RGLrWEXjFJhqVoB +sRZhXakugxVQqy/IsJRi8GUYYgmGWHphVrs5VXs7pGpvXSiyEAsrxKIKsY7CXrDgsWJCrJKQ1UZo +ayL4uAGve3gZpcy7vwu14nxbJNuT8kJPrCMUosV861MbCj9lVkykkbadagLnareob2vRe16kq75U +fSB8Pd6ZW7VS73y8D/Fs+xhH5N/QDZeI8/h1Wmnnrj6caXtV5AQv2+6B5taaWjnYVER7sGWZM1T+ +z0e1cb2pcx9813buhsN3beq7X/p0w8/phlk+gWORI+I7Z1MuM1yuZYeIeS7z/BC28l1Xdi+1AjdZ +qjlmtRwzbEJWy7Et5aiKSo5eaS6rOa4V6zlXpmfPaMXzlRzXCvQ8WJ5HpTo9bVnqukjPWqGepmCP +amv3rJSCPN+acj6qPfTotloFSN1TIOg7tb/LGy57ljuWWR0H7FWNfXrErnGSubE/aexL7komaxyl +kKqWTXiQzTfJpjNSUfMkm8ypkIiyl8Kal1Jas0xDaZKpeDEkrSUtD9gdVZiF7zceJfNRMiAtYbYx +wmlUVYBTGd50XA1vKgOcpEB1inGS2GodshBdpmCnU7DxeyF5n8Kedqlu1pwCoGIQlG/iKhtCRJRN +cVF9iI6KrYDk5lFfTd5KSfJYtuNqO1PqTMKBiqbOpCDZfdemin9XaNXHNvV93ORzu2GeC6QLTUv7 +6IMSvrUdetlA8zyYUapNbedJCkP309TTZ3wmg2KTP9g0tkkGULUG0x/zmfv3SmyLOKJ7Bs10oDWx +JyufxPO344APRr2la3/T2+2oB1tct35Gef2Eu+INN0YqaU8r19dnpOunqcr1WB/+NENnv2rp7IvU +8YVXKAdoVkUoEigzD3usqflpPkSsDEllH1JCGBYUDkn3jiFxyT6l6osJQYaUAK4PWQEXZ/M/l4ri +p3wlxTIW/y3bp7rFpepnCvd4oPDNI9MH+5pVS1XNaOiJtTT7zNQzhdpV0dQTS2RGQ0+07/i016ux +xPqRzbSt8uK42WBy8U3e2ouLYMJa6ezoOmxlvfEl6S1Gpps7cGgr+Xt7WwRSchs1ToOzGX2xSSdS +m8Vz81P2wse9WlaKmwzInOt7v8ed0yPkHZK2CXeTY0MTUVqUxONZ5zPYNsW+ftSnfhKhcqsoS2fP +V6r7uK9VRIpaDbWv4+bHLEVCTJNQ54F0MZ/jPoFXDsHNfBnSKHShwoVuEGI2A7ZEhGAIplOp7kWO +ASzhozExaJ+gfgvQb8nhGQB+qgiIMxX+s6xnXaI+l2rWOod8KrGPz8k7tdSwjsFwEdI3hEQPefrb +6JLSgTpi/6mQ6nZJdLsgP0/J6bSgPyPJnAooXyCcQjqTb6iP1c8DDnRKXpe92LCPsQ== + + + 0HkyxS851iImFE2lquT7rEhyTLumm0LJZankpVxy/NrXBZNTyeSUtDOGUrZlk2Ph5MXGD+KvfN3k +rC1ZCvPiyQvKpSqd/H1C5FZSaOgm6up8zot6G2abURU7sc13ekh50I4Z7iPfkHFThi2pih05pLpt ++a5sQ1vLqm3LpjS+Zlu7L0v47ZKLOo9Uzbemx2DK5lSZu3i3sj9rUPZYOY+z8vIyrMbn7yhTVEfI +7ZLQZoFjLq7jBaI9JXlGMlzlWW0iWrspY57AtwU0c9m1yaXbq6yoeSxrnhc2T6XNMxx3LG4e8yOm +vUtUd9y/fmu0hc67rNi5SYpquZPHbCfPaql9Hrd01Q4rLfNU/X1ut5rz1ehoq7JNNlYA+Xyrldwv +32p5jETvS1suW20JhnArGPdlq9VREEsExKxCFvj70O39gm4PW20OOI2VVPAqoZ5z3HOJbz+mRPAL +W1zCiT9iuy0BEkPSK+YsTCLqF6cso4BWCTZhM0Y5pbCJuO2OwSybbzsd2GYfzF7yaio5s12IqNhl +225hn3Hz6WzzrW2/QYUdOBY8Neetnr+6c9vyCQD+d3/De2mgaehfTvOmFPO9ELdDJGlLpYBYe2JI +kHRXoMBOSQqwIRN/AKanFGnC4lWRgU7iKUIsxRCiqfJUab0AvHxy2phQhPAtj9iiNeFSCfAkJqH1 +OdN6QZs47NqT4Ex6yTHoQtI0E3IKMpvgUbII9pI90PmEgUryBNqQG9AJyEMSAIZEf1by/fpcv/uY +5xeDpSW7L8T7+0w3j/H3F7792NSqz/6B9NZVdusit7Uq0lrnCa3zUpxLBus8b/WSqzpLf66W/OdF +5dOILl6qn0ZEcZ7+PNVAXSDEqqqCWtdBjejhRwf31i7Sx0UGtCH5KXRbVVjxPDqgNBiWePEyQiDC +iEfC8zLMeIMaX3DjLXJ8iRZY4gXEIdTmUMuzqJV51MpMamUutZBNTWUJddfyqZ1Lq7sPieqavLoq +S6z7HVLr3m8pfdpuT9vtabs9bben7fa03f5mt1vmXpqsY9LOUXLySU6NcWJSYIwTRsJKrspx6vDZ +yIwazseWuE7bgf6fQfej1iFr6XrQzw/2BLqFqnyp9FGP49ZCV8G9/c+NcVsq7mZwbsRd9blkq4+7 ++GOcNP/725u763/c7F9dvfjTF6r8d8Utc1/RvvWCfYvCdEhhM9pbcYaQUNotpcfFX9Gn+qZtyu48 +XfduST4xdCqlbhtSSkaP3F+8shG7X+QNOOeXVVkaxphgYqnuWiaYKJNM6GQdWcySjibJ0iqy2ENK +Q2S0gpQGyGjkiBRsn7sUDo1j4eT5SuFawCCXVhEd5nMJfxozrTjTiIv47CEVxAszq/JqjFWYtgv5 +2I/JGqerGY5zfAiKMZ6gQhJG73VyWWRGnpN9sWLvGx98zBcRvPBqXMstogtbdUwgkCzU9827mneZ +gSyfeFPYpJcMI7vGEB1dSTJCKk19aX2ei8nf5abm7zKXcYfGSPsh7dJghVVpJpeA+0HsrHGfHrKS +mvlMTqmYZpFiX2VbNqZdbPPrj1lyiEMxlzoZSG0MYJsyr2GRPjPbyjYzhroMaLHqe6g9Dy4zgB4b +A6hZ9Tx434PMtaomOzN+njN//q1bK9eTQfTZeiyLEIRVqeKyXClCEBflQlmWaMsQ0ZX4xRCiuvZM +LH8qbGuedsSYrmhXOxVWNbGpJZNaKkJAg5qS2C3a0xizNUm9jmOypzEsq7Gm5dD5+wssrsPnVwH0 +6pgXV1zA87GwYiyrGIsq6gCXP4YA8lhLcQjCsVYPY8GqRPjrafBTbLg6mwS/TQDwqCJI6vtJgS8y +rUi16nGVkHKR9lPncjUUQn2/M7nvVFHU4BPncUnf8fA8PrqUlfpeZjHTTNTj5zCpJf9t5rKYTfXo +XfnI2VTf055Ms6k+Zkf62XwIgAhVDr1188Ty8VL9Yexn9NtAhdN6EpjfJMUPHERNdF/S9XtscsTJ +8YjJC6fLgeyEXp9LIvF59GdF+2yKzp/7/D4dEgee/+r2zW/e3by5u3nzzbNnmWqZf6B+9Zaf9P6T +31zd3V2/ewOd8/L21c3VN9dQN+NfGyjfW+ptrE8xQeXeaD1vsS43g+u3Gtr5PIi2PW76ad5CLsRb +Wyx5cAm+xE5+/uEv/p9r/Pogf0al/A9/lX//F/78vzj4FwzP5pebf/8/3ealv/K3BGXXfagftXmN +sx7s0OYXa2fF9/nF2oPu/XD1/m/wfbF7d3e8eXF3c/vm6t1fNz8XXPnF/vb21eZnuy/DcD8/vby5 +u333fA+FHlPy/Hc3r66f//b6xd0Xm3/EBf8vvutB+7Ws4VlDqBomByEf8poWKL6BSGc7HJl033s4 +LTpp8IL9xOoqclaxZrn2B1evWpPiAHie3vzhikNmWCsEIttIEX6cN3qetswKIqPes4oJhnE228nR +BANShhM26OS2E+ndDjOExI2eLM40nRuGWffWyRkzQxRGS/KHe4x2O5p+c5D7Tv6+uGoG/eFVlC83 +g8XL9RBVQZYmkDT/5ME/udd4DVC7LQuW4cX6DroLzpi3ILLhvvN2MoZgYddN2FfzsLUzbjz0UsJM +emVZeETsSw5XTw4HOpByO04aB/5VbtNLRZoZg9sbxzFB32eeBcULw745O2r/hsu/5i209ifgXXTX +zxuDrhm+CMiRxovJ8GrDkAfNpC0dKDhOMluD/xxtdq63m0FP2wnCPDQvgyneGDNtsS5wAlQzdBEd +sVssFQzwJBodzrBb6ncgagYLSPtxMXo7duDf48zqM+yN3uLe4F8MJJD7sCsQ/0dwJqw/6S+ZAvo7 +OTvghDGMyQS9A+sQBHOLUcXmwNR1bgoPGrbYd7yNoZaH24yESuMWHdjIxPtg6sFwZvA2MBzfFYwQ +M+3iuh5ncBAgvWD0Byp8eKVxi0vxSjQJdHEJ0RSIh4wET6/eRrM2jOUJ+JtvhL5hawxSN4krE++E +wcWbYP9AWaJ6CW44h/ubMMMDtCi+L+43jryjtuDcXEtui4WI+3DBYlNwcshN0U+qzFyr8xZLG7On +yUDRSc4D5h8D4DhBmxd80qj9KsDOQVdwH223mqGidoBcgZGF+r0lomEesAIhFGxMN2xHSXo0g6/N +eNkRq4vrBOLCADa4wSMwXRrnM30SniTvhC04DVhFHRZnD4Xbgs7wANbltu+wqZhgSPd8wCQLxkGh +xxsNsjEhJ/BloY/h3QwW+ATJxNlx6PA2/lVAUTusESxXSBO4jR5ZYocLyHQgpGByDiNiGCLA5Myj +LFdNUQpLgtx68+DGOWQ7DGtIeBgHwY297rAH/M7q8GAQQoYiMCX0BtLRllZkvJ6DQIS56awQFowO +lyfoKsaAQhAoaIc97eQM3xMzQFjDGSM240jhgiscu1NeuevxijzBjOQcoASgtJgYUBQIZhgp67AK +8DHLFllSa6FKxk6kStB8R5yBpQrBZeaG9GdgwoXeGtdPYWt1hhFenE68Kqd4xgygT3gQlorlg7DA +wffmyc4YVxCl0W0p5aDD2FBYoaB42BOgj9Ta8dY4o9tahijgwSMOy5OsM9jEmt3ByuvwpHHYsu4U +emQGbkAscUhSXPQYpGHyfdFm4kuDyxi7sTiAnlMGxqMYBYIDntRzpzkbnoTLsOz54mAN6CuWNaaM +BHriTewWYiduQqPS0EtH9MRXpmg6syOdXwQDtx6IEbqLofdUD6OAR4JkTCCEjn3AWRYDwbNATjFi +oP6YNksEDwkqztBbbGPch4sSL2Y5hIb2KQ1Ggn2kByzYwMYguW9ny089Q5ZVZmWCwKr41nxA54xU +pp7IhXEXbFTyX9AIzUkD43CQT+eJrGRoT/Bvwql2NJT1Hbg+zrJ+B1N8H7F6LYaOmcAwqV3XgR1q +UicQYUcLoAZVsdPoh6rnqFjxqvTg1eEBIxh8z5EGIwJF0BYs0MpSm0ZsY+wGcgzaZvq+G6SjkxxA +Ryfu3c3ZDckH7P8oclIbh9IPX2yesSYc9g09LZrhgORCWBFQmSRkcZJ4IC9VPtMbaFwjAxkhVGBB +kS9Zro3N/hs845npsXWgVEH3GbCSxs0zDDAoNJQ2CP3g8ui6wzKbWZkNNAmbcvNsEDZL3xP2O14P +Fw0cUSxXKAqYOrthETfsdGZhw9oBQ/gDCc0zvDmIetcxWxkItEEHwclJAnCE6/0xT4MGCT4JQQ+r +mh4m0F8Qb2wg8g3MSr/Zk9bg1lvxfhqaQzFEm2dYjFg5JPN69jv6Ue+GjQVOSrurAZHlu5ECzZr8 +UArHfX/v9oxC9ZaL22lI5ZBp0fGRSejASCAIYonLy30tUvB+vy5iX+T/by5+dXsHafr23UsspX9M +Yahn18bFb6+vXv3y6u7dzX/i5M3PDrsvo271u69v3732HwXZHGL8y9s/Xj/ffemeoyNf3f0Vsvvy ++EqChxj9Mq5v8z2s7/hTFnMYj3Hzsy82f/jfi8bwPz7IOx/lCE+EKAC5GdICtjrXEnQbSnwGQ4zn +jqAHnFBMFYQC/MR+BYnFLgebh7DXUWWigLHB7oCoBbLDWDQIARtHlQRcd8Ru0MJYRNLEkhEx3JMn +0OotXQUz9WqSAC4vLMjNSMZBsQQLgu4G3s6Qy+PxW+ImwUVBYCCcQXHD5aO/XX0ViCiWuMPtQAYh +JIEOQ4YCNcX/WLNWui1iMlYmTd9S2g9ELt2u7/ksTZUIunYPBYqdgNAEXsdqixC8QMEmLhcwejA9 +UEMSWwgx4E4bqBjYii68LC6nRds4DC7elX2Y2AdoQEaLtoEt4zaTwaxzSKftbEQalvR/7DTYqpce +8M5bDjOUGmy1aQOqucWu0+Sz0A42VmPCQLGwweVmIOok0r4jc+9FMrpeDKYYghJIOE6GuAgBAd3X +o9g0QMsddRvOv0jWPekhdIPBMaumF0NHy70MiQu8aLYYJoypk4uwWTE+mKpuonCCqZodHgfWE2aD +jAOMBJRkSx8g2BnXoCf8kEdDZ0ayNMz0IG+MR3npucdggDRs8DYg2Zgda72iwXUBzQZjAiarw0oD +b5kwwbgbqCWe6SSectxAG8RZEEwhf0CQMhtIKD3ndDRUobEhIHmKWAZpmMY7fzvQr4HSuwUx0xC0 +3BRvNzFCFbfDgnFY/1gBUCgxmww9BevDS3NsR3Yb+y4sXAizlrKgNSDjkC/IVXErTDkksw3EKojC +XABauoJRhi7puA0xJripY+B+N3jpZaT4OWn0bcLOxDjgSVhH6AKEalHmrKW8KtAE0FjsBsrSEBln +Hh/SYZlcUEJZhNCOqPBl18x+QEGCRlJ+7ome4f/1B1NHUT7erv7Qa7+QmradJG7FB8tBdAvKKg5C +PcFQEjgx92kCIEBuJlGUuDWxCLkC8XadAZOdqeWNffvBSEkWVF66U3+IdW0op/K1wZhmrh9LSRtk +B1qElY5SP0afwIZmzU0J5dGEaez9HFOWHakJQDdmflmI3VsaPfAcLNmRZoCt5Uhbig== + + + 5pAReyoHms/FW9kwj9h9/Bt7T7M2Ddg7aG7HPA3UGzRpFbeM7CdZPdS6oDJBuEUfB5NGnAwWb2Ks +SL6UFzhNoHQW3BkHGYrMu0EbH8UQQa4AOrWxJGfYetJPvLT0E4QXwidmhpsEe7yTzUhpFnwdsp2D +1usfjbVCQR/kBHqwptSM4QHNJsXTkFBA8SAgYY/h9h3pDybekHyiS6AgoFpYbGYcE6/osWKo1WnD +mxhRq2fqn6Sj+GCkgA2KT6qPzoKsTxhlfjAFZYgEH+SExJY5g7WPCOd6njsxbNAmwUnamAGvTFY0 +kYZLpzAbYrECHYokHXqBkO6ZeSOp62P+eA0NA5BjekKlsHxAFSgiy3hhZbC4kOYlG0MaZcLmwHCD +53I1gq17pJAnv5C8WaOIi5TVjzc9lw+6Qmoj/BOLCVruyFeFHhcIKP6hG5/incbqZtlnPHSQTuC2 +1ERBH7CoaTsbZG9TY+bdNQ01ngdKed3ZczROFZNncCOIFYdREhONPU7mhQY96WwPAZ+dBYOTu7u4 +/0HBZISxyqVSErUFTbMxNh5I1sxKSngKxhxiJt6868L5NB+CWoKHpBWBLbOl5QnrDqQXywWjDi5O +qglpYaZQI9OJnQJpxZDd695bTKDFzKJAW5o7Y98mefvOTyHvMTA3CJ0p6Egf9MVtYgFgjpb8E5wQ +Q7yhHYnDS6kVV1pJIe3k1ZhmhK9Grwxu5ffzIdidZ6rYULC5gniV49PxONofQXww7yBI3OKUS5oP +aDfDAf8G9Ye+t9iy2JRYZRTqROOR5bRirO9Cp7QXbwaI4ehoOh0yB2gqTqdpmGYCf/v6cN6l5sP4 +IgNtBSOjYCh3kaT4Nx9oD8WSgBQDtsSNWQxX2FcDpBCy2zTIIAaYB3R54GrPJoNmYEntCjWis9n8 +4dXCvSjp62WqB2ru8gElhbQg+AiRWvAIbMKpWDtyM+isvBnI8bLiOJaGhmXWN+dt4hoFOwjvD6GG +puJiZWMQaIvkIEC8GtJ+gMQfrsKjNNhP3D8D1hGoHzQqAiHKTTeQvE4ka1DAwS3TVhWjq3ODGF1B +DtPmpjlOc7pGx7eyBUmgAVWkhZGAn4V6DKT9hu5HWmZIqQO9GcBVNY0+eC280FBQKek555s9B/dK +tI32+oEiwUgDNjhspIZ8fkd+AqkeZG0oaCjuv6UFKxJccJ9gJdGQrewQKfRAO6VkwQbN77ohp+pY +9nTv0MJn6MRJrIAqLGQc3gyjAnYdmQefyiTxM62a8kHGcsDXIfNYrEuMucPByKhoxeeqwAe4aOwT +a6OxE6x4nKk7UFDL+SCvMuJM6fA8bhzPPAeKpGK2xijTyBi5LcerJ7MhtzSDLXj0QCFDs+cQv2lA +iJx9iNI7iERPq0WUBWgLtrRNYy12IGhJcPCzOXnDNXYqV0+UNnAI00AOApbQY5yjiPJn6YMFEQRD +hPxE7pcEGy5cbDfyBKxdLvMgCvleT77X2GKF3MR1OGs+HiqztknYwnYmThhbEcSFLqIonXHD401o +JUcvqJFlMt0w0n4tOegsdaYkCQ7UKMiyQL1nZ3SSHZsPcomz+TDKqTTV02yOTkxCqaJkS7ojuhcG +giCpQgxm13uKDAMTaYM/BtGZ80BaVv+bieLxWJTbuUtpUKBvDjrKIulz3EwHiQQK/0SukusH7ABp +NTrQYXktygMJb2cG0jcMeaaFDDQAkOhgnjSUnHUlBoIulEUS4WGSlDhRB6LTQ1YS7ckWSyuqSgNX +DacXHenpV8gVLL6cOP+wdyExuKSWcdjxYpx73B3TGxU5cZ0I4xhJIId1PZBjQ8GMa4rqdVQe6eLh +4EYtE2uTxGsmCca7l7oppCXQF25QO1IxSxotr8LA0ysJkRFsIKjA3E0ixkCb60AvVvXnIcjwUeum +B3OC1kIPZid2Sa+mg5Bv6SIGecDpti90ezCn0AP6b5I9gL4LGU5wLk0xNloQaJfvBzpGaO+Fhprb +HSB+YEnQn2HRBd4uGCnoMKEYR1dIr81i1SD1xuSA1unB9GNhAaHVmI4q0EF6vedoNiG5pYV7Fmsi +SFC0s3huRzAqud08FMYZ+ktZCpQcDxNnkkmHHlDvsKYhYuiTEYjMAEInyTrmtTAc0bfq52eyZBXJ +3MSbaXaWlhTukmigos9RRH9iZi14Wm7Waq6KxjCyAvALvupoMB7JfMZxIzfLbW0cL3KdaJgTf6os +yZE4oRWb3iC+Ee4NTjp91bVt0PcOs9pT9ODWm3ASiLbTA2VN6jH+pSnMiPmIq5i6NYcMG991eC/M +NcZu5PKmWi3TaylFi+cCHBXaND/s0CPxe0AqFb/HLJwbixEqJvrdT1OHDW9pOKP5baKllM4ZbF1N +gOokSVhM8Fw4EnI8nTgJ2UWj+CBxH6giwxBkh8HLDpodn0Te1TSZGi2VArTAQSDjWSwDUhauncim +ZxoPsdWwrQchc5DxDW9PDw1uD+JAaw/oHl27fgI0Yat0V6NHf5Zugj7PlB5GTL319ihKc3wZSynK +itaM8yb6jzVnYJSZFeW65xnkwpapw+jYxbrwAJYx+KLqy7HnRX5onmwo1YAQSeANoRrNG0DU8K5Q +LHt0MmzUeiR67d2hI04j5W4G1IxbyMsk5h0EIyc2iWY26KiiQ5PKH46ww/WM8kFgS3yQYRXedmXw +lXqQeHQHSpwLK6NeYT1dtXxx8mFD72G1ONGlLc2U6I/Dvl9Z2zyjhziC3naWc/Ai7ux8a2jLHkP+ +wxsRo7BpdhdIC/7ACM/U2PTKJsXg0e2Cv4nOntMmLTd7L9AfziWIAfoXyQOdcFgIPY0kE32rkZZA +HUPXIFAOBNybZZUXFEgPlK9xPiVcjzOpiBfdf2D2lu4/Impa2kcfZYeVgcEcO+qrq0SQbnf6Kxti +q8nYpB4UIY6EIJSUml50KHrQhHo8xS5Al4LME2E0EUM+DOKq3DQcgg4Zqq50yOARumUwmG1QlKQE +FFwJg45eWtyaIHtOZM3P6LOeqPNVTFBT1wSrQc+o8QYwQcVBNeQl7inHWtdEOzXMV3MNYwbcIHvM +tLwb62Xbj0KR2PHwIjXr51nctaRb08AFU8oMmgIIEUm1nEGnPY1XbqBLObxHLaRwkAVoEqQZupch +UlquDREza1EIKhleBC9HRjUGDayWo7gZB+9pdrNMbi2C0VtPwybWcUeYZyvB4XYBuAaCTknei3Iu +ubJxZ8NdNGJzbmpBUdzkHV3zYFqGOl8jb9JwO0Qxs5JShfbJ/UnhRcKvBFyuPVAALl1NIEorH/MV +aYvkK3ZJHa/FayITnAwoZXyao2vJXNNRw53eCPZiCXQkv9g8cxihWi8gxeCL4AGaxdw2jUqhqbY4 +fDTggp7aZK2RNGe8CDJ/odC09wkqEOEuPTVv4h4ICVw+IBax4xxTZZwKxYkQGLI1QmBmkWdqZaw9 +o9blSAzJ1ByB2omo1qogSR1nDveh72dFxdTU1sFdQU162h3aE0Y6XjDvxH5yPa8qo9ySHvyFPWRl +pCvtV2CVDK0d+gC8rJVnkifay0GesDKj8Fnr3iTCRIPgPoYp7zaN1s4zBKkC/oB1NrZKPwk93QV4 +EkhjeFBtMiBOkyueOE0jdLa2NhAzBXFvJGbKzf3cGiuIFLUk/CBvjiChuAwKU4d2AmVqDSR8E8hL +BJN2ZsS7ijhT21dIj8UAWltksJuFxBH+5pi8tjHo8AxSDp5hadjzYldlD9KOaIJNYz/CjbGeOdDd +MIoqU5ufCPvrBBqKRQKBIbH+wnoF8cP7q2p7Fz8QmCRLaBkxVVXmMp7RYauSh3T0j/kHVNY2SERb +jqETpBSJXmOoo3thwjDR7zGKjF2Z+XCiYDkPSaLMbYPaehXfCj553CRrIkZkFk6IAeqHNRsk76UJ +8pyIoAsqamPCRHeEF9ZGT+IyafXGwyG/9a3JlCM0YhgokEy5pauwuGIUoCBzomYoGQJZLW21mA+P +I+VgiP2jtvQKQrTnzMwMlF/AubmdmLfBy2LBMWjCDZvGxOwXA3UKJxpVa6GWrgy+K2CRYcRq+zbh +qD3LV2JRdpS6GtM4euFtXLVBXcRII0i0kXkBkm+jsMcTm+mBjBMGhoSoNuULLtNIfVEoeVPrCKCE +oyknYEt08UUqJwJn3i+tiSx303ofqLRxXVtxTzWOCyKAKU0QAYzOBMtA7fYw0GGZAgGPoc0Db1N7 +TDjsPZdg7WfR0+RXGOhz30e6XXtpSKU8oL8zTGO94v3pyOPoJ54pkemVM0iBOmJPR3mXdUdR88K1 +WwqsWtyYOAFj71pvFlYqZMeeAGAGEYY9UzvD6tu0Hra6I+0Zay/UntUMTO38awe39h2emSRxOMaZ +bRyTzaKIzszVNRUdn9V6DN7Reh03HtW1zdD4Y5stVXtym13ZOILP7O7SjRxpQ+N2bshK47VeJU+N +07shc42/vCGVwcm+Rmcbx3xDrhuffkPxG0jAKudoEAU1A2qxCIF1tQiGNc7XAiBqDtpCJ2rm2wAv +ct7dwjVq1t8gPRrxoQGKrIohDc6kEWciMiUKQA2MZVV+akAwjRzW4GeCBNeAblblvwaz08iREeUT +Jc8GEtQIroc1QFGUexsYUiM2/1m6VaGYGvE74p4ayb1BS60pAA3UqtEjGpRWo4s0IK9VnabBiDW6 +UQMva/Sr9ow1Pa09q1L3IhquURRrCN2qvlmC7xqltcHsPeaMFb155axK7W7Aho3GXiEVV/X+BubY +3qVGSDY2iBZpuWbL8OjMaP9oQJyN6aTBgK6aYBoIaWPKadCnjTkogVczI1KDdG1sUA1ItjFjNRjb +VStYA9FtrGkNuLexyLUg4TXLXoMxru2DDTg5GhQbSPOaObIBREdjZgOhbqygEXi9akSt0dqNLTbC +uxszbgMKX7MGN4jyaEquIeiNEboBsGcm7Ab13hjAG8B8Y0Rv8ParxvgGrt+Y9Bukf/QGNPEBq86E +9vLaKdFEJjSOjSawYdVB0sRFNP6VNraids20MRprLp6Rsi4W2swUT963VbmK5K0pHfOte9l0lbeJ +UpVMMQNze9lOK16rkTolw5wYciTSeu39gviypejF4kT0NTcOtIk+DUkNxAxEblh3xOG/LdNPzIxu +1a07T2RI2uQpQzLquXEJ4swgrZKs0yVTuxb9JEHi8NsCQxUdh5mHcpy9sA5tbXK9bv2cItm4SQRh +vB860w2tv3QSwxpjEDta3hZXK1iMaKqcTrFE5Q7a9qrav9s+ufYRNy9Qu5pfrA5D7bJuh7N2fQt6 +vJ4W7zevZ7N2t7drYs1t3yyt2vvfrM4IHGgWdw43aPZGBCm026rGNzwcQsV++yi1LPBqZJi4pdqG +Z3dzmnKJt8I4ewkfW8+R+kBEY9y+o+RsqEWyeKGEslKgovYPWURTWsZkQMkgBh2skbzLuI5ZAtoz +5L3ByJiHkmGx3dyt3YdxppQt0QX6oNgFwwjXkRgVeoyztbqcDI3E9ZJST0vURfMc5g== + + + DbDkta6D6m9X+luf4ddo/d7NfZqxoyzEqHgsQMjvDHs5M/TLPH2jAtgYYhdNZ8wMIzosKT7UGwg0 +WNGv18+yYhenbGwlCL+xSxE2sWKvorYvV+Lt9RSD/M9ePQpqbmYeBayMtec2Z1T9fxGNR8VZNN8z +bN6OXcdcGOwBg4FppmLKCZwxSIYOaOpghAQpNH3EkBODQeURJH9KtkRLazUIvPjjVu5Tj2Xbl4fm +5EU5h8YWG4tOkV6wFGC+5FTN4hjQKYi/0Erd3InIVy8wukcGepMZ6U6teHWhMuq+pz47Ucygkl6f +xfB+y0yVk2U1CNtuGsbTT5JmgD4zU8J22qur/dn2oN7a7ZuskYh2RJr7NKNak6t8HupdVq+/mQYt +GzZX9WFPWJzEWNRZfUYy/pVNRUg7r1jdS8tV1bJanlOvt9C7F6tbnzSOgVntSqeSpFe2/AT1PMJA +230Wr6qHKD3nzNjFTUBjiCGSiZiobhhKJmPmYOWAiMM8LPFDMRpMVBRBSgahoL3kQyDgCZKDj0Lp +qXbZid5PypraM0UoLzIUwgw6QnOxQCRDjpbbeH0YEjNl85HQItGyx75nWgVNRxNpGAQVLB4rUTiT +WDNpdqGWtion4kGCgYICabTxsC4mtMRZI/TGXjT+jgA45jQYDJ80edozeouNGJhFUYQIPhrnJUUO +DyXFOXLx9sWZ7cWyPz5/rQzNTM2QarKwRyqykhmCqTH6IVgfAtaLWVdG69V6/wDtMQR2FqEKl8/e +PUFOJa42B1mxH+ka4rRT+R+JSKVNgVk1eUZwpYMNzIw1oTjridxIMF9w6oGAiH8Y48/UHqI6exMH +c8MGxjUM4ivD2hGP2iiUwDEBj11lYSNNdBBNMdRD7kQSb+dAV+kwrdwHYsMsQ1J3IeRoWn+DefSW +2UFjsei1kaBlj5atASp0P6+NJuEoHAXCURxV1rVZ4VmDoGsgeHgFoZpU7I6tz55RrQd2YQL7oluS +q2l9XfEBeO+BD5hkIOv1OcwhwdWAjU7IS73ECb+R1CqD9e7+tZ3C3BT0RszMyeJEfKp23ECrKy2G +tHRqKnf1rk2vurbnBeFCo73o6aLiVLSDKYM8YMSh+8NCdgYJPRE0CpaOXVCqHm1x7qrmgZqA94HS +tzGTRJSF/lLcYK6mqZsgG4aZbV6XIodg6TFRkPU37ZAR88gUSMyhNhMnXI/8mt7SzB95LzPUMsnS +0PswunIJMOUR9azJMGfu2lIiZJBZkibuARd2W3xdKG8QDdCLXrK9bdpF3BGKRT5Oi6Ub283gqP9N +cbdVe4nejoF4l2YbgoaJ1WeytAFnuxh02osFIHGk9/6+fu87puwRXlxRC8ISV1MLMgdcRCXWpGq5 +qKJyy2NqIrnauYbY1u/WEOw4LJHM52PYMod6CloGU09jy6jWVkHL8OrV1DLNekW2zHdVIW+YeL0/ +Gjmg3mLtS69t1VYsqXf6eYnmnBxE0iIZWGJizf23aj3d0Nx/keXefExCIRq9WLyc9m2yRH9xffDZ +xFRUM3Ta0TKARHLqDIRid6CCtFH6nDpZlpv/8Xv1t5vqphjotbw37UDfn9lmkHyDTGRoO9LgNiuf +aBIMLx7JXHpBvUhuwB77n7kBDVNKQmSAzE/cD5YI814Zcq6ZVmGsdZAQyZU3doLC7YlLEGBFFzn4 +xAC1qUWlMCiBxlUoCdOsPWyFuEE82HGbtBAd02Ob0esvXsDIqGbqKiPxOpPkJGNaQWaZYyZGa5m7 +YiL8lKnxaUgGHzJca/TNWN31EtYrRm3CT61kxQ9ZIQN9n6jV8e2oShNfg8tNT1evZubIXjihR/72 +TARlJcMec4c5WrOZmk1YgbyKxhUjMySCFjD3IRiGAXFKQghIyMj79I4JFi2fhFv0BDIRnDSFFIyg +//TtyJyK0IS1y6RpmIsJkiJBWCOJoJUMmGJ0wxuLzuVhpzY8iSnSZidZJSfJCEl+NQhWUzAGHOhO +UjoyDgCMrCceTrs2QNBAeLUE5mK2+/gYE2ZQqgoM8tpz72F8Yjwk1NGI5gaFjxrzqEPaxRlLg8At +iW6WJJEucXJ6JSXnaEeIpfFXS85DrPReQq57n35xxOt1VDQZcy3YBI05Jyruwd1xUI9IsoZxw+t0 +G9cxFTLkIEhKzxJBGeisBJcjbK3Nq4bLiy+zecZQgG6c6bvGnTAez4ZBoFAO4ySOqPqiXgilZAIc +mFuXiTqZHG/LgAqmpcXyConVikt7smDcndaXiRZqvPowfLfncY1jj9DLR1HDhdxq9aUaQ0KIMV4M +lJ7iiP7O70fvC8GrEFlAB/Y/7PtxFxCyNhD+b+L7fVJ6tYfWyGeQX21taT8qoxpGVEPKAK+gX7A3 +kigZUguoBLQBTWWio/sE6wWEH3IOkT9yV0g/Pv+3T6rMySnSglufYZkgBMYIF0abbhKCClmKwMFe +jIaSF4SCpCPaEFLeqMXc2E2EMYGpdKQEEHiZInimE11c7ozTYW0sKqv0ckWB14MnsAQGUf80+Be9 +iNDyJM2DGB41Bd4Z7MFbhyAqioYHIdVnPJmJkqNAxwzYVDKxHcIDJrkf5W5JSSv6pWRWp4Fx9pZt +L1FjB3Viq7ExjQlBJURuMo5HXhHMaqZFNcVS82JSXEu/tg2GHppFqUh3g9xFSCakLQm9pS8PN8AJ +eLxl9oHGqNH7BJjRloHhoXZijVC59vLOzwRZ/NiNKz3QonITx8pIqDPv0QVtC0/rpmUQiKmiIEP8 +Z88osWb4wIOhbHaCnyZcLR98umdoYhyYz3Jt6hhNL7E3mhGQbmX6Ic9oLpCBefDpqlxdRoxEJsBh +AM8auUyb5cgMqowSgLRCA3VcyJRRJAEvfQIzXdCZ2XjlolncdlAUtID82gdDlWAEAFWJyZsD6hfQ +Aek5QQifYrxeMxCikjCHcUekiwdQF2NJ9cSKXxB6j3SlmgjoRdTeHbFqjLz3z6nnk0oNNre4AJw3 +TZcLAbdx/jYs8DCvrCft0Q3oKrMVLKlzymVJRCbd0lQIiY5ul3ZHfxRfmQhAu2buI7CRuZ+lXEIM +IWt2WHufepO2fan3+vo71ZSiHZua2jTDW9Oq1VlqaF4z2Q3dbNZLQ3/X1l1Lx+v1u8IBqj1Q843o +cDmjNq4UIfjy/fPfXr+9vrq7fklOW3BWV+cUZUpRCLFbZoUlsmWWmL215NqU0b30TZSMhCBWybVp +Sm3yaTP/Oi0VEHsh8DJp9Fo+bZ4lrn3L5TvrNp82RV+5DLL9JAuzzqeN6wRoycTTk+RlXsmnTR2C +jmrqEATCtfm0meEeD6PWQ6CVbfNpS1cYxt4L2luv59NG18TBhEczofbc5tPGPvVR23UabcPE7NO0 +nj2brzmQZBMh5WhvqfJnm2HwENw6bbYhHIzz3GM5Dno9fbaRLL3QTCFaUiNr02fT/kCIPrY/My33 +bfpsM9GDPBVZsw16IzoSQdOCuKqzZvO+kIE73pcicZsUG0qoQMtYmYNY9PW02Rw9qsy4D9N3923a +bD7J34fQdN1mzTbMEyIjRS2LY7mWPtsMgWD1hDVNbfZsSWIvqrFjBpGV7NkPb71HaXgPpxl+pL7n +02gzJQDf1YQs2oZmSM0A6BF3kOTPQ4dNQ4vMFJI/G+ZSpwkMZO8Z2QduRAI5z/24ZNFm4AmVLFH2 +iPTE60PiliABdnKaCfimmdJQBnjc08autxILAzFIxBPikYn9pCuWtENUIcmibWgAJd4bEr/Pog0i +ZFnXzlKreuS79RINgR1PzN+SRhtLzDIFwv77fDlCYbg4uSA0C1DEPNogEIR8m/8eit73lEj7x6+0 +w8gYz/8ogAhRXyrtMPyG2VUYfoOLdVtyxzDai7IXZWo99W3JHYmM0WWlHcaseHAONVzB4FYldxju +ImyPzGXigbrkDqOsBF86MJCarD0ruSNBMb02EhQzmJWaO+w4bVeMYQbRndZr7tAIa0iJrdR6Hdua +O2fHL9bcIQn1J0DuIEh3reYObaXetEa7iphpq5o7hjoOtiLD6aCRDW3RHSKeCC92DCsYGRC8VnTH +SEwukVxgqYbVUOqiO0ZwIwweI02lUbkqukPglB8UqGQdFtJq0R2pFyP2RL4qAwLrojsSVaVpVQU7 +1+PYVsthXBhnkAVfZindslZ0R1apVLiZDKWvtfvMEjXOM6BrjqnqDufXkhOuGS75dD9zE4sQ6bbY +DuFyEsJd19jR4nZhSB6GwIVoyKbGDiUjeSomzUmYWVViRxM0axiwM+pRultV2EG3xO3qiAcw45kK +O0S40zTaVNihAGcZtTZYCatsK+xwH1oxHYN/2TBpTYUdvh1DAJrKOrQ8gzCOtDwzoqitrPPg9ogK +BjvvlzdUHNKiVVcMIyJYN6fxwDCUgVZhQvINM+A0HhiOJQ3tjnVgrYAhFw8MtQIfljSR5raRvYxl +gJ4tcTTW9q0nRgJtOvFmGFrk1j0xIFYQ/WjKwKuZqW89MSLME0FNYX6WVVl5YihYWwlJmllnaCo8 +MUKG5S1n21FvqR0xvL+4RweKsUPrh2GwgpYXAUvSrDO45ofRUYYdCB9jMGnth/HRaDZEo4UJLfww +mvAL8DnMCKiA1et+GIkDkSdRrOLUVH4YWf4MxAFdZCHh1g/DB4lSAXXByIi1fhgfHc1xGcicXfLD +UBVkxgyqgowyTH4Ybm+/ORl4atb9MGRMM/nQwAI2s239MIzfYcoPbOleAgYaP8zDW+M7+2Ee541+ +jBfGOw264DQwq04DnChpNSk8ktOsO2GKK7kONs8wkYbR2CzhhmX9nR5mWUIO720kDscNXnB9jAPm +O77aiv/lB3q1H8D58nk4/H8Q38uZajZ69pBn7FSsEePWq9mIUNMLqpwu26HNfGkEO9eRJICE+Iyb +wulEEqNuDVLPNFpFhk3ScIrPMQsn5ThmRXJ0AIFdpbydZOGUcxzr7BLIlWf7bK6KOUIpPHqaAgGm +czplFSXN6uQKLNPeDUUuUt7OS/8QDZiDJuYvpUAg3NAKw12K2IiIQ75EqZAxX3meVDJtmxWv4Uh5 +QRMkj7mrQxZWke9ouqKRdGbkX5a6VUS7kQYYCSozKd8r6TXEv8EXnNQpQSwNVuC1tMH9/+y9S7Im +y3GdOwLMYTcpmVUp45mZTeHMQDKjGZuyavB2IHVEjF/+LY/4H+GxsYtHBRCXoijCiNr55zPCn8vX +YtbzjVVWroTKsKgMnF5bXLQWk3qNrWpI+6lmw/e3EIA6eKuYi1fGW5IOgF2wBCRqYIMm144XRQUx +kgXUTzUbxuo9QrQ3ejPht2PjVdCjm7FTlweTL1e7yGXAl13XU8yGWRAfNH3yBBPKEnPe5A/FNZbE +Lozfk+bSYB/2mLR5TFquPXVxcKiT+Rhn6VmbOSwaVpMrOen/oGKXBfd6Y1jmHuiFiBILncfJy0wM +4cEK/M5mdyaTs8KcBruAGU0V2XZE0NQOmUm+oYJjEnvySFNTpW9l57XFn5981dwJ3A== + + + FkQBVeTgL3zVPJzWpUUCV35yWWM59G5ZEQcz1oMWO/zhlUM7/tETSybO4eWhxlrZqvPfoTVR2HfC +HVreuLz1QRIjlJYswg8zGcAZOmZPTarw+d9fecXnv00ScqXKBy/XFgQ8JJO2nFvj2gzDX8zhvZKd +8+r8C6Nwmp8CNnA83IpoLQM9aNM5p7oGl4vmjM2vwE3xQsQuXgl6h2jUXlCnD/p2MiCN21vk1UTq +NAjfWWG+iLLwtG9KNiqzi+2hImXYJ7c8sWNRIgcLRH5XsuELkaCbRzhdGGvQ2OvOqdFz50zZTuJ7 +JoqKtuSJiXhjy2euySNxMHwpPTj2Mf1KXFnhOpuT8me6w7KliX5lfWPyl78wE3HTrzgsSp/8/xhZ +5XP2/Q625lQMICGiO8QMfYMF51VnADeAWqz9iqjuKW1DMErZY8oYEKJrOrRSa9KaeGgfcMOK1BmO +pXUx9BK4cjvwmRasSkl2CCzwulBOttel7sWbGgMfWlWDId0gQhFAqDBnsX6m2APbEtf5qgzBmoOo +jzVn7/qpX8MlNVBul+wwvk4FijzUiu3zHIme7Ktshbs1EnPcWnuKXYhkB+limH6IvKY8huJ+upLc +re3HV00NdUa0ja5M320KcZAcQm9CckhoMYU71Me41OAwW3e/C9nQgwDMpvydBGOKhCQwiZV4BjFi +mohDVgSCDWV8pEuUfV/FSLTFlQaZqyLFHwomOpv+nVktsc654gk2Vvw0Fo1a3tReVFKUVB/M51uW +hXzL0FUJqfJUYkmyDIrPAUmfb/otSQ0tZuAAvbnAFMwzzmdyOp+JLaWHSkz4w6u2TPij37Y6Ot2J +JWrTcJLr17hUex9S7f0ecjf0drwsAIkEnZp5vG1WUMNMBp5iYvTzr//8dk/rHx9PYjHOnbnZktxC +jEfHIIEWgo4OiOL7+xq7rltycZan3g2gjgvqyS46rKfejUZg6AZRg0rl9UvC9qNzQVhBoW5+feAn ++gNVS255LBdYBghsYBkwB/G2xOxkEC1xMuKr58LkqCs/VzDRmB4bMrI7LeveCZ0emwSWah18Mo5S +H5sK0jEzaoSxiRDvdScyxQ0Ibu5aec37sbupvjFM8moKruIfeNoNYAzwkwFjsLfxVK4RGOCWBjAd +1/vdPnFXfDkxIZ8PW3ZL/vWpV6MoiYLmq9QXuwfrOnXBLCYqT/kwXHJ/UxrDr6uOMFXJ7DXeTxN/ +HnI370pn/o4esmj0uv2/u34antou8qax1r7D5Tm91ym+pfvh5RScXm8e8RZF1cN5phklnwyG5vp0 +t0ynUn8220g3+001hixNxWnnWHqoxiRGKDRmYd62vmnG3JBvaFzXIwefhHyGGLqv8z0csa9sTk1g +lSqxvxHDpK75/UH52p9BT84i9GFjnC4f9hIqMcQAW/GMqwjOMfy2UW1V5Gcktv7hLWxb//iI8Yg0 +CHawbuaIn8GgrQAlLySMWLe3EJIZ46fsC+9Vdp3OPqXnT//9NaZd//iIhAHXwL0OhREjWI/YGRqk +jirvQdulvwfcuXgzA2azdFzPX4HqoLjbhZp+CewHZ9E+HcjVS8+QngK6fGQTTClrrRx0Vs9n/nG0 +8XkL+f67Low2eNIGF4Dokerw+ultYa+pwT6SI1Bqsq83aItP5EG5GcgsAe2ojzczM6J0GHtn5kYa +SC38Nc2zD0rDYmaCt7iq0swYyS7l+U9Yg4G57NJNj3rrI0llxOAA4uvJ7CUmzfyW+FrOqOs8NF5I +9I/8lHapbgRec+9GWZXoYwq5nN81hP9QpbWsQYRbr8q1ILsQ+Rwqt52mS34UFLTOz7eag5nwzJec +BYqzCt70UOOtcGSeb1WPE5qz2h8lEmhlKdPMWopFdsSlr3WXechTadgc9/2s5ugZrvquX2x3gpWb +5SF7CH3OUFDCLqpXegJia59IqVClZmUGihHurZancAri8+T7b3opXDE9ZVIABG3oUYqANp+QqzBO +UIFVrtws8k9TAIWqqPo1O92TDoXlWTZyJzTOev5E5SQxF3dF4hrlTwK5LZw3xxu87XHY1C6Z5wuS +JfMudkolj3tf6H8eD7zTJRmvJqqRzHe5shY9vsBWe2R8tqg44p83Co2MtbBlahrrJvA8PRbaShEV +1+mOauqxzANT1dgPkeRqbJ49R9bYaYFia27JwM41tu+W2+vxo8EINk1B5BAbdmNLQTZsTCAwm7Yo +cJ8Nu/XGl+aWLZKsDQv4YGUbVnIr7DEsaiCCm6Y3yngMO71X7xhGPdDVTes/Ce6mh9ix4k1nMqn0 +prNZufeiq9pR+E3/FhgAhx8M3IHTZ26pB6eDDcyFwSUH9sPo2l/IE0NAECgX11AisDaGQGTL/hji +mMAiGUKgSUD5CJx2XJUh3AqclyFSC7yZIdDb8m+GOHFzniXEDEygmyM2jKKboxZm0hkQb/6whNFb +ZtQQhQeC1RDAr9Ss8YAdw2s8amWKnflGIJkNWcqWrDYkOYH0NqRHgTh35FQ71t2ZfgXO3pmnBZbf +JbfbSmyEvHBSDYdsciuxEZLRSXQ8ktZAiDzy2y2d8syFHxzMnilH0uaRVu85n0cO/mSK9hw9UEqP +fH5PSO2pf1TDmCWCwIQ9yglv/Nmj4BBIt2dhYuXrflQxdnTfj5LHIAlfSyMru3ioq2xJykNZJpCd +z0JO4EmfVZ8dy/ooEAVi9llICpzuofy05YYPxavAMT/LXZOVPtTGtpz2s6IWKPFDDW5l1V8LeDtq +/lD8Wwn+Y9lwEQZYK45bUYFQrwyaBKHUOeUMQoF0q4EQyqtBSyGWbVc9hnjETtchHrU+cCgoRyDa +UojeKlWEOnY4TSiOhzsJR2yfKBwV3sxat49vdy37f/KVlq7B4yMvbYa4PNYWxX6ZhQ7HuljX1khY +7mtjZbtp1rZM2HlrQydu3rUftN/7SzfpYTnW7lO0NUvvam+y1s5XMH2haRasZui57Uxu6NgFgx2a +fcHWzxbh3lWsjcXgcWYncnio2Lbc+bXY9VzdYuyXrh41dFtf3fCjNbv67NDMDe4+9IK3wUJoJYdQ +I3ShZ3ASetfbkCZ0vkNEFJrmI4RaG+3bsCu06UPQFjr8M8oLuICtnEVAFTxizBWLsJWzCFCGGOiu +KIgQIwcQxS7CDgiMEJ4H8EYM8Vfsxz5VWKEjMeUYYJOYpMw/bHOc+cc1Q1pxLzHJWmEz+2RtBd3E +pG+F6/zMEbu8Mx615q8LzCimwCtIaZ9KrxineJ4VHhXT+gCz2pYHVpTWo6iw4rpiPWKFhe3rGiuq +LNZHVkBaLLGsuLbXAs3AwIWyTkDNxdLQwNptC0oBoRfqUSu0LxSyIkJwVwcLAMO1nBaQibP+FvCM +u6JdQEPOSl/AT4ba4Iq+3FYWV+hmqEsG0GcoaQbM6K4gGgCns4o6kamh3BrwrC812gCCDXXdgJ8N +JeEAv90WlAN6N9SjA/B3VrADXHhb944/X6vmE58c6uwB1bwt0wdQdKjyR2D12iCIAO1df4EsheFJ +O4/Zd7GULn0KPSyBMQ9bN7rpCqz0YQ/GUvK+P5LFN8ucNwpO10bJIqurqFkCs4s1NmYyLUZ4LsD+ +09bftnWYmxfDSoH9+y6xK6RA8iScMxsvn7I2lIijPGRFwOfctKNmwKde1dLD0oyQ2u4b6QqekhPb +7TXRYoS+WVZd63402DJpUcJMsszLu2LF4+C1aRevs/b7Hre5E6h4PNvaW4yvZqdLEV6xtzPjt1m7 +n/Eb75qnYamsrdew2mavNizW18buutRnEzhukrVr/PU0BLe9ClNgqFSLgKve4R1P+iletMfs1ZL6 +thGmYHoQLnimB5OUnle2eD5DlidKotrYs85TEinYfWj5lCCH89QkMUYLWqTvFBnwszy9LbRyqkX6 +ukTjjxfy/XgDK4F/fJCdEEB8IeE84aWuogSffpPnB9T4y1DO2wpVPP+46ETEapQrTIR/3+pTfP5r +V1+n1JNoxW+uG47YaDnEo1ZNCPxcyToCPa4r6krEe9zpUxDxnpfIxxPa2LvzjFcYb+GTF//j7fsA +v2r3uyIFYsLO17aqlFxoZG+WnSjWU/pEdoKFcl4b1QrS3PPeiEx0lyB449l6HLxqSszTB5WYeVN7 +kZnxKOsfHw+/WpH1Ta3rfF0TL5oR4Y9TyyGsgqn+EP7wqhnxF37l3/x5+rEGXjQYHv82BBs2S8wl +HuJeexGG2Czw+av1PTyu88kLmuuRakLP73oQVEK8OkAb+3quiCSu1VPp99nbhtOdlL7L1R4EwW3P +DU+2nchTUAhXnrJSyxN9e65qbj73O9LTk82mARIMURblUSdiuuHc2OhAiK+I1EWJF69w5dn39O72 +9K5cn+hAxAdeef+5kgjLAANIa2+VDPDUHbWCg/JU3UsPcD8636pcQBTvvHt27Xpu1A8gVVJH1zL1 +pJLWTkWBoxDMu8mpoRwKIgyK81Xbd63eqN8Ql+9OB4Kj1BUEQdHrRgeCN6BSYa92K+ne3QtlMFRV +qsXqA14VnwlktwgRKh2LzatBR7n62/Qrh9cLXkKvBQ6/+okwBEepaqyvnjcfuQBa5H6bZN7jOoFi +gHI2KdMn6hA6a9us1VKceKBDOJrTZr1nwmnuz6yBqAm2+8beoTjvUOsE6xi3nd226k723SAT3mzd +9UG3FoDznnq6fPayMSTism+Dy76+2CDm59UxhtOoPrWQJk5g/6v1eitjfLjrHfF8fPiVwD6+wJUD +P36IXQoRP+jKyT+Xwsrmvy6jnSZAeNhVWiCs5lWdIGyKV3GDsKemEkLYjauGQtzUOy2GYBymlEOw +K1P8IZilF8WIYNQeP1rt4eMywZxu7zKY5fC0w6I/Xs/qB95eanAj4ZsEVxQ+a3Bp29URXGNYY8G9 +htU5vfN2cQfnHjZJCBDCRgsPu92wIWAJ+/7TWGcJjDAv/9YCEZa+at/ySBm10P8QiPjXCET89Ym6 +WfbnCbvtZdHFuYTVvEqsX6OQVvokOqZOLU4a8FY+2bNQJDs7Kt4AyEf9hLE7iUISjKLth35tGLuT +0rkU2Z5FE0T/335q7+adK1qUnE1WA9bBDVG3Oji9T2pqQA/azjBpCjy94bXmN6pamYU5vYfzzo5N +siMCL237DT13jDVf6LlJsMSWZaab9tru52W89nKeIpULN1CdIKsXi49oMG8fowxfV6Rs83wH9BPk +hm1R5Hvz0ijrFneGlcb+2zunKqVMjwJ723wxsQYRmFUZ4c3HrvAXsxyq2fzyCT93AnBEt8bOYUtt +w8+tLuHNaxgkYnPZQgYG36CAI+ldlHLzo4WbOF545TeOD7DjSY4vYuVbDu9ypWyOX2JH/Ry/6MIg +HZfCSkIdV9SOzDouzJUUOy7ulVg77o0dQXfYYvE06yaNt7Lu9f0jDQMR3kiwLetLDZZp+22mYQuf +NtjEsDqCbd2usmCjw2qN1n1d8Z85h1nT+ivSckf1lwZuD1bilsStvddGcvJlO8pCYA== + + + i0U22khnYXS62xGWbqJ6ELSRmImD7jir1TPmBadI0mkfzqKMG7Bmvq6NShJAh4umjEWvyNtGlSSF +zZyjAuCYYnKrSlJnOD9vxJE6WAIaABbhkBtGcaR++xOUhCb1kPELKknAsUm5Ye+3fblRSWqnN/IK +ULZrp5LUWCJ0jihPtM9Uktq8UoN/sm9UkoiOcRf2dU/oEaNKUgcn2GGlzpkXrysFlSTicAuNbl7N +yWhlkEmC4swWsV0JZEbZyCTBzQ02qHQzB1OxMwglAYOkIlwsoaSlEBWTSDood1iGRPllI50Eip6y +sb199aV1paCdxHmamQTOc8PYH7STBKwXYzdvuG20k9bd89sf/u+0k8SWnA9nS4awU/is9hekk5yz +LzHUfthzRKGf8Jut0s9524e4AQiB2EifKCdxe4eDsSytVgH5913vGwhBkS3Yv0jP4TPpJBH3YeAP +VEDLRhnqZx8QUI4ZduZvzRztpZN+2QNC3Q3FtnyoJea/jlH7syXy67Oxf/hW3ItafvVf/rv9+n/+ +88c//PGP//XHj3/503/7X//7f3Dw31xj6W9Ott0sHKfEdJnZOolVCkUOgMgZedPsHtOyCoAIRYGH +WYtsRuZAY5VCc7sE/b3AsJY8yjXpgiD11hEUcS9UACgmFirCYPcslGhmj9x8WZisC2Rn4sBFSz0W +70oTWVdmCM+ujIG3IzSXjjnDNt5235dLM2QLR8ZIARYNnISdhmExO0tyWHqGJxbqC0qEMpuIbFqY +VSwsUkXcvKlIP/5Rp7GQ9wTgbK4di1sYK8C4ZkufOzJFX73FSb3dknPnIoxit3lJuKIzE1SquYE8 +1Bvt/IB+LzA+uSX5sQ5sqNiLkPpxOoViw2skWv84bxBDOO+zQfZRhzE/7VUB6jiZWMDJWUA2CVDa +QLODYSu6HUa2kgUYxSFfdh5u5RSBPAGq37AlLdwwztqO6OPtwFYKkgBCkTwGcFWR7vzcvFd2KYwC +ANV8bZY8FHNEMIl2isDZb0FigvCNE6BQvr3RRSFMk5tOTvz821yaRFIWzF5vvx7BAqW2QjgB0o2a +mArCcEtRfNbKBD8sJ79xd9yFf1lMJ0+HJomCF9IsrSEmhiye6SxYpr86g7VFAs+CkVIaFUgLnLNC +OKiyHVuLe9enbvCOE2pewIOJ9EjDCBE6cOlMqOGaPvlmTixDpCzzpWDUQwSyw8vW+UH20ACpmWcf +yHUFNcAnAazbm7+zcNJJCtWKDJhGSsAvLuC9NK3NJ9x6Evto6PgqawKLwkQ6eKksWYHxKBbogyO6 +gNeD/0ECGrSvhZe2S+1NUWG1PJjOud1J15o8iaCADYEj/np7PDvje0rUDjrRdvtlAQP8IB/2Ub5b +0sWcSEEgxGXlGkhu+89CeMwbg6aFt2dRWRWNF98KZBHwKYC29uQ0m+2kqOAUO+AS9uHyLQZdW3Wx +GpB/bQ7FK8o2i5Dvrv5XIX2+NFmXM2jk3j2TREKggRnkQlB5tKrxbAt0O7o15lxsYXTYookFx8j9 ++ttyeQxvVuImr+jd9V+IxBNAM7N71Af1fDIgrEZbj7KNiWyW4n96sFs0VT+4gLkTt++Zm77Egs9c +vxC9FkJ+p8lvD58Ta71Dtn3b/RfGxy1jttdqeQL81hkg3Ti/8ir7DugGYf+hwUbNI0HJDXsr2g12 +HU0L2He1Cw3lHLoVlsf284RGB9tC8RviK7twSwOIkQWStuf7zj4w3wBtDGATn8VAVogZinIM02Jb +sAJG7mDV4HVFT/vk6c3d1uGtOsOhbAezEkwJ6igkpe0Dm3HLCJDY7hOdB8TkOCWg/qBcEHvCqJWi +pWSvHeQh6ldKqs/BGXO75nVB0ZrXXhiAAjjPnoWuk6ECJKQZuSMEKPRhbKt2Gmb64HCfwyIIOLHa +xz+kxD2JXNq4UY3bsbgqnB92gaOeNMvs8m7VLEfrTr3FmPvB3kYi2z5NrW73WZ0Z5hyUeeT7CVTa +oNiqXYB9uxLgjOL7CB+cGBcQvqdoHO8Cy5jZi40meGahm/3hYcEKsXdYdVLo6MxfTJnsW82Pi+g3 +wYfbul/ATFcWVOdUC/pCTeImlrCVmLE6ao7A9gKtWKonjVn7bF3PStxxQ4N95TlCXNV1vWhE2e63 +o5ivYUOaUzPD+dHhC7DrJ3f9FhsII4Q+mSuGN+quGBteNlC8U0UmP730021v2/s3X5xlKRhe44VT +b7Pz9KG5hjABpi2PAR80+0h3uUXmEi4OaPHvWlvmrrVhaiKiOHdnufyT1UQ+y4c9zUfZizaTL1MU +jwD4bMsPzYxjtJE2B1Gts3yfkckLerHTpf4Q5dn81Z6lgAG19Lnz1S4vKyQmG8vj29u+lNljIupm +bJBswRahhM0uCMpBfRVR6B2IzGE96+YIYQkYpDldWUjPEI6y7SrPKu0wMa6BT+XjJlCuI0bup57O +xdkBYF9JhskWtS1dKP7HR7e1r5WHjBkoq6LBOMY1zEwS+SHlToB9wX7ClFsRqBX3zSY3i9SrRvXt +CEaf2GEEdXobF57Md+EAb3FTOFsExGRfaxLa1n5s8cDJEQeMe4S2tcMsh0HRskeB44Sr0gLtxtZk +RrxMlitGUxheNGeJEIod1eCIIhynlGhXonJvASicgLZXb13pZoATyJaFroNd6Nb0t/kDeOZst1S8 +TPantLepp6y8B6RQmEHK2cfsMImHLFbNqGnpCH1z8Pt5zIBiom2F4DItmsMvHWhDndxoJS6Ry8FD +XVk4bvuizOVTkoHxjEEdfA7zauZzSN2LQipbl/YoFnb3+W1Pak88it2oLlCF+rCfZ9WjmbM6RSou +YLYFnpmpZDMQvYu3yx7W/PNJeZCRHbOfHNEm6RkuXO38TLUd2N1doAQrfMmCT+/XISEdNHBYPorb +mIclbrOkKSuKUaVLklvmR/IJTz/w3kPaWX6h83uVExZ0oChG7coDr6Z5CYufvdBl7/zQVOzFcB5+ +E9+W/eswJIX6H2exIy4vY2WMyl2G40OkhrgMRDdc71IvVVmV6SFzoEVspf3S+A6DBMiB0u7Kqt26 +vVfIVckyr+4fgEXPvJZFuYNV4hKbgF3JPgqDDWLWq7pRkFEsI3sHVUtRUXu2nUwGRPCD2hFhuL4a +y29QO3rYw0si7FGwbokZFUhbg42GXJcykV3eQocienZuj9oi66PIHWXh5vWIqvhxB6QcQLpIXfSq +sBSyL42RcA/6hXbPzKWmSxqdlOYvpAdZx5Zku2NClYjQ06IeP4VYCrpCTK1juaE0JYCbBrUudY5u +7MsNgRUaNqdYIg/RVlxV6wwTwpRluqDVs/fIEcVzHPuOl2ykhUUqAIOjwCX7A516rQy8am0RNF+n +n5/81ZMHPoRK5h2dLzEzVx+OBCDQhr4Ql2SGiEtaHHWqPs/nRUNVH4+hVNYVRREIvpkmRua8kogS +A5hvGaayiBDP30VRtYxagVA0BI5eEam2XYrfFape9v5slZJV3pa6K662UEPPE464qk+PIs92jNmP +eNT6mGjG3odZU2AeABZil2HVr6UorDDSQhdbzfP7Jo/lLb89qfDHZkUWldTVMOWwFYRbCUfsHike +tb4aJHnpX9mtkCKX+HpRIVbTplEDUClm+5nW5kn43FRDGLJrDQPwsj4Y/s2StT1vprZ3q6sxqKfz +gxRJm8XZUEDVEUS9m1XNDShOb4zw53O/J3Sho+lC5og3e4uvlylxNYYN2rXuTosdxiu1REi1q+0e +vyC8KCRDnYnUaCtoF/l51MdJG3PTmBy1JzKzQja2N1utOj3AZdkWsKdo/lQyuuGaOO3ByhlNaJNg +HFU7Iqla96aYypCCYfzGzo43pqqFVGBcUp7aXQBNmaQheIsUQJRtPYiel6XI854419UTUaOkF33R +V2aWMngz7vEgDLE8/QA/u/WKdg+u6bY61QaJg700W8EMKbbomBvqaZYYs8Y1hrzz741YzdbeZS/8 +0PTbGiZYvOeC0CcvHLqKNdTgHml8QYTR/YhNyNIAuCFobkbBLNMZQx9Kn6xkOwIEQonhE1Ukhz8n +McDuoy/OkyUIeUCOUmIU10gcVSG8kPKrMRLk69AOZwUlWPa2ESWNtZZ4cr6q+MSXyLTNZN3eOtSA +MbqlNoeg1kWRoZPtrMGxr7jTC4pm31j8MchuDKs75dlFrTcG63/WHVeRj1A7J9aKQT+7lALMxcy4 +JQ0xcfCnPv2pGejfZB1ssAu+F5LHVDe5Cw1SDXQ63UCL+Q+G1N4I1U98QN2mUY2iMhwuNKALqflI +whrVB0KgTk07p5i/xSN2eWA8as0nqdKCrqEhLMcRclIsvjfcacizmjYZLY8riXdMKh2KNS1mDaiO ++Om/x0z88bc1j8fQMTdDA0fidaEWwAcCa0wH+2QdbmsK3DUu2e76ANW7OQ8UErnhhoD6b6obIA0O +zD5IA1TEtlUSy1UH2qCdamuHagsFdW0BBMMh6QhlmgaJOosOVhLQN9tyD+9GDSYzeiBwY9koYADW +ypMq94oluqiT9gUsXjEJDXuA9kEof9Fg8NLxUjlr4MhtQ+JL7c19UoFrCMXLitVO3ShW8jiPfWPa +ZHYGvP9aDcSuKILvBwxZ+6JiG7n7LEXSXDvN19JcO05tiaWK2Wjv26o0A2s/rGVfDW0g+nR79B9i +TbVBFMGXEvseqeUox9K1LrB0AIQokijYVHMrY57IvUMEeegCSzG4HTQf0dLNNB839WQcMSeGqSKr +MvcsQtPTINAyT8Rqv0IJG6cIsw2qghi2WAX3kOjsHhJdbV9MpydoyQ6UPUnzDKEoT7vP27UUfluZ +5Xzcu6a9zwMGo20rgIaiL4ETAqP26CRwUrYOJy0M64YmBL04ZfUdyEFpu1ZGPIu3QfDj5kp5Od38 +QYoNFN49shHb/gsvH4T+2r1R11Fbx750z5sGEEazaHcTa9PSXRtJftunVJ3hX2PmupwDV3rg5/Tp +kkfWKvlrb9EELOh8mj2yl8Nw/2EPftqWBxvI5uuDEKeKaBRon/llyFf4YybGRSUUCnZ7FXbfFn0Q +5BHgFXjiLWi9ae0A4Kx0SGjBnGRjrO9Ov4/pf5kltxL18pDEzpOzb/HmxAkHFHWEywo2mwebSU/S +PTXC3NGsI6KC4YTMGEYVvbJKOnPAUzHjZub2MRpmEoD960pabnYlIQIaI9WU2E8ALbS++Dj4ZPs4 +wJecQx1+KljPcTHw8PBcUgaAqxcAWz2d7A6CtwyZUVE6RUkAKhdbuxXlDcsGLmZNYMmw+/pOtnAf +gje6K4jnUWeTMMzcB0wg8V6u0ye9DvOeDLfEZ7puib382L6S+/B80uJO99Th1VqIblEdFwAAq+Jp +/EIiP7vtUlgE+0LxKwNbxNIT4GaJnayrhSchmj1AE6SxWNZFR6WBqOM4HMYWFm5FXx0yxZteD3oh +67qvGnljHVyC2P2YVuF191RKVsAfYTnsxG/rBryqk1nY09lTtM0+FpFY5wgoLdNjHw== + + + v9sDOoT6gLAmXB/TkFh4Dl3aRaJgr6c/zE9lANCe4xKyYZ52tV4VZIctQ1SboS+M1pML9L4xmhXh +C1bQTdng7HuzWamiEfyI/gfBltVuV7ywfX37q/nMO1j/CnybLv1FP2EmbqvnqBDDYNtXp2MbXfWH +C6FiyGqD86q8scHofZZWH5nhmxOsDM9nS63paaSBDXjzoxWWHJCUls5RVQpeuGp879CTpmlSgzOv +gLMT6S9Znp12jQcss8IThWiiiqzeAj8aWLMytMYiHAR+ewliKjEScfcFDRNFtjUUqpqCupJro88S +2hpS8bbR/ZWevSIqj8FYLGaS2UzUkVOM4NACAdmNm7pmBLcGguxJe6GFPZmUyq7BpD25LUByajKW +K8egtBKUkq9TbQMb5UGpx7TaTifTJqeHGms0XA9GLABnA6Fom5jabJFKHocKXAO1E0JzLKGug7Ej +YlvDe1YlZRgnbxJUckkTeFQGYy4YB80ujCst6UYVrxnb1AzuIaD1krJUqD6bGEft5nimkPrczFDy +TOatZj6yZlB682boefPEiR8hC6uio7p48wVgc8zmwhE/RubzlhXG84yEkk8LlpgpD3Nw18sfuqA/ +l8+BvKehlcKLbYLrHhMvIemNR6y5s61+0dRqxiLX9vjqbzk4xlDuDrZWIoKQx1fxxBNrCxWZNkfI +M1xoBLAL7n09gN3KDDy7tdB8DCWJyr5ojB2YP8stFjawVrKkF7x7M3lbCyRYZ4rYyKhBHP0Riiwc +YWYK0aKTKC+Waip8fBfDOQeQi3GlteRTAU9SkVurRdUSamJQHETOPcWqU2XihqUJPNGM7OPzv1Wv +KpoeCTI8vYEWq2BcSe7TrtSY0lKUs1bTKh27KqgMKJLyESpyZke/yw7YBgebGyt7FY48b01CBDDu +eK0QcpQ8F5y4RBuhymhrU7kPwuaM0MdqZe3Urx7RwVuts7bLi6jCTFCBXOulHGEBNQ7MOYlC3ZUj +RLwKCKROOb21fluZTCAOuTRF8BFKwJVhC2IUW1sHrHyhkmw5gbgfuJRt2uHG14q0LVGVPCzc1nr7 +mMXsyvqX90z2I40fLLVw8wLfGfwgbAS2OXbeUlOvjEPIkyKHOPsQr3V5ey8afbmQvqAmFur7eu/3 +o2b51hSojElQiFzaCay6S0G7/ZqIPHQluO6V2aq5iUXoAYh97W5wHnoml4A/nGftkOjuGLdhVfCt +1kaLbgXQg2orU0hn6dcQccA0bE8tPvWP0POpMK8pLDXzrdB27R0pBGXjIwFofuTRP3zrQGH84dy4 +YGHLvO+1i1XLLSwyVpXoJnbDaoM3pCsOEGnwLDO+NtXs72Nt2X87y/kR+nKVf7BQ7jqlL5NCe88C +LPuFFrHFgfds7y3NwQrnJkZ97Svy5oXdtZxPN7C2JysB25S0XJqbxJXyTnY7h0Z01gZp7UnMlZcw +LeXeHHEmwampS6Q+C2bhqPUp155vRfWNxXye9uWpqa2tYxI6oGdExczKjUdaWtDhPKGNHW4lHrF7 +pHhUeDVraz6+3rXF//ZxBAtYv2eAEcyVMMEH2/UzEAth8Q2EQ1i2AR+xXf0BZxF30YrUCDsxID4+ +2dHvwJFgGAL2JBiXgGHZ2agAhVktXUDTBGM5sDhbUxuQPMFkBxDQNPYBQ/TiIQICKfiXgGIKPiqg +oba+LqCqgs8MyKzgbgPAa+u2A1AsuP8ANlsjiIBZ2wYiAfsWApoJmwuxUEDdvURSAbMX4rCA+wux +XMAPbmPCgEMMseWEMIawNCAgQ3j72w5JGcLkgMgM4fafdaMLsjOE7RMUOgP9ACTd5gkBkBryjQBq +DTlLwMZuc58ArV1TqIDODVlYPGKXzcWj1qxwAo1DQrmilLd56TvQOSS3ASj9E0fs8uvNUUt6HrDf +IbNfEOTb+kDAocezrFj2UKuImPhNycPx9KFcEoD4oeQSAP3b0k0YDAgloDhbsJaRHqMJuypUmGxY +i1lhOCKUw8KQxbaaFoY1QlUuDHyEyl4cHNlVCMPcSSg0htmVtUQZRmC2lc4wShMqpmEKZ5Za5+zO +rj67Dv6M2u4cFFprwWG6aFtSDkNKoTK9zjmF4nYYl9oWycPYVSi2h4GtWacP817bMn8YFwvNgjBy +FhoOYXBt27iI5xl9jzAxF1omYfJu23oJA3yhcxOHAJeeT5wl3LWO+qRwKLYavWO2tKD0rMTTPGvR +5lu6WMRf+rBQYRZtq9gM62SfRLdw0Ci8X3tqFn59J0azULjRHA5tuZMOCb0Nux1GLrfdPbMQllfY +AmQeNcUWoYJOKvwKOHjgtc3YkTdTeAufHniFpVvpH6iIvAc8LEI/senZL5fWsriaEdFHy1ThzX2K +u9EetYPNjR3XU5U3JMMOSnObrq3ZWNGMI8WgYtW2+xvPs3aR472snejwJGtD+8f2hayN8fhe1wa7 +ZmjC91kb9esXXlv9cZnsIANhta3Ig7BgA3ohrPtX8EPYNit0Iu68FX3x9TQwD7JKAnTUQi3CMysI +sdcV14VmiEnq5HTtD8RgrAuzmpny9nGSXpJE8RoVlNHWx7Zp6oZEVNjogwn/xx/02BdUs50sKivJ +e/zqOqW5XRC+4uFw0GBbdqv2eTCKE/bliaooesTTX8l1G45Cabht7m49wlfr+nDhPPEF3WMVoVTH +LMyXL/r5ef75DwPXb/kBSZ1IdkmbC89xQcOQnYFwc5Q5oHpvilq2gASYsMhfjntzRNdPVVb7iZ9L +F5js0eIfYBCPK4c/LDf+Yxah3o460XqzHWvfKRNtcQt31xHotXBEE9PzZaHxfWm+Zb1Je+m2HPHI +VDzToxZZqXJboOYtvnie9SXGe/nqY/x4/3i57jcSbZYi/Aa8G+DP1nXSEAknMDeTc2iuel1rtFka +neuTunj7ZM3aYpZCyIXAHyxo4Siz6N+rlzkP0sG4f8xcfT9PwQDstvIniKF4Gt+z8Q7G5o4P8GIS +4vPPX8VXt9ig7Vtfd9Wy7JgzoAr2p+0f7/x9u9BsOSkKQEgKLozdEbd+ut1Mm58v6+t55fUP435/ +7Da/GajvhPsWJFfL1vpHWPsW9yilIoy+NjZAIxMwchR4c0p7TIK97cRwlvBSw3188trntqHSQpzJ +aulH24QnfxpZv9dSEpQdZzxKNYqTNNQMdVOyKmXCi4oLhB6qZheyOjMD/Ez7wh1pAU8zXMoBRNKW +aEW8Jek0SQliyZRXOymLcnp8K6ALpsCowiSYZYvErI4LDOcu6rSzC6dV0VPLDjzTYNCRqTNWVRWO +Q/U0y5/ypSNEc39IOdQHGpV7WjQPAZziTkvzOEdPaT7G+rDM7ZSDugD5aNHrEK6ZzFselj4Hne3j +GE5UBQ6HowHJJpBPaQzUWerocAb6DicjxhpxgkQUCbLRiSDwu6o+PnWFJhzuPXr5ltNdB6EmU2my +hIlS0OxVXN6WpsqbgJwcWbUTygreuLuJJNWSO5qDyuw9oH5o7mrrCOFd6lJkNktVnk5CjdRGO5bq +13IWvqJewnr5ixJh/eTuYQOkAtxgRkrPZ2fmiCKZ+RYqEJu3BgJG/H8SIE37t89RTcCeTJXwjh+v +sfyvzXfnFk5YNxvLEjToZvk0qUyBhbP9yrsLq7Bdg7yq2a5mZGJdyOB9uvrP1QePNtsBOkSEh5mx +gqrnsZlgdoSFHTq2Ey7ndRs+Hm+3hwWkEbOhWqRntAWwATkuhdtpG3sCr5HaTlDWHXUDmnW4x5fn +CfdCleTCGzONAeR4PsrZxk1a6MEkoT/K+iIUoTCUAFiGJmZ4h7QWz80H2KU34TNK5BV1jk6D7SMu +BLozFJUPuILBI4b1JDluclQKGnU8x3xI2khM3FFo0dhBWMlQQTL8edDJyHFDkCCJlskSpCfiIGws +ddlOW263vdgyCDrftmQ/HNw5NzKkWooqhCI6HzOjbH/GPTSnkw5GRT+C2ShUJ5m6AJ5EHT+YH6D7 +YB3smv2469PDvhmxzXkWQxhvZbWn2wcJ1ng8fjTk65ubfmD74qMbWb5f9ETrEogObbeComNcV2J0 +rstiji56m/EHDz82VAgN1q0YH3W3pWOkslqEn4h2voyasE7/1hoHlaKarZVumQIlTLPTTfgKSUGY +j/gPjYO/RJQJFlwjcW3UJs07q06qlOWg3EXyJYo8Bucs0qbaykQp6eRRpWd3KY3Dc9ABRZ001Voa +Hpp9LR46+kync16oFMcat/830knEUTkAYvFeNZ3v49fHgeYtaSAlXvDiVSxddt8SwM7wfNNnv3HS +aJ20ecQxTpGa1Id/G3nrRWZ9otRKpRr68YzOsG1ResR303lVFadGy6inmPXMKh1MwlbAL2YjuRWy +fA2QOk8AGcyo/5PcouREcotYs2bVRMKcLGchPa7uOM1+maXwG/EJZACKDu8pwhHSRxKfUPs+J394 +WFB1PGz2YT/xGCYEUJKjkJgMBgNzQmKpq3cmFXvSQM99jCFXWuzjpPAlardfhyiw+WM9T0m01wPM +pAUKaKVeIgjA3SNLl4SmUEPgorkOQRUNcFGTwgs52ONBVDhwxVlXtZpEIppQ/aHNSomArh6B8aHR +tcsZNBDqSkKZnQMVCT9oiwf4g9jDamQGvAfOqtEtZG4FJkaQG2Ar+ci3YzKKJGwq7ui01XAJcaT3 +Y37k8dIvQE7enc/MiOMkpcZtTvI4wMQdyUFPTPI33Z7X2T/dZb/94Sd4oGsCpX5I5E70oU1sIKiK +gC6HRH/s8RfbxHAJSxsW/UEKnQvcDrbybN3Z260fJzrSzH4f9lkkHUzHEYLZbF5FmYnIUdE0P8zJ +Zwyu6MUryLADBnQMrgYuDhowtiacERrybqYai9rShxS1gF3dqrGLN//LazGZ2JHbRGoTLMo3Cx+A +cJgjk39tgw0a7PBNm44BZ/qeDKawQhrcKxmi/595MEHuiCpoflw8GDNeuYILslsZVNC/4sm+Ia/8 +3V5XSkT25baLyWMfZgFO4Gu/gAf6Ly+Kv5HD+kvkzj+/rv9tVXqAWCBVsa8aCadiIX+lrFi9iQDc +yo4qoLYsYmPehGoVJAc9KZ/0phZhIgS6Fl1nmFqxJiKRxNBiJnlHbQiPNVHvCDra4HH1vJTsSDXS +RHR95aKZyWyWqikVvRmD4acX+EDCRu6cHFimHYf5yJTpvh2KkZ0fVyktrAF2HsGhWLUex9vzHyoc +ldEQy7eGgcytgUgDxyq6du5R/EUHiIpJv8FpaDdBzg+sVpl/dSYmEehiX/rts53XNtG50eU4JOlh +H7o86iwkFPYHIEPl5eeHfwIwbNDFPC+YpFfIqZgW++x+j5H42dmPc/PYTK3SCmrm8CCfj2/OnAfS +d4KQn/WTD4B3oxRqEUg/d98RF6TBJOgg2v1cAuLDQaMtJYl971cQFg7MRsvkPGWzEvkZYxKWalBY +j6u5icaJNQhYlzhrVxPfnOd00uhD+wQurPVe0NiD5gZ1ssT8W3wmR76qJJ/aowj2/g== + + + RkiHCn1J2ySnikjLS7UwRJzMBziHXuOnsVRMCsgHY0Azhw5fmIQKcglw3zV5Mf19kZxZYwx2BFi8 +ullsIDRVz2pgNtNzsb2t1T4bJ3b7AMbjMu9935Yj/xZVD/CHayqRhE32+Pm6LeOV1+29f4LVSsQ3 +sVqa+DZXi7X9KsHyhY8bjGZYH9H4xmUWbfi6Wjd+YFnxn7qR2UT6K+r5uLAqipANjVf6Yi7hAx0R +c/vQ9CNDIfUrs32oX9krb07QI3lHYO0SzII3Qtg+6dQ4fS9v0OJ4St5VDj37jBz4NF92xMIgtyDp +AQYlvS4Q/+h18TW0DsH7SoCLtWIROQTu+oOkNRD+SrfL1fpPWZeDtQPUhJSZmJ2DXECqpK4rinxv +VXEJNIcF7MfQiEPsBU1zu020ZgjQQRYToFeY8ZELyz795rK7uhLyUXpgOwzt8gJoWlpxCWyLLgRZ +P1gWRiqkfWaRtrTPDj0R65QnMhPaDxfOldJDBzQ8YJucxt4495saKDXE4jCJTFXVU2y89vlQH052 +GmRd+MiC5ohehxyruqqU5LAOv1cGn6HuJ8wZ3yaNCxXIbE6p34F5ttPYpSlk6pvAhkRMK9HBrgoW +I7R3y85DJO1MFCGalLaPoYcKvHtoeYrShAdPcMcVPVHjqsgnteTZNFhly5II57NuhVKWoKTiPCmn +UBVsRGDRkoZDewI5t8tS+3EhH9NmvAgf6ueBmSkR1R+si9RhMeKN+L7oqNhRfNhslp/K1P4Kij0X +8KKCdPFTYWZug63CzAki8sTCWZhvgQVcZN+BoPDlzJPvJXvE7wDpHYhne80MOPy+632rlEMBP9I4 +L39ZsEdI1hPFjPL7Hw9dwYbM6QU6cSvY8+sezzJMc7KsKdUbr/8Q7Pklgj0AfVVJvFUBLHtvRXdV +0yk3SNOcNt7qvn0e+QYad5eNt7IYpkpum2S9fOKsqI9hVw8zG+m4Ns7qLBoRI2LJaHxFr0Xpnn4S +HJkspr3XEgbSnAQYSDvTxmtdRRwxFqQzdNc3XsuCU8awbpgoz/yJ01IcLJnxG362jde6KEEIZ2mG +/agbt2U3W/VIxHJX/8RtcZ4jKTvq57lzW0Sw5tHstTj3RHBblGHxArYLzfS3T9zWPdqS982w3LVx +W/fl7ZobS4PyZXBbAo+Aqb5RNsp7t6UGOVAXGuR2oui3wGab84vuSthiRjjAFjNBsHVXFeFr+JMQ +FMvlfrgrRlgo4dqSv21/pOiuvt46v9t3PUtIthwfJaTFdf2E53qXRvvM0BYK+MWynvyZ13r7XRY/ +JeNu6MMxyHZCVPmvvtS3QszCbF+Dz7KebtJ/wmP9rsfaeKu/ymP9FRzVX14O/2/4KQv968GIDYb+ +lBKVyFpp8aLrKjfFAORtGSg7/kA98zqcUS8ju8ZkfxsKkQxrMsaVhVypMBJrWE5HdDq4NGgt2nX6 +XoTJoE4+RuMM4KzFWSwXBty65NKkr0k2Tv+8qoNBb4b551a9j5RoHB1g27vwqOTidlY7goZWcmoi +O0KjK7JPVBKYMjE7XwFM0oCzi6kB1/RISIZ2Jpc1gurkkZS14YiUkKtupXP7GZRNE1X4USc1HJNX +WVTmArHTYjmY8GFUB1mzi3Ad30CHPTOHkRASa2qVdcoeAKTL4ey4DNdLnS4fs/2UXBnv8EFn1Fbh +fjjl7roubO+tcuFCJ5/34p/6kOy0faOuGXb7Rs0c5/AMfFr8B2N7Ej+jtIhvYzQYlIj9pw8xmyu8 +DhjSL2bHKSfgRNV0HMPxDIJdorfGHiE7dhVk8B7EghmM+EkMcl8uC3Yd4kqvGpSlLHnlwpWKAy4h +hS4CJctRMl97o/Uw/jDbZQW+GjqNd3GNXuRzKWOhp6l2ov+c7rq0a23Zie2g+yuy75xBVWTRmdor +YiTtGNJ1NNOyJpbMW9pxLgJcxTygMQ1m4JLuifL8TU1Ve+SLrfaLmmffHq39xgijx98RkKDumb1t +s9ooqJoNVvsMojEy0Wxr6pt3fpod4arIlmPQ+kHejTiB5tA3i/0swDM/TSPW9uwHo2r4BGAfxaJT +d3UNJT77LXP46ip9S9IKzYpKLsR1f+pyjbDGFjzzpSpWMEKCajDkDp0JEfkFtdCYvIMQBo3Ab+qh +nRQVEAEu+aef7lDkRtkQ4A178nuV5CnjVcPj/aqnOwWkaVSwUzrpRl4EP7cEe82rp1+Xnn26Pv4d +ddL+5qKpaB/gde5cNPQs4MfttOJmQE+vUdoCZrLyFixUDiq7unrWTJ7LiFqQj3cFgtHFK9wOUBkF +mD8/KS63btv3Rogec59lYls3Q+2WCrZzvxKZFmm4ncc9CbDXOlQjum6PSrTfCt1Gu5Vb6lvErYA5 +E6AY/eRyVKk9dU4zczEXWw84/WkQwaUpdAf4hIPRkKwbTtSvGOM76H4wPZdRAkl3QZj6H3Uee/mI +V5sLqqo62xOYeS3EGWi6fnz5hqegqgQTdKBlQeKyN4dO2dzsx3HOdifCC8qfbMuRKwqKJ555CIgT +ygm0FyjP2YstuTu7bSeqsXVAuoSAgMbTbF1qgM2yevelRAw6LldkcKtOrhQV/ql2DemJWwoWxRPF +PvRu4bLWi7B3I005nBjM0gdMd96Y4F1oEhg5AdB2FJYVYB7AcHRr1SfBOlGhfXcoEvztX14YzuK7 +91ryYF5OqLWOC5xO3B1/Puq04nfqDgQlcNJE4sV7TIcgqHzJi24MzRfvRFr0AV7ZL3CPj8TC4DGp +XjSx2ZwFTAefl5legreM6qlmFlnCzCye/CQ3wX2ZwwejLuZ3QBI/Rn1W3xcWIjGh1zJ0UkqSaoRI +zxNAJkjjkpNj64aht1NdVoEMF6piZbOtQDU9P0rNtGxI7Cwkc8U7RRuMChNmgWH1Am1jWDmp4JsF +nbJQpaHMAg0EW0GVDAkREsJ0VacJEvUoCuhoXWZIZpjPq3AS0YHIIAirAjrRemewlKcjehhJgjE+ +S1Ply03x28v2gQPhhrLFvuk+MyCwM6eWbhHW2DsPmQHTL6oO8E0LWmRrZqD5GN0TdY907TMDTtyB +M4CNcgGLJTPQDaogviQEuQN526YByPMwuICoEdFpTANQok0MrRZmj+8a0wBdlxHmwqyYhMeeaQCR +pXSa1zQAMSXbIxYq03/LMQtA4BbQlRlH+K7OfRbAs2kUotj6Eb+0pwNAZJBPuiHYyRITW9IBfqkP +XFg91z4bQBeqUSwu4B9Tj9lAbqO8Zx+dobyYDdh70pwhb/igGLDNBjIY7pzpIJ4MVsRsgCtpMduV +QCM9gn7XwC5ZGtiK2l+yAV6jkN9mIaBriNlAVleKL9zM1ILTGtlABjSuNwT4hpW6ywZyh1gJ3ZxC +Pe+c2UBmxuAWpvzMniW85wNf77Bfiqb7CqA84XQwlSPfPBMCc1egsS2OLhMJBlWQ6Ge+DSTYcQD7 +qge/uXBK/YaXxJby/UwHoEk3B/UA1N0S0La3z6RHtfvLGpzgejK4P3G1jOn7TovPVm5DE+iA4MTe +wQmrmW2rN0AdI+cJPq6RDXRCwCrx9J98NP7Nohiyw6M8c4ETVuPjiaj7BY9mV6OxxyplQj7fj1SA +wZMGMfGvKoD9W4PA/11mAmKcUr0LDfuStpmAxTOOe6ZvLtzImglUNRIIqcyGYKZDJsDXygypoA9X +ettnApXGBnAOfEJrIRGoufhME+J+SXHXkgjA9SeaaXueW0nLJg+gdm9+QgbkhpY25AFiHlRjIEPV +mfd5gFnj712dkIRtTTEP+PL9zjygiq2bA9WMyPs8AC61KgKxzp2mmAfAkibqKqD09xXTALGl0bdg +FuCg777LCaAqE7Og2N96ijmBeZHvlRRvpAKQUepdACLHB+9SAV5Hi/G/WHogj4elp4NuWyN5KLrE +22RhVYdRcpsIaKGexBm2UMu5yQg4gsBALww82ZoQ8Ek1TCX1l4HGCgkBt6OvRUju0t5LQsBKFVsq +flSc6GtCUIEeCyTSoNRLbwmB+HP40PcFZq1tEoK7+3TWjTe8XhICYjjah/h+TcNtEwJadDBD3RoF +2yQE8JZZnlLgLasMlYSEgL6w6L/M8BMA7RMCVqRAXJoyTDUmBFBjSeRmzQO+3hQzDwjduPDZto1s +QZOAeSbmXZjAWxvZmjbQNAZ6BXrv741siRTJwFjEzNDMtpHNJgNWE/rXwixBmAb/jmSJ1v61Rt3m +ede2tUb9WGMH9fJaYttarDZ8I1htTg3ivret3UJwsduH9rZtaxSzLkH84JdMZ2xbc58N0cWDQgH/ +sLatAROe2iSdbZL3bWteANQt/CY1lv7atubb3uL0sgc9yErWvjV3Cw0gu5zH3PetsUMFGwLThIzK +2rfWuGLlXXUQtZu+NQ9pjyMyJd7Uvm/NM0H5B1AhifN99K1dtgmhtLMwMxj71oXc5pABx0jPCyx9 +a52HrcN5IFILDWxeiW+ICxr8TQN7a+n+LxrYX4XysYP9zVvYCFrYXqP6vTRgf6L/esKLejLpUUHm +7RrY9la/MbnZafXirljg/+ormRFgDIryOt+qfta//jYa2Fg0C8j777iUPRQUBchpXpLy2PWvf81T +2SJCms0sNWy0Z/9/Inz/vW3pv4fSfUK6mcTeTCUmZF+7t1hZs/gWa4Bgb7F2n6CVAd7U0LQCMB1q +94MnQ5OIU3s31O51nhvKM25+VL7five6F4YN7V66SkZr8T4x/tBTV8037Uv3CeojRsYadvCMlft0 +eWC6LdgnhIb7pk4fXuenhfoEN5vtM/NaaKCe+0I9uDJRA3RxUV+xUO+wMRkslLKyCvUA31Se6uQS +g1A4FOo5uZxybxAv3bFQr5ukXtWRJOGrrhX7lMcMAM8/uQtCyR5clHSOe8c2nI+SPbOCosRjZD1T +JV5L9gILCh1mKUIehN2zZL/5+VKyT9IRk+D0eYiKai3Zb4FXoWTPu6KBSfJly6jHkr3d8/ebwdKO +ykNusWRvCZaFA0AJC3LEbV+7N5Mg6lNoX0g7Y+2eMkG/JBGalIWsNfxEDDTGq0Lp3iIK8dJZMESc +HCv3dqyTI6iDTz9trdwnok7y3S6Gx7Sv3CeyTaYwe5aHiZX7JLDTpmAfNsdvDy+i6Yj//C9yDE/O +Qrh5xPN+W07IQ9iq8BDOA8o6KhGWrjWys4MldX5YlufxdD1EdKKUwUwP8AV7ofY1MhSzhy34at84 +ARmEWp0RKFFsURtmKVfZNVv3g5K4aiQB/AtUg/bWzZR9hzbbtghLSGTeYhkEm0Mh2haazmvHQMoM +OXXSxia2xzbardjCsJjs5mL2z49M+/08x+0wUvvYhSxLJP9SSTDjC5gS8QuUrC2JqojMSm5Bp4A7 +nB1xwZ0O1JK53DZyb6Bt1GiQI+i3W/xuLw9LXY/L6dx5L7YGK2F1Jpaozm/M7NnFG+I50qVJI5gP +4cEcpx+J89WR+7E1ocEbdqodSWVQ2ZwqBCx72opHkryDBIU9EaxCIyUN2usJNd8yQA== + + + V5a3wBV3Qd1sIa49y/dCIgOVLbwICFMcaBBczNpiWs9hemDvpVwCGunEsFwHFMHspcuVzCFmmZNU +oK7YLq61YJ6Poxojzc0CMVHOo/4sTJXA9gnmU9oBzZzWebhClajy4YK11WBf5JamsB7EIp/COBfy +u8wxZnipcBcV9m+EHiDcABei1MncFCtHM+9VPH+nSIW9PoBumznVXFz+iiLYyYz2byPf1W3SCiBH +y8T8gJHYC9QnKdyJi5h8qiBGP3QM7atZJA4KCYXGBvW55Zp2oH0cpr9s4ZGCplEu4v7IYGkKiLXO +dh2ZFLuuiK75OJySlVG0i/ZFLhI7s1sBuZ1HQYMBMgoatpUzQyu0zmBBT2O7hAQs53NcyVlaVbfw +CuB5M5yWmbWinkHPjCVLzIWPtV1t3x7sjxmu9kAEJ9f6uaVwZDYvdeG0buKBqmTU014oEw6zQKgi +QKCBkgiSOUqdT5R47U0J2GWLQZ0l88AE4yPtTdLvE7vVBc4q8Qqd81hO/rB8vrNEmetrdup2lNv5 +qA8RF4U/eOGojC0UftXGJ6J8Bzz8vpz3q/oLj0dkvhmFGk0m5jYuEI4aFU37L6mT99/Fe3gHw358 +gXjEMUsQGfsj2ynIOwJME6IPoWKBKZ5KKRAHWH0plaDp3bUJhgoJVD2U1DIyYVI6XP7As3aaWhWO +t+aaPPEoKiNnGYRwdRDC5RGxnjUpesaSUwSSC7ZI00IObKklDvl8ZP++0C6GW6uCTU3q4ZKhMIU+ +XRw/9l/5/zrCXTqiLPdQEGxiJT9sOV4y1tg2hNOhhhnbzkLHjHu0JYToCDGviDmYsiyHS9/AMMHE +8S2r4Yu7YRJuBdpTzYYPC5+HfVg4xe2pARAipAtKkaOLCJOpTVDU1IMlD8rNKEkF4Z90nu78+BZG +E7XZeVysjizBDOQ99CGO6g/Hheyu+TaWIOOhVKXtskoHu7/qCPaW1xOL69cgZ3zp/GYB7N2gjcD0 +txRHaKxi/ikfkt/ADKJCo6aoL9S1LPAilIJp3gz7rRrsb6MULxVRlDMr4xZUHY+myPe4JEViy7VI +MwXUnLsRhaBmeS3YzBJmlnwiGQ17XkcwE9yoJY4qjvntbmYL7neE2eygqobczc6iNo8EgEaLzTAe +YB0J3KDjwoaZfUwSABAhq/l9e0zmO82MHpgoqHGmI2gDSnpJGuNWjCrz0xOzAn7Dkp/CpmfWvF2a +up5dKcMcJKcEXiBBOw9UwtJkZAXHXuJoAjPMJCuaspVc4n3CXEbFSqPpzL3Y8rU02cuSBJL0UzBc +CrhuFpyc7ukZagO7OWbpJTxQ2Vt28kYa2F15Ta/6FOP/UIGBU5zOU0LYhwFVixIq+i5SDiBLgmAr ++SiS2JMaXEL90agQt/7lSjZaxJnOuS0DolyXhWA0HW0Igmzd7+2j1cxK+yNDkHpLWaf5nVx+J0wi +ePoAR51MSbp82pTG/MFbsC9YVRG2LI/K4cHkOZHV4XQ8ZgjNdWlE/xzngNgMHEcuvq7R76kD/HaS +MFNotWUNu1xi2NsyBDbeIUVvzLSQ2eYWCDRR2DOLcOO479PttlIdCDEL6x7dIpKqxmI4HAOD/fcK +Nsx1N1/g8MVGoUAlXq6kI2xNF4ai0AhqOHraKaLsPhx1cKAjwlccAiCkXmfJL/Ni+dQFfBFARZt3 +Q2DnIfooe/VQt196qYi78FIt0U6K0IbpRHJmjokBj29aSxYRVp3H6yidgn/VjSatwybVQ3j271Ms +EuMPUOvR7LKlAlHO+Ojjj+tT8ZGU2ccpbTg1TiVWotiz6MRs8Qgm+jW6Ckqd++bnTYxTqiIzwLS5 +cjhie+PhqPDcQIkIE8ObYg4hM4BPcVc1mN0bD0Pn4ctVaK9oX9J073nz9e0mgbBTKYHf8pPF0/KY +iT4QUk2bRVhH9RQ0hsbhwkKGaQobQO6gmGy7IVoWWwZXwhpsNhZNVBwpQmkH7Ebr3kT52N7qdmN3 +9DQLzY5DQX4wDzQW9UlWy8LgXk2fGKZEo/ikbmdu5EjRwKlKBCiN+qmAN6uRdDwZRTl8M+wDG1tr +cYrHs6uhpnEJiwSpEb2haOxpvkGQydg6MJm909BjsvISXJR40dX52JoQxdotGrHrCu6Le4RXzlI2 +EPV7JwjBN5AkytwCXgUfmtHRAAOGMBBNveCHMwQttFAtJ9KU6dafZ1GrAh60hXvfm7ggXxPGBTBH +bnCJLbKZaVsEdgSofR0RQxRAggwUMoZdRC+wRjqUfjQiaj8lD4/REg/NSAMPrdLONuriPDcTwxnQ +GlOla/QmhnWVBhtN/jsGfhQP7QpIOlZV0Z5RY8kufwu+ClHDGHSWkXTbWjobtCshbqUSl1QPtBWm +tGAJf32x1VE0bFWcKjGMzqdIUeE2RDH2EYX/WfdpDgDtQ2phSDiN0L1Iygsbwmvsm1Dfn/AcT1j6 +PmVgT7koHMaTlb6mHvAPygwm6OlUr1/SF/EP1q6OOdTFb9kPKAHBKpNgOXWTPGHD1AlFe4MAfuRd +8Q+7tC0cNbM+IBI4DkqcN8pdIWGEt3DwjBCY3Pu8s0JXwm7LVPrSJn21T6zgxHZdAWHxM0dsUulw +VEjJoeVQKQO0LXpfIa0XswfyZcBVksozm6qAOB8ZSoXzEQRiPA/UwOzrY7L5z3oErCun8Mxmoo7P +yhn1HNQrGULjXVnEbtRXPf10zMJSWGFEV8sOE1TrvjyDwfdWEaBFikSjuhN4UEJdSFV4ogKq8CC8 +t+Wlgqom2JRqV7HHj2Uqblt4WAiZQECvpS4cJxLZql9CSb6rmNF/azJVyXY7ONu18CaOIDCjtqlh +bA21uyKgJY0H8aO3fQ2wjHTcbKJK97GWSOesghq3/UKrKNYjafaAvlLB8sSNv5QzMcu6z9z4cC1W +Q4Gv66MBSa6pxHpqRj6WJlTJ0oLb12WBLFNyC2Vdgbn70A3p9CXW0jA+SPgsuxcaCvsSMz7IFhae +iqpKiRVqgeZhTIB1075urHJ7UHR6UGTLd18tJzBquoBK7MwSeDdWehpXqM3jzguV5l1lvxxpNB2L +1GBjh4DzCxPG9k+A0pcmA1078vebchKKptteRTzN2vPgDV4aTAAt1XpomxDf+HjDdZQEOHrXfdH0 +BU2/LBe96eIIYMomywW04aYTJFJ2WYQGI1GJHSV/d+DqDsFSmcO2o/J3WsSwDNciPtTTw2seGotD +V5C8qFIEYwkQjAk8CtslyzFDdoYTKkmEzVpbtPSE8AdYpjfMgyOCW8DtVA0IVITTijQF7YnGvrT1 +xd74yLRH8GdF0dUtE6abNxNGB3Ug/SHRhfjDNjwhcC4u3mZvpp5AwjwKbSMKrW4qSY8qPV8NvTcH +G0Llaq/KXoptMPC0hc7NIwi9JbrMYKjeXIF+60avuAofwCgBvOFUC5Mwv3wjRpap+yE49WfdL5hf +W65mPLF2eqoujK/F3jTps8p2toDIeWwf2u10tzDFNpomo4kJaJcrLeLdVZpmkGOfEoL1GYv1NOpv +omhnm1mrN9xKczJ2xjIaAMT4SJYoaE4IuXh7I8OOLG/Gsh6NClE0rHz78ILFXUAG2woKd/+ksyyf +qd8a3AZccWjUP3xpUKg3T11uGgubFcMDZVENnnamsa3Xhdcx4E2zIgx5fMS1i/QFRQAonQAkxT3A +3P+hgSTEPoenWHbSye1yd+IUuz/iZrT7t/CA4YMzKVEOm5pxG9IP+t1lRiPBONAR9++I8oJLLr0b +GIvSFV+jtA5uJxqqm/EMAL3m1o7SHlnLu72THok0TaHnqRvTi5QWEIRiSSKLN9pe83NdyxDFxl4+ +sb1I9gI8paTRCZ9XN1Dw4wjEZE8mH14EMI1irWxmysLAxwXefBBvEYiwNLnTyObltKSoCXICFWam +b4PPs4yGWgs1OPh4Hrnku+9EniZrlsveM+s3+F/bJ4Xk1xbCcWgKb/HjPOMJY02Wt3oM4b2FAyRV +SPfOAAJgh9yW687kGH8QW93tOX33Fr4QqiI8SahamAwLIRA5iiwLrU6Rlq8RFKnqpTxfIOwySi5r +JGaO3IJjKgr2/IrE1mjOHsn37qHcdRMViopkTlovMSVjg5rlgk77dFjYe1jK6KStU5CHTZDYNboF +leSjHhWMygxv1yj5dJbJGGCzHtfQXEOFif6t2ZQ+cTBrhN/vcco1J4AG9yTxIPCAuzDkFlB2oNVi +dutJ1RUyFFtHmocOyQ1svKCjbfWVE3aXkCQBQOYDoUd1z1gj5Fh2G5omROXeKwxLnlbIGy8ButC3 +6jHfC0d4ZrnkjZvzrBkqWg+q9IhGou2OAM/N3oMaOF/7HBbfh0Y0u7yK5zbk0/GINS2nn6FVCH/u +XFIhvWcy8ZLthae+x/oBeCXgaxTlRFgQDtAUBLil2hE42RcYMNAaoLCkFpGZj1Dj0BhSd655Whax +RMLGLRKa0OXSI9t8K7WAptQStBSMQaqPUK7hCI1pWNxMEBrLPjI1qB1kCvIjrV2rR8DjvJYm8hEn +UHirO+EjFJ5midWmWLYqGrVKIs3r9HHnengrf3F/yELcSYCMWEXjQtrXImbq3kQOxTj7St5OSODD +ILNbC3o8I3XDpQjIP1ctLtutFlc8cta3UiJHyWHxTwVMzlqOxGfI8ibmKe8rljWd+/Ry7tNr9DNC +eVRKLIXib2cCKX2EEivWSjh8AWC5l7VSyxHMkM9U6a3QW4qZcMALtgRu4AehWFzGcBeIQrKcWHSG +kFdjUSmhLD6TsqV4zY5UBQX9aQXqawFcWiZKL9/L51gxDTWYqUUUdOy7pQjPNnMvWoGt+YzSWyFf +0EcqK3TzsdRrP0Bv+9Y3uWSpZw30ra/AaRhwxIhZ+uBuVtpgcqYp9jE0bIXkdILip04eiqUfwqLt +5InprLaMro/QU9H9VU1dOVZktmR05SGmOfs3GCY+IoMg/Rp8xm+dHy1aZirtaik9u0YElEwnFab3 +ZmFo7TkRANKXC+0qcRhoVt42C6z5oe3Fp9OwCUTcbd722j7DK/l6ofUiOpKlBafRsEuzWBb1tNjJ +41W0poWJYshw3GtHkAsx/oz7OzVHunYV+TK3lhbjuWXTncSM+GB8BtU7G633+BLdWwMJJCJWZu2L +Iv3DsDXSP92fdT3CduEp1LXlkQClt/3V8MCh1/sYLRsd4iLGhM7Ah33yOe43+sqPg0cDOp5+/mF7 +d/OP4eHWPnl8QWu/ff9+w/Bb+E6j1RA/8YoY2C+VFXkQVtwKXoiLdgVB7Bf/CqaIm2jFYzz2X0Bz +bLdvQIWsm38FlgTzEQAqr0Yn4FuCqQoYmWDuVqTN1moGwM40ugHrE8x0wAxtzf0KPVqdRsAuBb8z +oU9btxWQU9PpBdBV8JcBvLX1uwEEFvx3AJKFGCDg0V5DiABnCxFIgMSFKCZA67bR0ETmhWAqgPpC +QBYwgdvAboUWzqAwgBJjPLmCG0Nc+tsOJBnC24CxDGHyn3WfwmWGIDsgOkOgHpChuw== + + + eD8ATEPaEECqMfVYMa7bFCZgZUMqFGC2IZ2KON5dWhaPWrO7ABgOCWLAHW8TzYBfXhPWiIH++ohd +8rw5aknCJ5w75O8TBL5P/1cMeUz/A/w8lCICjH1b0ghw+LU0EgH1o6oS8fi7okxA84faThgImGWh +ME+wqyrFuQQcYxhnGNWrMAyxLX7FoYq1iBYHM9ZCXBzweCnjxfmQtQoYZ0zWSmIYUdlWJJdBl1DX +DKMyoTYaRm5eS6thYidUZsPUz6zlzlmhXQE4ThqtdeQ4rbTWouPU066mHWem1tp4GLsKZfUwvrUt +z4cxsFDdj5Nka4cgTqTtOg3xPGvHIg7HrV2POGS3657EYb21CxMH/tZOThwc3HWE6tC3gVCleiNs +6SzpqcUFd6Ea3WJ3SnGYvrU9/9X7tsfFigaDYS9wRPVrqwxW6AJdjxlRQBKx3VZpcmBLd8069Fwl +Q2Zmw+K1Fpt+vHt6iR53nndsHBKXE8+uXccZomXfGRkbF5uXtUMSRtTK0Hvb9EAV4Zw0iwgqIUBp +JfZSqwpotmROpPjo9qz92Ja6ZtLB4FGl23V141nW5nC8k7XBHJ9obVT/2L6ZteH9eK9ru1xzMeGz +rG33+GnXzv1jZewa/3FhrQCCuDhXDEJc4zssQ9wrKyYi7rcVVvH1wC/P5CPDL2PChbHuSix8XChZ +rUviT8NpKVW4KENDvl0to7SoAaojnss+1KlGoIVZPm1eWDqQMjVom/B35uUPHPx6hG/yQ5Q5PH6m +uRVOA9cjoSiy9wQVdj1pLhfuikACbKkq+knp7H5ph7Pc3igueCjCiPU+zJNABGIHiGBg8zjrEf45 +x9sIP48v8nbcgogboJn56ns8P+I//2Gg+xmLP6gFCShpCxnBTIvKLXx28op4EPStqvWcSWXNUekq +h28gc3/lytfzDxQi9AO7R/qxP0btbv8roRvICsAji9JpuV484P2uf4zS1ftBtTg1nYWFZjTahkzI +ggf0PVHws8zmft4/liaR4CezFeVRepSaz2FfXC29+Ov1vYU7+Or1/3j/WgfLyywMpBwJkMRms5HY +wAYJlOVQ93VdI1k4ZMgkuuL/dZWRxyV1z88TCfT9IiXw16CJ0MDg18N5kFsQRxJcTCVuF/wgYsX4 +QUtmzz1KKJxl2brxRtbdHx9oZ0TW1xLOEl/sYsW+/D7L5ltXKEMMqqd1CFMu50qOR/UiHQkwuALT +PEaREI4krKDmWHN//oExEP0CgtVS3rbf5lfLotxccD1ivfEfO7PBbEUTB0WCesZ5w962UKJETPbW +E+61Pp/AYgiqGgxdFHPPj2Gwt/0bfx7f8HoLX36DuQWhBzTTlal+oimy83PmQqnQUIyyeCF+f9U7 +gCYzQEWECgTOgm5okCkoVgkW36SMRyU/tQPScNNgpgfm+ipeaDso2jbH46mZgCyDSgS2KlExJfRW +UR5ct0qtloEAi7Yjkjmovg9pJdtMpe2AGhR0VhuTRohSuNTa4eQtFqVCKKojZPwgiT7BATELYhtC +iJ/Lb0UccRA+P8Ce69NaaEuhzULbK8vwUpvI0qG+BGbozXGFKEEjf+t1E7joLLmFI00E2bxiwY0H +SzQ3I8iDfVKaX87tfTtbXIWf2s4reG8Rm3iTsK36/IhPiUaaoTZZUXL0CYHBNolWsFHy8M6A12SS +1/zZeeqy9Ho62MxeQ3t6FowOoSRpGPHcw7WorWrmpnnCN39VVZWVpLYAhuv1OnXGIvpM2tef3Day +q4TDShYlZLM+PmNhKrldNGbr84Whx6Qn1nfqn7zv5ho9tAmb5yzrd1PayI1CIHq0zafvk6LvgkT8 +sxXUboeeY/6Rs4wLsQ26q4PKKjs3LOaWnVM9oSckcvLdpqBThxVE9qaeabO5WneQO6dB7/axL8PD +7na12YpL0rKJLL5tbIPE/8CwtIqidDQvuY5uO0HWHf3pBIT85bOEG0E7Er1gCVX3a/M8hD5y5Jbq +lFFLiq+D8IdxiILaueZC11dapXaXVJc4dKX10+wSrfiJC60xFoF81kdcJQUSRzJbBs7qvVltsGTR +t+Q90ISaq+39wWETG83k9wVfkoOjzG1A1r3ZOLl5o7OCbR6dn7jv1ORjhCSDKbk+4t61K6l8Zele +B+oWbQDgM+IU2qNlMpcGU5Jdn4vBGqC+0QhJlFV4veRYuGnDjsHASlWXwGg653fLF34ejOd6B8EG +bx9kmvDwHoLRD+8yOI/tN1l9UPi0qxebi2J1gdslFTxpWJrBG6+rOzj17SYJwUHYbCGuCBt2fdLt +vg9Bzmo/voyTvoi1MGPikDw+/H/++P/9YU+KepX/NA5JP0mCiqosAwXd3i+aX/7j9R9h6YQtuhwq +fJrxP6/i5V9L788+Bb5eeDr/8ye69v+/IOt8e9E75s74ov/umDoD9fuWqTNw6wemzsCtH5g6I7f+ +jqlz5dYPRJ2BXD8Qda7k+huezkCtv/J0Bmb9V57OQKg/eTq/fpmfEulveToDkX7g6VyJ9ANNZyDS +33J2BiL9wNk5ifQDVWdg1N9SdTqlfuDnDJT6gWkzUOpviToDpf7mPO+U+oGwM1Dqbwk7A6V+IOwM +lPqBsDNQ6m8JOwO3fiTsXLn1A2HnyrH/Rti5UuuvhJ2BWT8QdgZm/S1hZ2DWD4Sdk1l/8nR+vTl+ +e9lGbzKgmS4T08cWSTD2sVfchev34AjUo0VgtSrugmexhcng6VlajYq7UJ94V4Ug7Lj2irtJCk9m +BRq4Z/p3q+Iuhkc98sbgaN8o7qYJgrDtjLr0KLovkrsJ2LOFb7ammH6rUXKX+W693aC0C4xYLC58 +7kebZkjuHtmrUSSXGcu4Su5aPjSYI5iUxv6ukrvcm9twy3yOwQczJXehVfBFmxlMzxvxXW6BAClo +7h4j8AJSniaBaNDclbYZFfaOfmndaO7CsUuiX/URNpK7qI/KU/VE33dcaJXcTd1DPFtWttPSRnI3 +sT5402YKSNaj9u56hF9pFeHFxOKczAR2qScHEV4zXhJWM0/XBXIMaryl+uxCxfJO8xbUeMk+mKms +BHQYr0WXl9FqIOe1sr43wrzrjvztD79SmPdNdxX4dmNuq+91eW1DvsnyooOxKslaHPkmJNteVHmz +EJASki3QsqDGQJH+XlV57RVW0XlN2doMHjPK1u4u9tDkPZDUsnzom709Bk7BfeKIrp0oL474VZO3 +9Z9+NJfkrbZyj86TYdfMZJm7Bcn0x1/3ZA893qa5POR/kYtR8RpfkH+dHu9ny+LvgMX/14hwRb27 +neeLipKr54uKkqvnC4qSW88XFCWD55uKksHhDUXJrZsLkpLBzQVJyenmopLkzs09JCVXN7dKSgYv +FyQlt14uSEoGdxfFJYe7C5qSO28XNSVXbxc1JRdvFyUld94uSkqu3i5KSq6+LGpL7rxdFJlcvV0U +mVy9XVSb3Hm7qDa5eruoO7n6u6834i9yeNMevFQ8or+LupNfyU6Wj3e1RIvPn7KTlnDV03Xa3d9Z +zkcQHmQn7VahfXkoMzaAy0GZcXOtF9FJMKXt41uVikyhfgbhUf9MdfIr0clPHsxFJ4nZLCt+urtK +pz1qTv7u53ooTgJhtMOezg5k9wEv4a+SrPlsSfy78XVqv+yE0sQTUBmBvm1Z5LoRSqvH99IZEqzU +mPNGKM2sn2jjLN0/xSK1VUqrloACB7B79snKxzjbIAwIAmlhlu9VIM0MjzgkLVA2C3tuBNJ4EqrD +9iRdCpFBIE3oVo2jm/U6p5T6qpDGyL8eLzkHRhBI48bFGnDADrjRR6O1oge5MrHdJ/poMsmZ+00+ +xhX00eqQTEkZlrt7o49W0dpkXtOyKs2wbfXRahpXotpXzo0+Gvp+atUV2+Mt7SBNC0nDVh9NJAaa ++7Qd20qURysDPgjq7Jir4U0njRktl0wBnNvLXifNh5CaDyEBOg86aQwIuXjKTdZdok7adpP8lOvZ +yUp9exTYX+Lojczxz4ijfZvqXnMn7OW9QKgTyJjpuj4RSHu/HJUpTs5sZGJIy6JLi1d/1+U6lZTv +luofGkQaxjk83k4m7fc+3kYq7a/3fH8FvbSvlsjfgfv5/YJp9qmxkRb/N5S81Dy5CCXtBR6ADz6w +190Mg/n5ZJ7mTH5Wtj+efjRa+DivfRnzL66PhhKRnYy/OJfZBjhF51H47MNSGPF8MUHObIeZLjOh +wIku6TOCnOj91hBsdsBUGcKYzSz14XBHipegDMlEHk1iH8CqmrFxBIZwh53o9vRuNG1hi2KoaCuw +pu7IZFERZRCNZnu6m0rjffjIAhOekHnZ+5tQo+otZMat8EOCcdyOavV2NMEzaWIbwmPAZ/BqjITD +Bn3Y26Z2DaASUUm7gwLcf5x/THYc0PmCh2wTD0lpobsPkAU9LATLkOtQQWWss5A03C+N+w4rDZ8i +n3TAh8e+VAzHLW5/28eHWC8LETGZAF6cxsT+9uU3brf3XejT5S1A+SbfflLqL8/3BwqxOfChMFO7 +f/0kXnKAgLCPtvmMpEJ4H0p3SSjrdSnYLZxaLKSK9ycrygK9w5ssTF9dm5VJYEOf3wIb8N6bRc1P +ND9NCeoT/OvmNFClEblb7HLridZbIdLjJZtZLCKTCU/kc+UzQnt/HzT1EUamqd8U4K3vlPi+aHag +5pOwI3wbhqwa98h0xYQ6hE8LMKDoPi1SUBi0ro4KVYrOY1aGWdWwyirhKaO9FnzdpT1X2eFICSao +QUqIemFZ3DT0nHs9p/aKylPvizkPus2Tjirsq/DzsDfD9cMe395+MBXhNQQrE15lsFbbTxKsXvi0 +wXKG5REt8MvqmnY7LMlo8tdl/ZXnmK0xgBX306W5oB16drDFquQHva7b4u5dWdt5mRwA50MZjRn4 +fIrJgm67OdPuROEiLrLQOuvR+b56hQkKIhe0UVWnqX7QfdqwVU0b5jJKIhCwM0RkQQkohqKKm6jC +zXnaK6OXfTv1RM/maP1WRLVcAOlJfuJ2hhwgEnhbgRh1iqqRVL+QiGJoZZu9YG4W2CVVfHQSNI5K +peviRTDiZv9BPYhpbclGgKu6VUPFFLEVeJLCaOmRx5PUoQgAYeel05ywlFsofjmRP89/a3C2F4cF +3xS87DYLRpHWrqqPnYQEEVPSS8ZF4TtitNevsyhIYMX9Qo1ybBcfsdYpXqOOT2tuoPBpTz4FHeAM +ZLzBDlp9YLegKlrUDB6v7BwQRBgs9G06QBT8RYVB0VXtBL9qjUqHV/+cp7rhs4r3mm+tAqRQT5+b +Y/rcbHoGYepXOv0TWjhNE1lPztgzwKlD8PVr8ttXjW35bCUMecxW9urE9I5FUfH2VOXUcizCdKqE +45mu5riHBk2/sNd2Hvn5quEzsY3XJioCs0g6TxkbAxyLJG2+2jq/O+N61nK4jVnLqcDgKI5/pkXt +2Rb4PdCi91BSPoaScv4IKQzZgX0BqOPM9Z+aO2IwkVGQxNi9Le2tHDXpLYkl1Jz2pQ== + + + bK/n33e1b6IVURU/J77rZ5LUSrUul+NtRBi/9+HgNiuQ8xcK1ztV6l/2cOqLUYuC684inl9a5dut +jF+fZv3Dt+IMOuU/ffyX/26//p///PEPf/zjf/3x41/+9N/+1//+Hxz8t07IPpFjBXelSk8TH8Ct +KJ/BVCo9lF69C5aSOVX6B50uZxsBFaBPM5aa/YJmphxYjyyDQb0PZRxG28QUWyxCIZi09+I8LKV+ +z2BhEs3wY3Qu4B7MPlOnAMdMmrnOJHJ1Bhxv8kW64k5N5ho4lZVy2smFh87OCcsI8Ogghd9SlsIH +gVO64CYVAxHdMG7ldpbEQwzft5AeQHvNbULkYp4Z6Bwz3mmQxXCBruVaz5brkJlJamTI/Vb5+tMr +o4xVmEdNmY5UGkxHzIcRTVHjU/8kZXqI4/zZociU5Q7REhWme7PeuiaoquUPSRLByZHM5mrEK1so +G3MH9r/ig4TGZjA/aayZflB1gLkYC244HWCYETmiaixYNHulcL4wiIYTYxCtKzy8XBnFQqcqHl97 +1SeaL7XR6fDbL0TN6M6bpy2D/SQNqMZZs1pBl4p9iFYfhDmF3lQX6z5kPbDuV2GfedUMeyaBtFwp +xM7qeke2ZJJI9QDFXc78lAGMIR3ipPEdW5hUxVakdd3+5VsGfjzGQyq1UAHDhueTAeRGmfVuql2z +cG2RITmCWyuDHx9GZTHnWahdDuqrFhoQKkHrXFz+4iBCSpJgGoLf9l6FzpJIxuGrW4JQtnug35WK +DQPh3HcDGpiokeYhwgBzEiIMxRMZepckMmlOtIVIgkq3zn9A53MpRBBjLUCD4/Bas7lmCGozJWB1 +XQ+pu4B7qi52Td/nBtNtjuERjIhS0IIAC2UuJ4XldZrHOvqQhPBI7mTgrjh9W8cO0FSSrlD13iTB +oMRRpGjEOB8twRn8KlCV5FJq8j4wmIBvp591J9cDFDMbsIycnQ36rqItA0DhL1WzChY6sVjiEYKJ +QIbHHgLkkcvmNCjriJqs4gqdXs2+Br22XKSbE46wRNAMFCakm2sc1wkHdefzhH75ck06jBbjllVW +aj2gnyPYBilODwTCXcJkCHdrea4FWyqsBR5C1lCUNPYOTtebHSxo5iFJ7akSXBKrm3/A7ICBwBLa +svfbn39MZFMAsIkmNSV6u6QDXQ2n/DKj1318lPsUsPA4nWMri2ML3pLzsaJ83VlecUogyYwqM5Vm +QeHQkQjGrSSEJgKknhgNsfCkzOyDwlJNEMOgJ9keuGX0yBfOy7e47QgoICzNBQstWRY8oN3MVZTs +3E5yZ0c4rwUC9bbXLfQjV+u+R3z1Z6rhzvje2KlQfZH6+XeGcfHSdz5VrjkgMxXf1lkpJUnV5BDd +odkzPTMcfdS6EUyzsOmfxnpR+6qBHxclze1aKhkMZnERIbPUSc/dBvWPPTtUMnY3ybEqRXZL4kjO +qcsnx4vD7yjzymchJ6rVfyXWVHHfAIoFyZFPnzZkR/uFkkuMKfvvo/IhR2cG6xhMPbYsmWvKLJen ++6eTXc3IHGRxZjWLroRplwqz5c7Y4Ury2F3xRPkDWLL7HliHLOW8Dg536HrkoUbQB2rFHLtP9YiA +Pol7976wJOReVBtK8ZqNZT10tsG5QwIt9R3NhVfh6avIbMi2ILOZIHyeV/kf4/ZOeZ9d/sTOd18D +F9gck2EfUCTWrHR8J/4t+8eBUck+Dt/wFlJCWVnGrgzmJpZl6k5e5r4TRDbKN9co8MH5IgZ22ygN +4HhWHcKtvqph91jqmHZbS2NDJCd7abhUFBgsxZE8xeHEdNxWJ0Jk3ZEAQGZ2iAOE7SUoED3j00mp +RLGTuxDlI2qqovzx2Ee6b7e5SJGXZSTU5DPVjzWXJL4Z3SgpMsuhyCs1H7PmGcXfS89L2gZs77Hh +qA/KztC3pfV32Lc44EBjsdJDb/gyEPHYQG86uk+qrrKXWvVTUBEWVa79QsvXrDgpub+yOuSOOkCP +y6k0IUu6eQs+8C4WFstA+PDSmNIULUPjmsSwuFrDVNQEsKxSytADiQHCge0ynEr5RV9a9e19cVmY +dkt1t4wjoNSSfAABhTDmxNNNkoWHGBcP8rXmhG4ntD2H7eGSnyWmQ0P89GNVh2INxLrRzT+w+ujc +4BTtBdWUVTO6z9GAHfYU1ZURWNXTZTRBdZyDwC7pScxQ2Ce28wDRt09OgtglZ1id1McsWtOzhiOu +6k1ckBL2Uf2dhaPW5+Xrab4RAahW666cNigNbNGePr9+e5yJ1lutcxXUUXQzByqVg3AeRitgSLL/ +tXWRNvcSjtg+UzgqvBvCL4i6O9eWYV7fbz2E57HosMIj+dl3GsaqM1ArJYz1e0PodgBZpiaBpZ5L +hRa/+KVtr2NGtusMtVudn4nko2/Wq6VUfgQ15Zo2a95cg0J5y/4KSdh267Aj6Up0pWu7LVir41GW +vWtRkr/JKubhzywAWOCyMSCQ4ennFprls25sEJhlhGGU9Z7n3pbdcMGAkVstIdKS7Y42VI2BoTAS +TPAlMtYzWvCE/6Y6f9YK2e3D+CfoCqmcW2By5XZ/4jt4FhYVzwIUdPU80F9KjWd1WheSDLnvXR26 +sRqCXj0ltF6S8ll8LA0scSpuPLQmq88S/btKlpuAAH3iq+3DCcql96B2fotGKH9Pzue3QIY0E4j5 +Ng7qYtnahFGaPrruGIHZezvrtY/f7sFxvwZ/aSbFFsXYoqybANJiYPGomskBCRQDUX1tCD51VBqy +BSGghQqRiWUzHdITXsJieOSoCVwwlq5RtXg/6yYg13Od22AeLlJ6pojfZIpNISWwbW/b+IAY7nIV +xjWtyAOrJIL1XvfZSSpqQz1SGhJ57DOj0EJkhWwoHLFNpsJRIRfjbsgi8GgWYW7SOLjaqJ2g3ok/ +22aD2ecuQyppr0PhAfS5k2r/iwM2KW04KGTGiH/SGzjNUvJWY3YNPTPAMns9h3g1t0l6LuIQh4Mc +i7w5T0EbHMsvRp5dwQBK08GGEusNuX6Hvu9GvwBAS6xbwOapRX6gynVuah/Mp2vRFQqp9yc1FExs +kok1B3FtSjHZ57P49MXZLJZqDtTRcrmYoqElEItCCagnoQwlv55ibYmMHjHMUI0ym5Wd3ntTzLqG +dMJaAbPYpEgYZS2epWPo9QEWwVlua3Ce7dZH5e5muVGLW2t9zGPcOe9LhWcZN7FWGhslVtpBozZJ +/xz9yW1FEwF5j86XeqgF1Q3Kx1BJFQtN7m/1V1tmlxClS9GW1s5NBLKWe+Xjz32NGBJT10tYSsyQ +XaRrlqSZXGwctqtjn2KC7o/q96kJ9SvWy6+mlHNTa3/8xMvzuL/JkfdWz2cGrg/umdAFQKYQf7T2 +EFDIPidW6LX7gCcTUcsJJAf459rF0Ao6vruUHPOhJ+g0XALvtXrQBu5bbPgiaf8gQuiquVpUnQc5 +uSZ3fBFrOtpObgaAkWRbNs1BxnBxADKWFoC+bdMWhPSVLUhSNmahv0v1VdQq6CUAlmf9KKBxQLJi +ZTY2xK0n3RoCA0qBhLVHrzCZ+muDjU5qMc2/rZ3NMufzg+SVb+zwFUAujGnbTTlDPSPQAwGDUqwG +j0W4TBnWkb3aKgelbRgVhJqjZ3of4maaqjjj+GvI/5mpsxCofDyugBYjDAEASQCpPO7LTIalI74p +5kPY/lYCcCT3FI9Hv8ZUEpQYZq0phc3XdVPMh3cEJ8SEw3y/ImtGgiMRZl3Pr8ItERMdzC6P8dfx +Je/i/gz4eIYCc3x6xsoJUGA8PRlsmutE8+ZY//tS//7H2A+1OIu7lAJsE6BE9FiLV3VyQPP1lvG3 +zVK+msMLDlK9Ebw+dsKFsBg3mUSNP3cOMggJZmfbzwdDiHO/QWwOuA3khL2BNMNN7VK4yAGQgShB +UuBhADgdrN1j30NWj0eyp2HQtb/tfFQ2mFi8VNex2GhaFTEVZMHVD2D+D1sk9RDklixquduIqIfZ +ggGd3G2aN3QTRD8N6y+py7CJlcHI4Z81dDc2hAypBEYQKIQCgxxvWl5ILEAeEFyLOHOaae61IG1i +95rm3p/GnQHdjDKBBY4oqE1vgMoHzzk8R9Xx0BFDfuMWdnoZ/oYA3nRHzO+zZ+zTAAe5Hk5M7OSV +YWAQEyPvn65P0i3kU/YfUKVPF8n3MWvBQkzSzY4e1ha3RjQwgNfwsNNBs47N4xXWcSJRGB7dnsL2 +JqkICau91xkGVMKAG0EGe4QypJ1n8KCleDLYcbqnCXEH0hJoNyAtwVB6DF/gNyevYwo5D960GAWx ++3UhqaH0jzWQYo1cSMNYEi6t8RCP8YTMoFx0G2xPPeKkt7iuKm9i+ZuNQV8gxIYQPzTJaaOgwCPN +0PJOTtgCMHrGe2tgqvecEB9oHc//EYJbODQS0/n40/PMMUgOR/wYkeVbsL05zxKw82lhjbqkn3Jc +uyOoyIvf1BL1/kng73ot4teD18HrOSJ8iX9Y0paKgFRnqsVuOw82lJD+YHbIXS9NDR45JlpVKR/x +lAstbo6gSJNE9MLav/epmChqYPCndA+N/0wCoYBB1wK2bALRkEFiVRiuuiRCMcLlkIliDqmqXVAR +VIbn1myWI8yNFY4gpJiZMFIP9WLq4bCANPv5Z/osGhtbXTPPhlSECAari9DLmqRDFt1ZhUgjl5Qf +3/Ut1YdfB60Y+HXgX4slAyknILsCKSLaEupdraUHGEaoS4o9B/qlUbQw2/cdZgcG4sG+zEIHug50 +NRBAtrv1u5vVEf4oZ8B+xTPPeorUCmjjolYAU9qswogM5OkMqdjAV3LqJPaSoI2bNR6nOmniBEHi +axaG+He1Du3fy6RhG8WkKk0VyE8EqPuYxScoPBiBhooIAd1HxaqiRZwZQ+VPg6NnlLmgjyebQ8mG +T/0x62LV/o9DHic1WLof1TQYR8BQELbAhOleZNTgoDlx32MxUJqVyJfqHXQngDqhJ2+k9qEIqHd1 +P0ovb5XDyiuwjGfWGvnSriJiv2KKc1YouYzlwHiWBte5hwFe1uRHGdZIWx4FjPSsg+rKoET5SjRp +1yqqLlezLgfHgxcLlmKs6NPhTYdoAcaIWceFCKspGDIzRxwVysCKhdhF0OEfY2Zw1pDFgVWIttBa +4c2t5Wd41c3eS+4DDx+q2BINqXDDtxPCm/EASzEcwn9fEjmBXP0IBXV4SdAjsm2LH0uhLg9FirkF +VlxFAHOY2aWqX0H8Y/PWhgDvuWkV2XriBta+AixXc42sXYmqWc3EV1RfNfY/IE2pihHBz5Z7cwR0 +A4TYcAn0ke7Ho9anDN0aiGAK6xMmkAoD0dr1qUAF4ByEbDyfs0OydI/iedYOVLyXcMT2mcJR4d2s +XbX4ftfu3NvXWXp74dMuTcHHmlhbivsltbYm48pc25txda9t0v0uWdutcbOtDdu4YdfG736/L/3j +aDbWFnS0OEsne2u31n74av1CSz3YzdCa31rd0OIPRjugA6aZn5iCV5ewAhGiQxkYhg== + + + 4IoCBGLryQKUIjjCAMcIPjSgOrYeeIJCgt8OeJLV4wdYyjZcCPCWEGwEiEyIUwLU5iW4CUCdEBEF +sE8IplbM0DYUC9CjEMgF+FIIAQMMKoSSv+3gVDEkXWFZIbT988DRvMG7YoC8QsRmSB3wZdtAPODU +QhgfsG4xFVghc/uUYkXchcxkYPViKjP/sM2E5h9DIrVCCmMytiIT90ndCnCMyeGKkfyJI7b5aTxq +zXMX1GdMlVfw6D7lXkGo8TwrkDWm/wEQu6sirLjaWINYsbmxjrFifPf1kBUrHOsqAW4cSjMranlb +4RmY57U+FNDSscQ0wNbbwlTAaoe61gr3DgWxiBrf1dMC6DzU5QJwfa3oBfz7th4YcPShnBgg+LMA +uQL4d0XLdQpg1DnD+MBaFw3DB9uqaphhCEXZOf4QyrhhemJbBQ5TGKGGHOY3ZtU5jH9sS9VheiRU +usMESiiShzmWbY09nmcU5ufcTKjgh7GbbQMgTO+E/kGcAFo6D3GQaNe3yMlVhKE97OqyrP0PPSKh +NI/IUl47JwrB9DlpuxI3bNouWfQ06Esit8u6Xps2jNWLHqjgs2ps9yAcQrCCcEiFRWvXK5IGFnPf +RePEJXaaFHnCvmef3FH9a5OKiMtjXLsPouG1wzUDQ3W/1rYYnPy3NAe8h0Yow7P5ULSmhe/Yecsq +fN2xVwfqSeSFcIerp7Zr9T1+vrYG45XXruLjftde5I/Xp1w7mPEdrQ3Qf/rDAF2/veu1fxq/19p5 +jZ9917gNq2dt+4YFGBrGYR2/tpnXXbC2puM+WnvaXw/28Ryr7CKm7BTvewMzccXPr3HAfIwMwAwl +BOisA1H8WXgCh5T0Jgtv0Q6waNd1j7LA8xDB4KrSBR7v8Qc9tTk36UJU6JuB+sxfwUeFnZFYhlal +RcpiXuziBzZLrk79drHGH6PaIuoBWPT7R7wuXPZFuubmlUvb3PZ6hC/f9anDeeKbu8fqglmSCbov +v8Dzu2mAk4WmApkt0xPPRE/MltGf3v5ozkRVu7WU1W5tEMsLLumfbo7o+qmC2Z/4+S1eOmpHiZ7/ +88rhD8v9/hilp/ejYKyocHkj0S6id0CMOuJEulj8zwdJlAW55iLq5gnsFcPOiUQCr/lRghRzCVgZ +2uyb84x3F2/hkzf+4+3DINICane7g+yc5udT/PxdyfxmBcI6J+DSbuHBGyr6jvWPcNeJ+25d8jBi +lfTJ6nr+ynfZ4/RjOz7u5WXvPm58/NvzCRfT8Ol7Wdf1shQA/VJg+tP2jze3tPn4iCvibW9qKL2c +uyNu/XS7wDc/94//vOD47+PufrzsOriDE/2RbLlUZiJnXXRiBhYu2uKSzeYTbhlSwQL/1WBxCVsg +nCW8uXAfn7zbuYIpVfS8cf5/GgUXr0HQXL82a4hsX+SAKFSAaZbUEPypSA2BqExiWiRjPAith96e +/Be8M9fMaQ/JPNzomGj6lydRmgXFQHW5BmXGpH39VjipUnSXis42ZpMIQxKVJtIvVQcJS39kKnZV +Kbk4LwHoo6nBERgHO0JCUCoLK3HrkI4w6YesPKy+B9pE4/bDQwKDR8n9AMUMILSdTiIFPuFUeGf5 +BezPUCqwT706UIuqA5lq23EIi0k8nNIcOSF0AJCnqQDpWSAskESLgnCDaFEqYGkwG0mKlmopW8Kb +IOogrnRDlCikjAS8gYm+OMoSeTKwoTdDJu51bfyv+ggU0y6XYIJuGrXnrcPJFqegx2vxFWyhY0V3 +bzgC5PC0ZjlL8ppkt5BP0Jp4H0lC9XZEIh785HkAUZPVo7gkFIy/jHJ52cmytyz0ZniNSlx5EZAj +Yfu3X4FaHHgT+3CaDw0fs3QX1LKEyGU71/WAAhc9F5Kse7+oCsZ4syILvd5uP4Vfb6zZ91Wdiby5 +Pdv6tXyyOYprpjjxEg5i7qhibpBY1T7QkZUOLXtxfbjtjkYIjSo7fVfIPINhsDxTmAnbN02o/2Bc +lO7RfK6FIm48YgIVvjjPeiuQMKG8coi8/44PRISgex3M7/6+1teicAHssp280fYLb5Sm3rn7HrtM +I35XMRQ1pxq7XT7ndObSg1LtIaHwFtaSmmqkgNQH6rz75RFpzDAIQ9mCilVY0j2p+wUlHNomYWOQ +qNDMI1F5tJPiBlPf6oTcFuWc+hF2Jmy+QMPDvu5thBMW0AEI9H292Acw4kLwp4Pxq49gYKD+Farb +Nq/ZoU2TF2CydKLMih9TgymYu3ie1WSGWwmWd/tEwW7PFzItfXiDq6PYf4ngcNYPGnxWWBLB9W1X +VnChYX0GN7wu7OnDt9sieP65q0LMEDZkeMTtxg4xTLAPX8dBn4VRWKi/kdDgvRMavMW75OqOPCST +YsjeCNagF2f+4j+EBv/OhAYpdxfXi7g0S1Zo0zOClBN4ca/N0IwhdEGLU9MlFMk1FGkf9ejOVePV +7qvRItZoiE/xXFDauX6GynBw+NOUQpP2mGw+VFKLui+ELT5ZQgUOVRNtaHaEM3WAnaCcapYhST+r +js4RrO3F+TGKaA1tx45gkPMfNAIQm2ia40nOCJuh9mM2+Cgu+lwvADenJgObSErhfbRF9Y86Tx99 +BbTCKOoggABbXYYWVTIeX7zPKTVIedwPpFt8uHJJv6Q4YjbOnuxPo7fubQC4pamZq28naYWEHMZH +5k1Bs0fcJloiyBA75IKWn53Nqz9Ojye8UpY4C5AVO8IO6c82gPDAcIKS0MHHSAMeVu2K5qM9wHd0 +ue08iK80v2MkQ4SS0ZXKeD0W4h4MorZsxqo+qRnArVKZL1KYOQREUtPgOLwxhagg/YBb9BO4MWZw +j3PIhJg7K5rkHjNSJYGyGS0TVqlZAVYp02MvPx/8i0O8XPVYNCVvRSm3i9BIl3dHHMjV/Uuh/CZC +yuZD1PZmrvZ/2Hu7XtuS6zzvF+g/7JsAUgAfzfqeM3fiiWIzoWFBFmILRtBgmm25E5FNUC0K+vce +zzNqrn16rd1qCqCRm1gSzbOr1vysWTVqjPfDwaMStY9+qDERX7Igg0KZdOp6Ixe6oX27IVeYmFjv +6/iSSDQ+2ZdXiFkQZa1ntqxn8qZhW+OBC9uafCGKnqmwSBxFJBXfmMRQ67i7PKImpCS0semqcNoA +8MMHiK0Caw3rrsTphgsBu4PL+7gS7N6vfMzwml3/q6YRWymrlpRNNe8fU32NA1T4/PVKM8euO850 +4C1Yh6SThgiXn/oIPn/xuYgsBEd7lDRasCgSmxhLNH4uMbmsGPMXSXHM0FFpp8Z9Qb8lEyq5D5lX +bMYw58GLh4DTq4jQFp1eaPqWCkpEDSAqM5GM8iBgngOYTJHln8zwQ0eKCjpxKlpcIGo7yVjHr1gn +rCyMTnO9qyydMcqxD1GGpdLEA810J+hYx2GlUPAOKcx5EbekDq84GOAhAI9gwPpcC2hytZmPLN4y +/7aeqk4pPBCD7VFjFNLHUFoRpsJ2aCWVS+Or2k7pBkvlpl4fHNKXRL2Xv988MW6N6iW3FnuXLlPS +0cqLGM4W41PqqJV0Y4Cyq6X7lW82YgZFfPF+uY86tjlUw9Ubf2nQdhqFWLNZTiL91KwMiEeTIIs/ +dwrkyhg9XW4wIn/YS+0dCLL70sv6zOWgsJVoaf8U3xTKqgVHAXnO6m3EwAIhYVVK9FejWk2w+Nwj +byCGrSWbGDHCLED1EbLCzmeGvNVj40RVIisxLkitWCxqSdnafDwYOPH89Kq8n08squwDI5S/Ziq5 +IYKqj4oTcIx13H0vOJZTv48s6f309/T5T/4/cAQcZtRjItiOgBdlWnBEDys7gAE95rOyrewuVj1c +0dH9PMGVkcMc8b1Vwk/46zG7U+GKqGQbAvZLtWY0cZv+qyd1ZWAmJ/Lxf9C5JvC0T4gg4/8Yq+q/ +waolDoOIw0mJ7QeGgDq7FEklaQgYc8/BVFv/0DsDYIJpPbbd3BmyCjFaccmNcfOzP96d4Q+KWOrE +2h61D+3DDegZw/+/H+Af7pH0P96ygg3tirXkYqVIZ4aP0utskpKy7l/TooKN6UHBW8GjkXrOkD50 +5znLLrLDtL/SH1g9bQLR1rP+E8+EKkw5UX6/Ucti0zCpY/SYsnNrXmStxJqVIvIYQmnEjMo2AOSp +wVA3O+gcTzrhPcFeUrV/OqYzVah4RRxHvKUQ85kNWZ+PUc2Wv0NOMoSJxb5kQSv9eOIKH3ojFPEp +fscHvW70GHUqKiPRi7pGOj6dlHY+Su5EfHWKGOb/3UBSBOiJsWY85gEN/vHztp83KR72G4/zARkF +VdjSVPlHLrft7FfDQ/384K4BKJmpK1PO+MvzwgC7ZXqsgy7++LlT6LYwBIZnfPD6+rF5hN2ky/sL +7zUV8OdGUX48XrSw0zi4Hro3vYy7xoopzHIcwj9exi5RJNtTcezlg+ztnVV9Os7KXUDE5GD03l6v +ZfWU5Yn931EA8b3eUyLqrUSWO6H3/ERUZQclEfsz6CAvDxXKrvZfYKgUhnp+NxHqT6r3YP76I3P4 +/I7X9ng/JKZkJfGHwwRfTo8zgCn2D4bb6jvFP0CHl8dw++FonXftdy7pKq8Dfc6P4QFkHdUfAlx1 +3mL9z1/Z49fPn+XriZ8/749vYE8OL/f/Mq+8PMOX+enDd3FPby+v8mVCfBkNrxPrB4PqZX5+GZuv +c/zz+P7JteLebf1IVq68/fnPvvvu72PF/flf/fL777/53W+++vk/fPXX3/z2m19+/82vWH1/sNq+ ++1z8yPHGkUv9lwf8y199+/13v4sF/Ndf/dU3v/s61uSv/o9v9ire3/7857FGv/bm//vl/x3r/ufv +fvvPX/3iu6//gN9w2d9/y+V89Tf//Ntvdm9M3uuPXtVf/OP33/3H3/7y629/83df/Z9/tlORL8/k +i87/9nff/VP2Q6yrFO0d5HP86Dn+5tu4j//07a++/2/5w/FjN/BXv/vm999+809xz3//Dz91LTzO +eDbffvMP70/mx3v/4pv/+v1X3/7mq//td9/95vuf6vw33/32qe9WMFxbwbD8y7f677759u/+2/d/ +4L3+9Xf/9A//6jf17z4clX/5J//TX/y8ffWXv/nV/mn++2ff/N23v9l/+V/e/vSvvvv1b3/5q+/+ +8Xd/9idf/HcRpUxWZMvAf74VKpdTB+Rl5og6qz1IgLiLHkf2KGxHZzde/Av/8z//05/8wAvmDiuj +5Z/95/8e//X/iT/+01s53v7923/5v463X+Uv//pO3X15Mc+n2r5lP3FBb7/4qNfLjf3iozP+Yb0+ +PONv/uC5Zr/an/3y6/+X1+roiW3F908h/heP8d2f4Hj7D8bjwIRQQZkt1sOILigzxayOewqLykmi +/LS0XlC7G5CfIC9N1I8qxhcRPbEJMKt+tJ1lfwOC90i282d/RdEsNl8TZYQrA3ZIKsQ3kFTMGF8z +FTJ+vRtZu06gx2T278ZuBrRBbo8IM5YpTFHwWKYB2TsbWK4wozgTwdUxnY4tPesQ5A== + + + HznWsfdAq4GwIZkuZaY+gtzHecbVQlSLLaAUIFZpckEUe5Txm7h+9H0C+G0SXFCxoLrd01MKM0x5 +r3QA+Y9XKEpM9MjFFO4jbAoPoe3TKXKZHpuC4EWM/JN8gogQ+lItgXLBqVfUoaYgPVxkJxZN2YMc +Gz2Ia7IH0m30mBuWBG6dLbTMgH40Y03yRMSI81SBCVt0WCCk9biByvNVSYIrqsJKCGdOouEDIBTq +fDATISXgzPrZV3EYM4DtOOWhcYHCtuY61gbLkFIAXIK2g4F1xjPz0yXQGX5uz5ANuEuEWpPMRgol +sUsgJ41xHOkoIx54DJOcXUlUaAbWnuS0umsqaoLfrmnqxw4GvO+sxi7nJ8AgYEZR8OSZ6TNrkXim +ma+dKsyi6MSNEB7tv5/Tamrsn7dlYKKJC/gzO5gIHBrRrcfhBxqdxCVwzOmlcVkMXKsE9hhD+kv8 +97xKJeYY2uWOz8iAE59deaI+9+FHagUKmG6574UYRRYtE3Srp6fSMRImTWiq4W4MjYPTQntVuNe/ +e9TRU3sS3HoTDJe/Idl2KucXw1bk1ZF29eRXy/iwR08SEwm9ti/6tdPaCIoDlbSdVUyf4z3cdVGC +rcEeo6ahcL6tp4a8/iutt15+NRNZxefbAOfzuGAWxZlzx6EDVX6IBTIU4S56mBHMxgXdY4ZexaTm +AfvVXgUDrAn3mn0JPRpPl/HG6BcMz3xTGIwJVqjWNdhgn4mKcBc6H7Qf+sDSpM+CsytyomoyxhQ4 +PEoMK26IMlZ2iMXLDqtnh2F0rs9yzR6nqIlJ/L9PhHnZdPYBwOsmITdasWZqDYze45jqPQ5rQqS/ +FTc4VtEX4rXHmXyvGMcY7u0zPfci/TsbrO8xtMoeW1uZZOKgQkwBMKn0CAd1VSXFdUHCaOyZnnvk +KIt3QpKd/G8qiz8fh+mdwtFE8ocF5ASh0d4bPhq8dxuEr6KbNCsCGLYTBg+bbnRKY6fcoOLIWGCs +xLcUIyshU7vDNIXmdMeH1HPFsUjJ0lCvzOQ7buI9xAtuKVoBo2zG1p6C7O+915nIF6UzmF3xPaz5 +a0oAvMWLtw8FGxg1BtVuu/iy1U+kMsc8Gz2SHQbXo5b9LFfiOqIX5RB7+Z1EL8ReU4Azp9B6Ip1j +j44oACZx0w7U5ugw0TzxROKN4hDxQvaX27ZAK1CaniuYZZdYwU6oWAyPTNjQ50pQn5ThyYcz0qnb +8g45j0FK57mHZzrnJscwhD46Duwy2Fuwyyi8o9ojph394AxRcJ8eGaIcewmmMSZvGgUL6fY281fc +mWReBHgIheaVDR8GUA+gsdyTTkIMiD0s50RZn7n7hcEd33MGXOeZ1MSV7HaBPLrNEWrA6eoIo0Hk +JIEyr/x4VI1TXAEuf6yd5dqeJFvRkbb4D9pm1nKv5N7E2ozZef46lTzIlzR7aMQePQ6ZiSgcwPeO +Hu2oefwIDSkYA1lq+0zTkUavA19PeonViF5w+t/ogcRF9Ijlg9WDHhQyo8fyRFMsFB26dGdOFFdB +B4TOt0hlccqGpNjQ5KPYgcgsTHo/vQ7yFWL5wnudWAmYl56UZ6/4FXbI3lSdVhwZEjKLRXpAQgXO +jCBKKFgNxmH4KrfhJELbSMo0tVJOrS2jBy6wuUSPgit5hYfFS4vHXZUxRye9d6Uc8zaYDq44a8RD +J1EQxVTIWkh0oOtoj52IzTWKqSCCZBo6hPc4aETT+VOLe2wmUO2+TyAfdaHmMkzBAe2jk8bgdKh9 +2OGUFU4Phxw+bGdegWy+RcjJos2JYNRxIiRF8kQQVSNEXyM5f2L4IQLHU5jSHFGzp2i02IOBLqNI +S3BFNf/kzf/UN3InhJC2YJGJK+ZVwkP4hNZefkToXhwowRwdyB+NEfJVBTHEPEdDofxUydyiHbBa +crBixeu3CuqCMQ0L+Yixd0AgSGBX18kUXYwD9nf+HUA3IDz/CVc/j4HSJ2H2WZFpIL4CQFWkIB9m +Wj/BY1WHwbg+nnFHU/1u8CgFVEKF/99KhrT7V0cSJUVoA1OqCN4ym8eIlKUMbLeAIIgv9RHS0niA +645G9pPtE0TG7q/8pKKhau3DSkWJ90oidRPece6jLJ086XwOKsVACUt2JvJHnKWoPxpR/drAfYVc +cKhFhqMpnnRf1PBTBEdewJCixuwePb7RWBEKnNX4mlBlYZAnJXah2ATmBWgGeqfH3qkhHY+zPUXr +i7YTaYYidxglemjwpHvflHiCDPzcMIC1rT2pvTTGN3pyDeAlBqT5mQXdeK3AqnJRELy/sLFcj4a8 +unjiMVOc7MwRJnr/FYgaufPagoNCRRfn5e+HkMs81g+b4oNRu4WHw8QDXIu5AicGP3vCT6Wsvlzz +gMGw5z3x1IBa/6krMUNDW/7Kn+BXnsfypk+kl950J95i6MoYSH040cGBa095OS+gS/o/EWe8bFhw +0g62uOydT7aPnhw9kT0qLl8+PGKEX7yfJcUjHS1O1FYA1vJI2vyoAXrBY5A9NUbgONUJjIs4OxRy +PbgXFLXYb0/328D72D/Eg6uPhtyux1KMbzMQ4Qthu/tXFaweDzS+MxhoAHkb6pzPDWNLoObhnhrj +XR4skOBIR6p7VPnK1N6l8Nduja6T7dncCY7SWQ5Ax6hT0vYbIF7z84tjUgZ6vBoYxbFonAnUGIoA +88g8nErBuKfHnoPFblAqUvuobskcpkKWOAomVaGulCUi28QfAApcW3YYoBuViBMxUriPV07bUCjx +rYBujLACr+2ABIxaki6/Wit3Bau96pxelxXCU+RzTTXrVfJXwLWj4VygVmjwg53AC/Lf926TvxF9 +0DlW9OkpvCUalAlxWVfRENWvbFB9J35Bjs6UQ9lzT0QZZJoRm+rsWwaodkY8ca2Vj6r0HZPSqj0X +lA8XszuCHKB/lA6IhzqYzoHOjfQtHWQTWARUf9H5iW1S3EbE4oD8TuDpWgAD6BkE+nzTMfMPjbEY +ZfsDobGwA2BZ15L0BAd/+ivTYsxbXf8hcB3Ibs+MCiePomElRkbh3Iebe0VEOikPQs4y+kKZoYGw +zgZVkeK063JZpiS6jxFvA1JzfICzaqr2SRv3AUCIsRQvmlwD9z2oAMe2SL2IBqq0l00eVdMK1Y5Y +wKZLaGGl5yhVxSYQhkhW7QUhYuCc5SYKHTBhY7XZsSdtMCJoQ5uNxpOPwgYUz8hrKaMrXmxkA3sO +64nMcnK6+/vhDic3aAHZmSdGZyqGPJ6xDw9kkobV1c5TPOZ+dSZXZ9Hmm2FnbDPUSak8J2HarDaV +Zf+lYUPU7uf1gzagmAeo9n6osnBicoPADmKUCtUAtvbqa89FIy6xg+h56eEJEPOFiszjYB14PQ5Y +KbK3i2LykVK2SBaQGJ5sJWOyjDuJjdKCOjb621VyUH62lneqxq/ozEitVcCVMZHucPcAfjDTBgjA +9oIp0LmBmupF8ySNvF57eANIG5BZmkzN/YPDYL2Rb/EUvINCFzv0l4aF+kc9H2PhB43xIi4il4HQ +DKgC9tHd3AAapNEAGhOZlZghWn3/u0eLOGjE9u5UaJ26/f0j5IVU5Yq3eJK3Z1o/P2jAjr3U+3DP +jVhuxAw2SDpfuAodzBpD44UJco7LPR8N95snX8CbZ+P4xa9i+YylAd2oxZ1AvEcQbAASYw1C8IYw +Ha3GcY9UEWR8p+SMY5iwYaaYbIMfC3uriGYHPGNHwJW1i2iYnU99UnI/H4ez4kH2vsSmlsZjFH+l +IlpcIVAJG9qR5zFEmCTS8+pcIfNw8YQqYwks23n58QF8GIjjKL5xNbbTNFzOhX4Yc38YLFW7IQ9X +BXS/d2axZddAANiNdjrJ9dcGQs5yX9RzI3EM91qYX9jqHqgAOPG4QnG16ICiJXcqV7UbPBwq187Q +KIC19x/VaVISsYhK+p6cJHPeSwO8r+N+Ys+Ni1wtiy96a2x3py4oJ6r4SbQ5rtTxWTEKWsrl23AP +2dy9p9jU3UYaRY2pFWMRcHicZrz+leixbmeul0amQgdUnMOXvBqlGPRwIhwYvGTQ3sIkJNA9GvJG +wR/TuKpi1I9fwWOKcCM+nZq2Zqy1MQ8NwMbE0LE1rsnME0mf0xFBW3xs0Qb9zzb2DjQAWD7N85B/ +24+zXRn0Y06lYdUA0bceR4OzQWMR/9LvWejS84WGgy1L67m1zl+cNqTJYawC4742RiXfeudLRNNq +P7i2JA+fiDCyTU2N5zha75/4nFA3PBAgvRtyijxNebLSxZD88lfXHoiF9Ed7o1h2Mq5fGsgLt/4I +MH7YSKJvRyWxh0KulaQ/1J4MIrk6Nb2nvA601D5NdiV5uH6v0biTZWPEg/5K9b2JiyLrGYnQ5t9j +y88/r0e44t8MMGDAwGfKTa8HWaw6aFjFqdmCdAOMvu8CSaLZbFj3UBsldxaT8xdfACp6b8SO7izI +x7q5Rlvs/KiB1edeo54bu7CvjCjUAwXfHJuMN/Gm12iGiSTz4/IO1RMfLY8BEistA6SCFnz/XcNg +UUHNw9RHKRnhxwxgUe1EPr8qP2b+Idd+WEqnWUlSz+SRcpvFXM2qz1w9SVmeOwUxqGdzBaSEI7J5 +NHx9p25Jiy+UmuJruBvJ+Kinciqn6cc1Ynv92vDl9PvSiHziiX4XcG1qMgvZrHiuZ8wrrFwxa+K+ +MgnJ2ReQJG73lor6YKapYmKOaTc1kYgNY3pK6ZYDdq2VRpJg88oN90nIzZY2Jqm18aHsw4rM30qV +1NQEUW830uxowiHZ2u+/a66DjjhTDzMwPKz7NwQbS84pRKPJNG8MyU6UsiThaoHnwY7p2oVp2uqZ +baSybGPnb4PilYPYIhv63dCzgXyEDbsMTaPi0lhFrUOzpoNNkg3Wv2A4ponh4aujoQy3yegA06AE +bB7u1BrwlJC73q0PaZjmCQpqwuNNuej8u/o5F3nSmMgm6fH72poVlZOH01iArIur1Oih0CyPfc0a +exQcOzuKpCdKUNSVv8wpofvE38iD8G/WQ3JMSJ3ZAAnI5FNXVuJQIov6+dhJPRrd2ERjP9NZE22v +t2ygjkrSM5aRaLiACXg4yyInGgkTTZxj3niMiMERvkPDHUwkqy8hhyqHM8X44h1OrYKggqnc10zc +AS6O468rJ+PPO99SkXCM1ayxp4Wh1qn0OMeiJtrAsb8BXfb7fPr7pS70Tlc/tRWutUC1hNfaU1cz +IS4xjzZqs1q2xK4BRGihfIAbIbEFnEQZbBWtDTLeZxMz4VW3LaeInB2bRQpnnim+I6WLmTUQ8CQx +qpAsvzATcks+InOgzjJScJYZrw1s6SrNJjrl2sqUwCfrFkegho04AtgCejSqQFxKURTkSm3J6BF7 +qjPFw0dXPJy/5Iku6+8n1iuPM6n8rWZhL/tyij83fkS50xUTIbySx3X48AuAPjTEwFzJpdo6suh+ +nv3gDsAxZUlPpb0YK62pFVx1dzzReLN4yHc3gOKsLpkFfC7+w7Hsk2hIAQpku6IDJA== + + + 8DxR36B3G5u/bqKXyEeRzThxqVNA40zhgugBJV7hZYuHJ/pGW+HCOtlURnsPfHo1tIijFxKj9Mqx +I6++5ZlW8Th1jduYMe/ADfZJAajmLXbMU+OnPNzHKzAEQb0YKqP2PD29pCxvS7ItA+AW+njvDQfg +JcDyccfjBh7tRgSfLpMghHmKIxO7XhpbdNLllO4j1Lr/nQmvQyjHo89kIPKxZdEl/xmrP6EFSvyo +mu/z7rZybD+NykauKZ6uGC3Uy1PJFJTLKhKYfLOpGQ6vKIJELJbra498D+lve8b/FUxYPzjOsVVk +402NlZ6fFgkXVER1Zp97ECssHIa4nfN6f+M/7LVVbWNoVWZmROYMDM8INJD/pXxnWvDInNvZKPpO +3xBBMW/o6ne5k17xNOgF2ZNOFbFItuKpTZ9iQHRQEPzYfk1ufFYqpHffKXPTuXswpXOINsvjPLmY +x8/gnno1GvPAf6DMRQ+2OdGjM/nQQwFZ+P8sYHQg6RAdWCrTmQt1CpAER38fNeYSqMdBH7quvTOD +Y8kCjErDuXTgQp7asZd5WnY57fH3/KKf4pPHj2RIYCp1Vt3wqHZiwPDSkK+179d6f2cvvdgdXNwL +jHZNfUoq73lVpybY8t9RwumskHOrgMePYh7+oMfXu/BvCnRNaqXjg+PwgEAmxJM9YI7yWK2v+qgx +mcDDjFxmrGcxZY03CDTkvj7v8qyGwoeqplZ9l/tiMuQr82NjvDawMFJGv6Ci3BvE116ViTeCzjPz +hgtH7+00bhUC2gGDPE5yJoCTCAlRoYiYHxUVzDYdxGMWlGXsBQNYBfeVJhjYvdCjq1SoNBB4lzgO +j9cehTQ7LA/2cxCl0aOMLckiBrzPlGvYYPLPXpj+0qtrpEEPJsATOrtQlrmheXFxfWYP91xcy7HV +lJL7gSj53IHGuLL0dpJXuVLvR5fyOCiou3SE0FygUqztlr1PBBbY/jY2WC89sEOZSQMsx31PL71i +b8A3ClKLbU06LSggv32/mToL8Stb2qW9+dS876XH1zuUgTFlRF/IjL4cR41mVnDGC0s4CvKgrQch +yKgf9Thu3OJr2+yJHhrKmDdxtKo7XEDAZuIHN0gtpjlE7iFNQU1GDlr1wucej/kCpG28kkKG8vU4 +JD61k4n3wKm9TvkskIV6mospPo9HDkWmfNw9H3e5S9EWU4e92NPRSV17Jrui98RIGAcdBA+v7dbD +l+KY50TGHDE9qYKzMqSkB2nFx4ly2r3z7suMDjRW8RQeh8mFHmiMiJiBxakOB8suXHUmEHEqV2Jq +jjWLh6gb48WTyRNNjebRhVAshZvoLT0iJRedsb0kRQpESRfq2Fscmly89thq/1p7byuY117UgtLz +pxUhXvDJLr0jIJ2lp5VuvRNp93QisHJ26dJ0vnTIYdedZJCRKHIMno9STs2IGVJLG+xetxR519UY +noEkdV2fRMIC4bn3tKVvRER8JCdXSbAAZhJGP6oB7PkSqsarYMlUAktELTN5Ar9NASBJNQkAIEqP +vZNE5ySJW6cmiyzyJvVLZl3w7GE3X4zDGze29x4Hi/nUWUNM5UuPrJt3pzDAGZeiP8+9lAQnnj+A +fJSECIneBK1kNe61x7WRbRGP9X5X6J97AfBF7hqAr2bKqpXyyC8AMzVh203QIbzm03vaWukKgtqj +PPASMSCItvRVPHejsKqIzdYG1eRoiG+vbzx3op2Og6pv9si9NaNhJP5ZQkDsq46d9bSXYyPm1IcJ +hhD7Qzyox5n6g2Aetc2l0uzzKFPjIl4PyDLIgZo+0CMiM3osip03oCfCBNA+2GHPbVLlQ6OunNCb +vOsLNP6Z9OrptaBN8GEPbFvbA+vz1Ehuqanzbr3z0v2x+VLR/eGlzsM7KLsHC+1WT/5Bj3xWPWO+ +a8XcfXx4nLkJC/FMKf6pHseWdMaAzIzHuCkpw0AMVE2+WPIcezOO6KYYCzZT53jt9Yt9OXJ5L0JT +qQFXOhcMeRfpcgEpgFzM6cRD4qxgPBLjCuriBz2I/5ltl0CL97TND3phZ0iwIvqYDx89JdGqraV+ +JpiY1KaaaYKiX8Ohhw9P47XHvdUCMU7ab4nMfTnOuakvMVXFApry6gdQZWw5psjM5x7P63OGss+9 +Rk/85jT3mlFiN6GKZdZWvAYfKWCykohgTXETcDTRp8y41+aeAtu0whzzH2BcZ11GOqRh6EBv1D1j +SqD+G/s8SBNtbkTmSFAapS49thCsKMbt26Qdf9uty0IN2VByIbriZh9La0DRwN2PPBGPJ3rgqcw2 +tKfozoqwjATZ3+6yHSTcE0Na1r9CBQTyBjUu1MiG6WvqzSe6O5fhf6KZqaOSCIdR9PLnTMf3TDZM +lN35NJ5/S8YXaMAAG2Ct/Uz99VVHgmqee7AbGXsP9NJIUECBHjit8bEvQ/luC6/YbXG3sX1jkrSE +XY7bHPqQhUOKo+hkFUsrXiBxNnfVcbQ5tOXJHPePYl9ucIySfT+k1oG3psRQv2QtmkTX6QqCBXOM +ZUe8qpDzufHXu/YfnS69NtXD4btG3Yj9HocBVbOkphV7CNbGA4adBD2Ea1Jq0S5u3l5/yKY9cLlr +18iJ1ngpov0kdsTAIY1+rPQ5YT9/wRvqpBTIpsbH4zAvm+8WuxqB8hVsTyXZpRPGo2Z8oCsanZSs +o5dT1STS8yCi2EhcnzPbNetl57msmlT1xRi+59rnUZ9FZdz1fh5EQOkFtDx7JdOBDFxebr+EXlDA +zT0uumqWtano0QCeyhsRiM3COO5Kf0Q5COLFJ4vTn1SNFE6NaJlwcGBGlJVg6RxupFIFgPTEuISM +JDOEFbJtG8f7c4cfiqXNBG3Y9rquk+lxYFoTn+mVdmkkryuTKMpNGqrFt8sCODDjBFzLYoVUlxsg +UKhYaN0qyqBoGtN+REcEA0qnUTJHkEswA9GjfyVKQVANVqjQpqzLkkdyNxE/OGDf4PJ3zUe5T7jq +ZLpxv3Am6k3uEBiSQxCJDWw5hmoBwwLhYd4TT1r8y+O4xx2c2UukfTQKfqYusfLnpoQAcPLFZw/W +SzhrtovFIYCtY7cD3eXwx10FZE+WG64YZAReMdGkrxhRx+hZZFZCFmR6SZKCCA5WB2EWFRjnUvEu +KUFxrHsnTo1Ux7YI3XEU0QOrK317AfRZFoot15h9QFpMBbupieKwOK+nJfAMhM2w0IkAp7V7Jp5Z +MVZDEAE+QlH8/5AzwENlEAMCWRqpkK+LFzX8ISCcrc4V65/V4Z5ibYOr6XfldcPESS8UJo24z8pM +jqQXZXcfNUh/iIw4H+N3pi7DqJpBOcbc2EJolGJCWYQ6wWAnvKGV9GKlo9ckPUevWAbREIwdmaXo +c+OOCjFNdiB1RofRih1QrWM91ZjGE00M8ig63LVpqvli6ci2sitFMBwaKFvgs+SJtOJjXWbwRAd1 +YWJ/gDJMdgCZwiEAjdJDzDiZzHkvkz3HJN9WMa5/tkwEC2hOCBoU5Lu4qH1LoBaBP1jHZZo8VEja +jqbsW3E0fQyDM+GhfKPVqno3B4DbEGrvsajFIrb8etALhtWeiNILdV7ylgOI6aQWP2W9xD0h98fV +Hp4rz7SOXNM4thKHRq4Y7pxNdCdn4rVxJryhFAQ9yIxx1O5yDVa2owKFthM2WBSEi8Zz1FYeUE4T +rHPnlqpAqfgAmZ+BElAM04YW1cIUz3Ruj8BFAO8cuIhWPxiNJNHUBFvzeaPpLqq7MfsJ763H+JRa +a/peFpEAeFeBBABC/obzXCqkTj98a9H0kr7Fvsp7yaS3kEJBj/Vy0acDiaTs0aTUnDnBs/+kGQZu +nsXbRFH0hmHVK2OS6Yp57mu5DCgB39hBdAK4NWQBqXCQa+9pW5Y9wHcxTLuYmCMrbX2aOt3AiJIV +xkm4xFOn3Mon1OGv83G0Iznp5G8Pkj0gbK88gWQOamekbcuVNSmmClwy9p2QmqfgvnxvLjkRfyDy +Sc4IcFPLUi2ew5lNO64lSRrcrdGOJrPohUkcAwCOrtFAXXRDRjIm6jsmShUz90K4fuyYyYWVqGrM +fRTNEyOuFgT/U+HbHQ9+oN3wp/8Gfn4swvXP3v78P37/u29/83dvf/qzn/3F11//46//+rvvf0nf +H4g2JGUv0XbFeAUttDcYQVB7fr2DhQW6Ad85jA/Y3jneN/49XlmPb1nsP7c4esKS2SjOe+4rG+vW +2MRW23DDpAECMw3Q420oTnUlMQAwwtErADz5DpUue31rFP1OPWwo59mQwDEMihsNa7oW6HjnvxlN +Oea20eQkO3MmqD4/nZ4qB2r5M4sxc9eEDcYccAgbxEGTUH7uoj0xWc8d0kGV+c1X33Z4K6uMN36J +yVcTnRgtGY6VKOt6oPoTz9c3v7DygG2LUeIwJXHC3+PRe9XkCLNBM8OIV+M/aXiHhbP9Xh6FVcvO +JvoWEgqNv1PjyINQR+TohgHIQN+L8gFnk6UzYvLDF0w93WjUvT1Zf0ppkBISZvkj4+rzH3EIk5pZ +YA8vgm/W59JT13/xvyvNs+jlLvECn0oqK3pJJmNh4tpM8YjhiJE0a+5wL10nCM8zB5ROkxc21Fl6 +PppnUe/1weTJlAqz5JmVWAQO6BXzVPqnCsHiOGxK6VFZn9k4Q4toN1eSS2EGKOClwG9A3X6kkubG +dcS7Muqooqjcs89Ei9RtXMxNXFnkT0df0DwHyw7Cn4mgcK0EZnH7UJGQSahPQxB1uQdIRYiziPkv +JXf75ju4ztOwMK1YSGHF/mCY9rh6KhTDOHiIE0SvgqI2Uo2w1u1Fpgtw+Syp7JfSeSjEGu32ZHPj +b31u0xfWDXqcYLvoodZd9KjHfOfcsd+xV9sW5U1XRHLh7eEdc3UjRkPRuFD/3jRVYfLWKb2bcrXH +uDl4uPUNsES9ElcQwfgiBqxDUUDktOE14b+uJ223uMdhIk65dDHVfJqsGBEKudBHDQd5fRN+FWA2 +9YyZWekI0wC8iuXKFCyh7rIOQU6zt22XTFYS8ZiSn2a9LITcpGl089gOApUDCUYGT7/DYUI6yw+7 +MIOIzfI4UmexmT/Eo3SlzcEOxpUW19eK1A/Z0DHvM5GNNSGmqHEWiazhkg8h5cwGh3Eu1W+kM7OJ +cuZoRNrE3rCtPnU93Zs+cn0x4sa93lMdo1J6KtE7cgdV4B5HiECe2WeTecLr3KreV2rrR4+40MT1 +4XDv3vO04ZT8+CgRXirsVEMhe8V12eukRAgHlkk0ZhyI+nt3qtfyOawO0YMBw+70kGB+Um98nOAQ +iRbbXqpN7iWZ19hLNn98aKQs4L57/duuPGF1nHbt+wJiOEjS3OQttK4pcKBFDhggVki0qN/6Lgmx +/FUrPShM1WTuJrRpgf6v/hQUE2lBsCCPcjNCyCp3FKueEFwVOye7ms7wFgNOmM9Lf2lnq0HiD1hX +DLyyUjWvf3FYOTLnMJdT0sWOhAWRe45Q2d9gSs08sscx8VEUWBIXlBUgZPnW1hdUiQ== + + + PsbtcVcx8YZM8mAzXzF6OslajaJaXlOxmo+RUpHCBcQ5oByXhSsi/iMjyE5SRdmnG/UJBI7YGDVa +L2Lcsgfkebtl41RuIgi05tJ2LTAuswqS28ttPF8MS1PHsCjIEjHv+Y4vPQEYgLXuW9aokEGJz/7Q +3SuuJWGZdbiqAG1I0ZbFdqNqbCy/HAcDQryYJYyMSNXMs54PeGeVVnkri1SldckWbbRZ3Tsvyt1w +fQCXxDnmBYjFwQWnTVnsCP5FKeB9zF0Ta7R7Imy7IIs2h4gHA4yaP3eaQ30ElBhLH6NOyRe4vNGj +59/b4ws+toF1qRio2KiegmOA5be0dAyjARnnxQOXTA0aHYEvmErxTjwuFggAg1e5ea43wJXHDMgQ +Lgx+CCkeLatakgFvzhQrTrFnxiL/ckzzx9wEaP6lRTG32OUxmqo2cGL20DAeUU/oWNiIHOnaSqx9 +obA89Cj7dKjHTq4KHF8E9OROkxi7oY82ds7VSSzYaEGFhlSX6hCg+aKTJEgD++WLTflg/Luvn4/D +nWm5meg4VW72RRDg0oDGu+fp6g1c5gxtmE7TiHJs+RjguVc6KC85vRoTNa2VseclC0yM9AYsESMy +NoWxNDMHL6n+J5YfW6wI5ZYYEFB+uMJknigQ0My/YDBPGPjmZJy6BF2YLdOSNbFP7SbM0ai0xgUc +S54zykfVX8kBjoaDuJyGkzdEgxFijGWiOjFe8/1wS4gLcRB+7n4xxV9JBqbsnFCXxNnbkEIItVWD +FvIS+2M6SopiXMlggHfqfkXzca+OAjr6jFjkcFgoCrhMx3x3M15YtZMxwLZbi90szyAjgW4ITvZD +x2/IsleysDE66e8sHDCVScyuS5weuSwUzQAondKP22kIgPH1uaFthMF4VpUbgx3Tusk4cAYC6pue +DCCLTDHPDYhnOUPj4NRMnTzBJ7IGD1imZe1oqKlnYa1HnDNAL2yqkNZAcA9IF+UyDLHnF9IaVHJB +BKHurG3m9WnT5RyBMZZExR2UiClatXd6kxgCtrjXxZLa3ljtu+J5XbsP5bpO6mBkoc4EaEiAy1z0 +CdiVpWdPaGWLPfB/EfWdxUIYuBI5foyzad2sHMoD1C2EgasSqQMYDHcEQiVwJgIeiyD5B5QwWXVU +er/iQuIkunGrmdhTT4fgmO3yrEmM+HpDT9D0oxGk2qORG7oMnnFbGTVZmIx3GtyGxbshtpcR0m7Q +PNNFbTYizQNtX8kAD2eeIla15UXl8GbT3D18f6CjSzqfk7UuO19wufQW8HMn8DtQVx0qhwAonE1U +nFATjTD88WmUW+4ABWQe15V8VU5i1ZLtRotoEpm+uS+VdPepBRgch0q5635eG0V7MdBihdFYzZGx ++ZqoPCESQJ5MiiQWTJISANrGMokmQfkC1uA1LHOwVkgJb1DCbESTDM1+SiZN4HXcqbTouFO0CZEA +ue6Jk8jEzQSWOahhgFCU59C2eBM4kVh6yMwoAQBDAUdBRBRuSqp0HW57kmBL+kEyYZBeiVF4QoWS +u3IkCPzyxi4Q3f0BQD9m5pUv7QAGgFtmU3XjWaMx3JRedJnXTB38lDpEzLC/scXZzErEIjXRIm3A +SoBR0ry2F25risSLbAGtcWoNmjeGVAXiT3mUU74RpgSCvQUYkcKgQaVJtsuCX5MJTEPae6Z3DQ0C +ze7DSYQQhaUqht8hN0hsz98JAG1oNRX6T4y+4s6JiTzanVVDNRP47ZjJ9UZHD9Q3ORPg2tpepMBh +ynWf5KMVCCnQdjwGoE/PTNIxBQMk4TTVM9SCrLWkVMvSrY/sPwIl8WnnGshSez+vmQUcPAfnEkiC +nWHV7DBOj6Klflb8iqlPtfLUBKX6VS3e9xv2YaPegdQqu1I0wxcfDZUQPeZ0RKhoSFmhVXcaAUsV +RchyRboPRyGLxogpq41FEfxqBe6SvHXZoGJDNtRuAy/zxKh+fXE0Rhheikfy3dNzMoUtqHSTBJfC +N7cyo0EyLxpUDVaCbX/YbWx0G0nsiSjqJSRC05qmkgpYeJ+cnAgEMSG0XvqWk69E9WZnStDCTDMk +JvQEUphOaKqVxB8PJh0mt54Lpablh8jwhaKFicqxBctSb3SlHnxjFo1Pdel8eu6AdkLuO5kCTMXy +i+owQdIsCVSxNGzwX5wLfRH2h12lBioVmNctnAA3NmuDqmJyIvUA37K5SyG5N90E5lRS1Vp+i7/v +fQwaNeVmoeQSHg810zRU7GBOkUsHDEiG8DDY6JueEmMZKbqLnd4NhuSTUfsl9laH/IQjzTwX+JKe +gFsWsViYliaXBzxqQrEmQfktswBDnIwAg2XNde/r2B+pph+PYMgp2YqRC5hFyQSJHAoiXDOEWD3o +WuaufCZtEqTAMqxdJ8xsyVLrkK91+bGCEpDwQHi5lXZT/TE2VWQCe99RZBzg4N4AUiVcEtWp7Znx +cS9MnuzV9mFmdujH3UHz9DmnQNvN36VHAvTowaZYBY7+fiLWaUr/wLjoBf2UXkJYet/wCAqxDD17 +6JWBIh9zGj0Smc3klB1mXmtfdxTaiQSbSA/YAwI93CdPgjcgZoiptMSUgI6xh3Nk9GgI69LDjPSp +mHFNNbqit0OEv8fco6mp00yoGved/gl6ryIVq3LY3HBTGDMnZxKxJFgwnqUMoit1ShIlLZI8Ps2q +mth13YSEy2+QTlD/7JWQaBBArFpjM1NJuyzdlI4k2lrSOP1pgvel/q7HcY0oorFkvuzY2AvI0Xl1 +IitPaSRn/pqdBh1wC+xWO8gwWX3dxzf5OGG09Mf+wpjmZKVdqQyr5FhEGzBCZHVZwosdSDP//Qy+ +ZNtyup8Bzdc+ULv1nbCqATk7CVBv6V2JFDdtjUXlSpMfI3E8OND34qo5TFH5/UZipWYwug6MW+GE +sB8BaKAwICcmWS3klVfKvIIvROaVVO7bOEoqGSzdvQBRtW0zgmTIBoIPbR0tXh1Kd5r2WlN7bnai +r4AupCCgnKgmNVSvudhPTCjOK9W9Y5GCYctzfpdYUZBy7niQXikrfF2nxH96dKFOECWqPXJCpuyg +3EbPwnI5t0Y7dcYbDWCVqGdjGTaSyfJXblLiRDDzs4d/liU82XHthA5M1sXae1fVDyhEqHGWanop +dkIohgKSHGfZVTgFL1Fb5fmVjc9axGLCu2pKZ7AQyYKjFtNNNTIRbHwGknNLrUXWljRkj7iP9eoC +4+1xxLbEvAzIxB5ZrcKilfLikcYt9EB/O3uwK6LHzcih15G6nyXFu0VFGB5emA7lwLE8GQOHMMdr +EZspkyg7kAyjQy6/RbfDPP6RFBQWNlFDFf/XorLp6eKDB5vI/7JLWSRZmTQIrSGDLJJ8LeVzb+XL +qqs9AgUdHgHoWbDll76x6l2VFFFCb0XVYYwuyVBPqsZyo849WbGz5ZMBx0yGF6PFs92T3tissJ6i +OkXHVlOKwC3zTMnTaj0CnS6PtDXW844DJDoH9EA6jjIhMQLB6b6RK2F2JFCRiLzWLagwsja1JPwZ +IgyScvzzJPF6RkgDWHmRVqQ0Zb4mvn/rSzePmK2Aww2tK4fbkV/j4p6ZOc6xEcQLmZ+sWVppiuOe +VfwrsADG4ExTWIrCx719Z5MG9NXgZeSHjIkuI74SEfKuTMrGuzqUG7G6yXEKHgJDVQnWcubVYwt2 +PRaHNTKppcnsSBKk73GZJFpv2aPvHkeyX2WmsIDX9fHxk0CLmeXNtl8bhrRQPTvOzbacm21ZUvwC +C1d6DFhx9sjg60zqNUIIKnpdKvJlDxLqHONO4DEcVHw4sQ313bJxm4Sa1CFZZHKfCBzqID5m0BlW +xaCD5+064rXEhnaJRwUZSmEyHnsEIffL2QJ0EeHEXHY6xKfA2uuQi81Ns7Ci7Kt498yjxCpZJzUp +tsRCbwW1XILQj+KqgQ3DzbVsie9evIeZE2N37jg2FqKpHuCtasC1mHN4e9fU2wlqGdfELv3o73JG +qrgsiBAxttyQy9/uWeCGgqgABQS9nuz4HVkP5QKwSuRwd6AkTI6cHnP8OhM20m99QsbIqKkQkYHT +lVDFE3eK0zTYu+YKizLTAjLXK9NdLdEhcY9C+4nC4hMjNw12Rr04goKlB3Pzk9WhMKb567E00osg +DZgA7yoaLXvRwMxJg2OSWPlEMBH/bieeuUHzKKmtx9ES0Qz0qeU5jawJcNhfSiFAuwwKQVFujsSJ +rGsW4JE99hUZDESD+dlcaEuspzIH0LEsb6TCU8lm6TuGftginD2vrfwFRFlcEiLLMcjOvcl7Rwgx +hbM+XhcKGgqTqhXJDBrhXUVdBYkZkWwkLMBRgMNCg1BeO+qMLA3HTugOYsiqBiVmp7miLrSvlxgG +hLSGSYA4TkyVAk3QYBiqLLkAgmd1c0KyF8BqLPu4A+8LrykEO7cuDZGRCS8I7+yxgC2ZmgR3N688 +jrs6ym0EqagMSaGbeFuurB4ZkhPHX8etRZSe0IzxiJeLu0Mhd3E7x4ZMiaEmZT7lraN86Y1ghI1c +FDLz0rPBsFqYK/d9LAv7dMKLx17dCpZK5qnPmUJahWlg07zRyaAHWxufGKVWdiCY49gj4uMLfe7j ++AJXq5Cg3jrVXlrvcn58C+zBwkmPA1Re9MCwgx7xqlee6Ups7lR96QBuFhEDC+F53LDqkVVGvGcR +SqGEApdQ6TGV8eLVAdG7RuY1FG8aKpzFQkXycCX+KiGJNwoXzA6h9KHOmrqPW8BvbIktAMot8w1C +Ssm5KN5ZNiOOaVGO6rNNzuNMXnic6ZKTzigzisFoCRxnU+KezNDpQ6RUAVwbOVW1Cie8z7RQjDke +qBCwhB3vYyYkcpkQ+dzsSqmEsTaIrjTTwHE6mjap7DLxNIwephulCjD9AEBAFG9Cmj/eYbOQlpCK +w7E5e6WZVQfCppilCybJImlfbG7klpNC5k6G2SJKkUVZf2Iy0xB4EvYb8ZqyByhqFQHLFJiEdYji +7b5T10zWBkv47vZAxkQ8IR6urf1l6WGdvh2J7ziFnO3R1LbAaEWStSRWVPwJySMG5diKrbHIzU0R +xTgYMI4ocDB62+E1l1vle8vj8JYLyQfLFEDRRPciMVDL47hJi5ms1jM9WXIi4c73mfYVLEgd2UP6 +WkFj//1M4lxgtAu1UTsl5T8FChtApeUjDkSXErpbH/TM/mRCLr2+HvJyyYPTxrEt4Q9TaorwUoVv +ElYthRh4DhTiNvNzxA9Mxb9TXuwwiZ7T3pLGwN/EJONyY2WC8gCQSM6S+JDEnwDsTn59TTegqS/G +XhB0WUFxLtbrTK4gIKvtZpVazgnhQDPy6zQTRFlnaNCGZ7t3lCsZzLqR1p1KqkyZrRtfai8kdz3M +yl7MYvQCKP6LP0nqR80jIDRuWuJQlG9rbs+U4slfa5YKYqlvmWEpIUQ+fj7pydrUOtwMuZW76UEe +Xe9fZKwYEL3hn/U21spFHg0peLBoSKlturJQy86k3dyLOTSTWX0LozLiD2DCYGuaBQ== + + + sEqalllIIc+Ji9hppKbUdIYOZ3p+sOGDGoIrQjxakwy5NySqi5AK/NWpnu61Nz1o1sdS/KV+iJRK +4urFNjQCAaJE8D1X+n4CXQM2S8VqqXCEca50Leyhq1Ln69bEEvI11fsn1LUswsoF71OFdnQNEKyl +Nk2Hv93bOTkyVp3QG6yJGAYbTt6cIEG1MsAZp2qtF9AxyuLnnWYgF6QKdXx9Q4DosRXmvMIiByeG +U0wsolJORSdcb+DsQH2hGnkLz7DSiH6Nb4J8x652US/M+ioCr6DczqxTq3d/SQtHElM9a3WaP29E +phkOHZtREt0O5FaqSOVQqfJXPUslPwpS+WMiYf7nH/FL/Vcf6EfNEP9X//PY5uX8j+aET8aTckDq +pRrkEhd6bDPb+KJ42YnMhwPiNz2LScDnTpI8nNKYPEv2YEtsg4tlzGXFXWrdMT9ZuHI+1kLU3kD1 +YlQwFM1kBdWLzQ/NOhqqyCKjNczJsma7d8Q0RlQNYB3QZqOxZsIHnwW+whh9+OIBAKBclr9Y+xfN +XzyKeZ5L++n4sikYqkJPfA1OQnMaZN3blTX1kodTSWdhK1lVYVSrPCePbVwyE+H3xjdab5XOlT6U +i4fjVF43b5KFP44AKqjeOtxt5g6GuMXTrCzZMvWqeUHWVWXuLaIP41d2ODY9RJ0sU8iMergxtOMy +hhI3eaXnwlDk4eLjhSopMCRfzyQ8rWLwGhsufAy/nGqNRPUU69nI0Ugxy9OLKWuAkzq20jWlafJa +0TCtV6A6f0tbW7fm4sCzaruxL44G8S4ywE+lg9XoVyfy8t+PPChaKBSG4JSq/tNzEoAi7Ywaq4nl +V4qIh5iXscmDeInC+N4NHg6VxBOCG9HK9f4jk1dEcwVtLsvYGgQ8/x1phi3o+NJW9pISK4UKgqOm +gwhxLiGfwqWAmGsqxe6/eywQzOAOBl6awr/yN6igSh/vCZkiYiP9wA+E2Yxts4Qs/q0CThsUZdAs +q6YyvurcNBB0RsPCc9RRp4Dpygh+QII8bXhA1Gg0s6Jld55KCcWB+aVmC93V3QbJ2nhkEzBEA6Jo +HO1W1xvoAlFei+8J5jZV4eTlrJ3ZiRGoTSKxL1HJy9+PrJjn0Z4a2dYuQ4l0zzYWA0qG05yiwadW +ZQe1mhjOJRtuLwOAG9f736bbzZhIOhB28Ivzk2XUl4YvB8ZLI/AvRZSx7+nor6PNsqxtkxtjZDCF +MyoXGQPG9qbAMMowrKfmuyBDMpc5M1yK0YN3PLUUnxdZhp7Uvyt5HjQyEdIoiMQGyjA0UCSnSiTf +6FBjhL8PMJfkue7BSVupHmwBekeFfO1LAHYM5JIPmL+r7nzlj/l32+qDfBVV8cHaYz4YTH3CWxhe +wp3lRTU1Zhsyz/A5ZQaNZAg/GjLJklS/R2dibHf4g1RnAXZmAk/R5FMS44FeWS5jVKpYxo5btp1e +csnVGcpe5ETpBR/F41iSxMwwUxEVwMl0JZ03KfNfXJD/xTCkiRa+/nWsPCuy5hP53NBoPxKxoX4D +chIW+iaCNYIxjR9TINDC8+HXQthVlKIqmcIj6nM79mWsCAJSkcIkM6rZDYrRBuoKNJDoR002wZRl +qyyyQEmNSUno+3BZ0EfVcioBPo5UNlQLgvSbLKztwKPcphp0kzVt2nBtPQQr5RhgYXyg5Hf/5EYb +soh+bSdEyalIuwAQ2Cjpf7ZIAqXjCCts1tS3kxTjVfA5kGTZMrdgtJ6qyDWk24l6rZIL4lydDcRI +Fd8bs+ouAzFX+JGIeVHAsYF5n19dphhzqpabwtZU912U0QHi34KDwKjZt8NuQRaVRkJ9aMekL+Lv +MNX9+6kQasoWYqcEdMWGByy3b2scNgHOuDg7X44S9yWnlXn0XWKOUw3uRwbd5z/i+BahazakakBh +nV2VJgvgZQ9x0JJSSSo6AAkU6HyVA535K+vs2hrSo4y6AQdtAw4QVwF9phZpxARm0NaNWWCirO8V +/aIVHOHX3JCEM4ELgzKINf82dgPMqGiAmkdDgitQ4+z7p1TGOcF8VFC23zWynsQRUOlIhFx4hTI+ +TxAwFoVNwe6006HDaOpcA0ok0xedBM6/9Mhw9so6yEwizGsvwtQusZb3u5J8lJw6coME0oCT5cU2 +ADaXfDYNpLGobse7c4Lk1clnRjr7Gon8il7QXT2On+289V6vkbny6NGBN9MjKfNtNZXD6MHuE+7/ +dUcVxEtuc6Ba5GE2A3yglJPpV0Ll2dSyy8NQjoXeqNGVnLHLREa8nDwRdXp6xInvTHLNWYPce5X6 +tKn/RD5gPsmuyBqYhFpgTM7ESJFCgdhlFilNXzqDlPzhmSK3CCLN8b4kkQKCQziTS34kEmOIQZ1y +kGWbz8Vt7nwVbsMEWO53XnqI9jSjU9d127y89hq7Ph7jGeiFPiQp9QLr4FSBytL93Iu2i1/mgGOH +JJXoqcfXO0WbPPFRBq7mHxxno68mEXTJazFGsoGaHw0zUU5S+iYz200/fumFcqUOn1SiXcfvfDmj +QzfuelO88NEphhJqlE5K6i3ZVUYMTDtz3WfqKUjEOL7MvEJhkWFV0h2KHib2o0ffKm2XCFr8KU87 +5FOl6LstmhEZUvXovGETpBYr4wBu1Np0s5G9hl4+iqqTEtPVNjXGqOuNdkNfOoiBtZlq1FIKQLD7 +BOcesJAv9gNhgqHQoayCOzdLF12lSR+9QrTxfLouTi89WtrYWu247nTtcy84DNT/J3bk+9EPc3iZ +Po4ex5Z+nFBN0kdHodunv+fEdru5xevsQg2ff0291KwBonPK4bLGXR80UHnqlB7ig3yI8rz00gBQ +YtYSPSnNfWUaXiwQhuJN06C27SxuxuW4dYMQBiu3xtqVfAPgBoiowhv0VR8gMrL+ChDXum6qZz4P +Bmq5mck4DgIUHXpl7MUEhWq98c21gfrosJaN90tdR7070+FYOjU5BWUYa7KngWFkSiYe6yxpO++S +Cz2RCPvzDdbIFYYS8Z55lvlqprhLGJoSeBF1pH09W3vhmjHplF0Th0chK5HySnzUV39X8DP131EP +JYndqQAmXEEERkweOERmD5Rf6WGch0e0yq/xZtbcxy8qnM5HNVvYw5k/h2PJyc+1cXVpQXzsJL7E +x5UNaoHHqEq552P7n0e0dMv6y2Q9U4xLqFplxTx1KEloImpbrJXzyKI8oTi5ip+OiP6Y+wsw+hDD +IlzER74q6igmx6U4nmMy/2IUC0wHTkKScJ43LbzD0nyLxnx5+muvTfq2FDbRVLkUQ032YBEBYQ9x +/wPtx3LLbh5J2o9ex0w5MPQ87XSqzXCYESQuX6K8DKhAKOEtAVj+2vo39Oht67vUPMZ690U9tpd6 +QeQ9w8FL810eN0+kmKu8kaWCR5kF7KHxvVjUYUNvGyaYLI0qVQL7KyWU4XGCrpLDABOZWj0UM+xF +B1CW2LCcQ+J+dEBLrku9V3RirBvJQeZbuO4BRg/hqMmqJu6Wn1UJGVTakGYtgj4MFo4MFjqkMZQk +OyQkFOlmLgQJ2ywKVu7H09IEInpB9M5ezhyggUYyF9WahG12jV0UU5quIA68exAz0UNqLHk4No8M ++HdT5SZhyF59Xw+TFr1aVW2D8qjKDkP8NCsX4SVLOchOb8niXr2riuB494s+L1PXRTJF11ebgNwh +C5EQ1j5QM6MUFmRklQ9Zky896h2MUIS/7pfShVZmr+smCwABhCwwmvq9mlteWhF3PCfYYJUNCSAg +7GP/1elDPAhcqdZByd4/AOeiGoIxDKCDqdNxaykeoGx93bL167bcScMPTDPiRaUrRaLlKPnWZCqY ++L5Q3olVDE9sgnL4ZIKXI/4m0/1o8Bqf7XHuRpSTSXLDV16Tb7gcZhQuymgYkGaPmT3IMKURyK0F +8tyoCbPQZNF1ST+z0BVxtx/KENQBGDhZOHUn5yNAmG5bsmywe9wKFJLnhzrZmMHZqZ/ZSVET6sPp +HTOK6iyqIuM9gqqXwhHPPaBvVOOJdrujfdDp2OL86uTx/urWrD5iSVspu1+ZG+bWxu7GQwyyXQd5 +6XEPmyTytoj9P+pF6W5J21ROs4q9YN8F9uLU8xXKpdy+jnjY5VeRrAd58DcpcmN6oteiYKNWrXLQ +kI9JyJSV3ySVfei/U7vK5HSeFgNjskgh3JYkKrPFe/fKhVrQutihsuIALdDZJ763Q+Lkmeag8KgQ +oLaHyHoyMzUlzHP4YvrlrbQd/aDYeUueiJtJ7fzJTO1mhXR63epr6jUZQJQ0n6Dc0W+OrlbdfKaz +vfbIt9LTwwN6SMovlI3jotfMtytUH2VcHKC4UGoOxNVdf8nXHuPTNu3QgWWf6aUXRWHeLi7J8sFb +qm+hTKF4NcbB4jcxPFnJxb7cSqHXPftrj3xoyMd3dVnavD48zpEFAC7EtzxyEodg0JQkeuogX14z +CiAie0Q/d2IGhCCCksxoaXeVHusdGYGm4kTyfJAFOtKOLBV3CuJO87XH/ZGi1clH2tC8fT0O9sWy +YhbgklwMFD0BP1s/7MH2SEgEO/mbbts3aM9eZ84qypNAOWjQkYH1pWANuo1DUVCUO1COOIkVGHiI +E5A1FJr/0iMfXkk0BMkNIAGvx7k1vkBm9DuW6kfGUkWF9F2b78oqF5NfMHpO6jp3KLVyNzTTj4l/ +L9KQyK+o4E5DRVkGU66WPdJBjWDRDFZP3StFtY/34+r+chFmXnkcY3nOXmsep3v9hKsbgJV5wYj8 +Fdham1t8bZMBBZyXJl71QVkuSfugROGLGFQ7U3tDr3XkubQQuXZsDJdFjfnqZxBrFWqJu0PdHXaG +p53pxwensiGC/tJL/rAxY0UTqiiNqYZI7AbRB/6oR6rHI233CGlfO6EfqEwAuZC4ACrZxVSViZ+I +OmCueR8IM8IEOVwwUdoQShCLQHuodNWc0mnUYoUVAvtlPLRSeCDfEwIeAqMi8q8IPWiy1YYdbiEi +KOz0iOj1fBw/hToOvqhpr2Z6ryOTsk+UUemaDvvLbK1KTriG5wup+ULG1hwyy0GPm9LflDhgD1Hh +LC7ffIfrM6B2yfo9M+ZHzVEJf+jappNjOmfC+6DHKWIp3hlV0JtI+txLXbGRumLnOY0xUyANUXSF +XJ806mMeFsf1ocK9VBqkAE6ZqrvX0pCnZ61+pe4XsOQco2dupVPYoykAsdzOrJ1MRYpsbd4ZIp4s +v1a7VSNrQs9ZNhuqodh1nUfK8mYeNfqCVCNazWvD+sFCzlOPr+/Slm5To2sl/Xocin9JsosPueQO +Fa3WhBn21w4fro3PnTTDZG7Gd/skX6BmePLGgNpN8EhAEbRkgWwTC5NM0bKpgORegP1/3iWKXThQ +cVdyC7KVUGQjoiRxMNMWAp23JXEpbkTpKOqt1MQm6GTZFeCiLwlKuh9OYqPj/ML9dNZ0P2UniW48 +tUjGRYUg80wkeOnx+50cctp+boRzRqIERuvhHhKqNxsa9G6gpaBjqeNKxEULBTLJgQ== + + + sYZKDiwbpWinlp3WuDvxsuk01z6MeTBcqsbusbLHga+4PVb2AJ6XPQjh6DHvM2135KWFyNpcxUOu +4hJSpyunf9/mijHRzaQqSPuKX7L/yR7Ifc35jjg+ti70Ii985Wu5StIYRO6hi3ma6Yw9EdlbfLdF +6B/x5HjnC3DV3PaOqpXh21BvEfZb4BPf0ns/pKWOlh1ZAzCUjT+sKtL/TkOnwZYG2kM8EoWYdE3I +pCgGvjfwobWNM+dFH2mbsBCnmFRHexpxA1cmdb8JPByHDNaiELTs4XQBJOx8Py7zMr8yxxdtaiFN +KuQMmA86aPkxqbxRjOSo1t1RuJ5bDh/WF3L4687M8tFCe5pSLk4JDxW4BzsfYEKx7T8Ov9HLKh2g +Lllvpvp7xnV1Wybja8c4n4pXTT/ZfkF7OAauSDJOskYgezjlv5juEPeqMDdee8Amk1fJ3PTApa4t +nkyvriur1hmMoBRfRa2xYv0qvKynZR/FEhD/FVwsW+09HlMmAi7naunj3qoUzi1pT3RB8pV4aaD2 +dJ0uMphgNdQE5pHAO2dGNu6+2170xaHxkFB5pl1hNJzkMfRjRNqAsNALiBgKuBK/6DdBkGiw5d+k +Vl1rc+WADxWPknJJdGRM0AAKHw/FhyiN1ohl6fxXVRpOq2LWT33nEcoT/Zu7ynNHlBHl8Z3QQKD2 +4CwqTgCjAaFoG0f+qks0nRo90DAUGCIAA05Cw/Ist0iHTbjt4E2L5h5VXklfHKykcMFc6W6s7omn +J/2zEIP07EIF76clhD0eQnwKU6MRPeyPnlo+ixTgpdWojiI2JCh5nEAFri/kcl5+JSGsI7YndWf5 +1JXCh8uk6nTBAE32Z1YuFqZ1958zmb2Sy4+HTvIt8yfUM/XnLBoIb4IjWJkK9qm89sAApLQ7t//U +eF6J7SR5bon21AxJTLZsJj104kn779tqEFUqXyHUxWO9d+Y9xZaAoNiE/v737dH6eJdLJLraMdTe +ly6l5Bje+o2wW8SY8aGBGzu+eCiFvyhS3de6CyFZ47rSMIYCifrU8V3Gt+QhbgAfbdJ3KcGQnOHf +aOirTAp1d6PcbBC9TnE5bUAjVJqPC3FOjDODE+PqFyVVbma4tunjlbwrdJRImw1VTc/UE3tpyJH5 +HES8/JyRtxVcl8V2yJlDNBVY9eu1hw//cYKnRnxoxBN5WQOsrRLFCP5rjKviqWRKspl7N31tOMVE +lbY/GoXcyBDI9M2bMPNLgRWpKCeWE6oJgAGWl3+tUW/5kLoBO9BWR1plm3klMa3hHyAcLTfFuvcP +0qrPPS427esd24Oxpo3tUMNraBOO4kXKQYjQEmCk0CTMBGPFeCEiq1syy3Igb1+iWOxPvF0Q5BYr +Eg08XBqQrOJHfhw98bZLn+8ztcrujBix/hY6mwrV9zQIWEvet7hFrsCjpNzyYGCqmzZuzS3oHxoO +I1IIpNnVxNfp/BlDfZEuB1ak4+Bzg1Cr+2BPbXAB1HKEHzFE8FwprjLuJa9uEuowUXT/PWfJzBQa +4DaFW7NROYasAGI03N4IK0S1P//9ysXtLhf/oPHWdqRGqxU8rtVVFcaEtLK4pblrW9hmPRoe3126 +4uKaXd5/FTO0Sh8LoYkmw0N0F3ggcsI+k3tjeCHOsfxb8VvdcvjEj/4Y9eojG05XurH0JassL7eX +NI1GslmhUNxPla+yuSwDiQePpnBe18gE5OmID2d5TXXenpPn3EdbfHkFpsdIkwPwFhBUSbOC0VSs +4fnvK28lD1V3QMPioU7GVoe0mkSsHuMQYPcnU8GWy9XXjw0yg+puyOgsharICZ94ED1+Vc5UMKba +KC965joBRzKRF4kFNyqTCQ/hgLKkr2VjlCG468+x4NupOZYIebjxbCxJvUgfQnty7SCvbsnoiPhP +aFs9vdJFRkAejh9pRY1QjVhDaJWHKJB2lfQWWHPrw4JnyjC1qhH9/qu+RR9i14aIeCITgdM/N/TN +SsrDPTe2FBqUmZZ8u4ruiSju49qkT/WwO7wMYfT1SziPdQsufZ3ZKJId5MiVCLWqVGBq+vn3Ja2y +uyUHlP/gN9BIVQyNjJowN43VKbcgCCBrkEjqmYgKfeJ4YJjw6xP6hnzDlGhVjsTErcSyzbbvXUW6 +1wasnG7bi5fGMwVYxw0ojU8cTXees+qLoHp2A2mO9mjIw9Vc23XKSd29/atjU09GrK3CFUFbND06 +kgA0AKlTJMtn7GCj0bg1GoFyd43rN4+wgW9+s1AEAYM9JCVe9pAxiQKWr6JuXhqQ/LwN9Z4bC4xb +ETNjA7eZvycWdqi/QWa5asITcRECGH48wkYZIUwLsR7Fn/vYLKFTdxVSWcmeyQZ2RGSLkjfwEAx+ +aYzvMuVoweyYkkpbH7C/RpQsnmrEwKQcK4Vfb4m0vnUtsAGXCd7BjUyZdKoWIDXsVqZuKDFzI5Ra +JXnjatVKbeNRtXWBRjkmoncIi3jtpXo1ey+qMwSjrPw4ksgWjBkVYi+lpgJenoy2WshlS5pc1Nhj +dgVWccn9gVOrgFhs5eZ8NNxwgyzFIgoVL+1uRFUPwV7kNCK4fPxbqR/qTQA66i3MfDdyvyRQQOwh +so5AYSo2D7+M1NzRey4+l3gyaipjrMWcle4U6Nihacj8wg7988awIMMBhuVMCaw0fG+LPZPKuqMf +2tpuBwHsaIeigj8Ff/ljgm3kFP4or/BfebADs8fxJVXQ//Kr+C/z7U//7O0//6cfP1l5+/Offffd +37/96V/8/K9++f333/zuN1/9/B+++ve//PY3X33+7rf//NV3//Wrv/zVt9//299994+/zZN+/Iu/ +/ua33/zy+29+9VWc4gcXdz2u4Cfoj/+B/5QhiNd2TI4FHQsWjYicVkyraFHGikvGtaJTEKFkMvHY +FMgSh9d68UGpbHAwjaBXFaPsDSQPSeLHn/3VQIUiAhBwLNeHpMtYU1I9tUGBIHSfoNoSDEWjCKQ4 +3kK17m6kwaxXA4UIImICSr1sYHdiQ4n1DTzIFgau7DSAvwjM7ClmlOJjilhE0CVQc6icpljT1IWz +v1U4QhFZXIh0gDshLXmauyxafHh8UA3IZkYnvM3McCrADxM09ipv9uiXPSJOT6W3EpEdPQ6Sc3kM +8qNxjF52lvTax9+aaThkCACYEZcgyz3TOokfgRnMHlM84dHISNJjEc63xmQxs0fvHoN3nScYPSUB +GhRAcn4oVlAIQbECSGXF45D9ZmOzpu7Wk/JFhRiBhX2juHimGJuVUBfYnViv5D7hwfP3SS25le1e +jTJRLPExylIMNoKYoURWYv/eqohOasXguUqiHFNioZGozomqblP0mEKFzSXqEh/VWUGL4cxWc+Bp +iGFdfaUz4GSbVYdud+xMIXkD5k+EKbdJt52xoRNqgXRC6Tc7YYZIJ24E0e+atWfYm/x9rjw6Ait4 +6annq9O4gn+XFJXH4Z1wUSJRlWqc20vmQghuHwc0ZoeXtg3FqeVa5GbscgFoh0SHI6UbCIj24dOC +WPdp9K3BsBWhW8eJIl38GiIjPsdrzoTULPP7JEbE4B+Y2bX77xy1mATkTqpKQI/fnFvLYQg5Siy5 +yEX2bGV82IP75+WKfN6Hf+m0PqluO2EB6ncIKVdZ8higQtLJ9lqen2rCU5oTofDc4AkiHBKQ+vKr +Kxf9uOlVtV7EEeXiCz+mVLgr7dcE1hVB8ll1z8O2XdgsMWn27JUwmgIy8cyfp1dmPPEzBSpzngGD +6BW0RGVoZDhTHMSZacrZvc/TdHssWytISpVSHwBnh0ch3qNHw7ynZODleRRBp8eA+THQKukfSGXm +mYYYF7klqe7SMgca27NtC5gpXBSF2GknjhuxA3DcsgVee5zuOBi/ZOj2mZ57gd2d1O2RJGPOu+qG +rxZVzLVjOoETS76u6ZOJz8FFHkaw+XMPz2RsWOPAWEXz1b8cR1FngOagVpijkb3XDpZUkuaBzz0+ +GsYvnYB/FYvDLhJsqUC6A6lXAXjq2i5kQXjlQOYN3BCGU9lhqr302a+kJXRWPyUALhOpzwQEbH/d +obYQ3Nw0Uq6m4H/vU9ho8HqZCqNRxVT+XrV9Anu8sriraPDC6XgjHvRnRnGWF43u8Q7vbDwPfYmy +oIqlBDyo6DWtw57Hru33ngbY9AACAfXHonrKFtNBfRFPdJTiIcqm4GGKVixtVxSacinTS57sOqSU +IsSCj1vG2cw1XV9zPiUtZ690TQUc0tp67eEUWtJ6DqfSOT86TgRPidLEFEXf6Ng08V0SrBwZrGA8 +lrHKJq/ZxixOGyUMIpwx80fssGmAxGVMxBz3o5HUHVcnwbXdxfK4vaYkKNyTtUTrFkpZwtDxiWAQ +mgMDkccOLC2TeC840mxpEHYhCuLBAkAunqo+Lvas3RTURKDsDcpWjaFtVL7aJYEVsAdJ1Ja/BuBS +AC3y4oDAXOQ+epy6THtcsRrSo+hrRClvauSFJepGt8PJIzDxCbYc9kpBIy5IcYweOFvQY5D9swcV +x+ixPNGlWwMd2sr21R2aQ5FTz0PyiDkcyHwlw8/8AQ4DtQq+t1aTKhofqByPBEYJC4mJlYx3bLBk +VF5Eyq0m7DoNyoseQLn34kPAdS++Fw3R5KEIKI3Zo5G2U4WVC4aTl/rYA3yDnmKY1rStYR8zb3wW +IyW/d6rWxokKllFQS/qIBfqYeSnS2EOiRr/hn2Qghw06XcM86yN/ekBaYJvR5vsJsH6ilwV5sZdS +yVrCtehBToseCYKjh6OO9PiZl1CSH3ZceSUbZjqRwN2vZCVBoqBbWzI0SawoPA821ZosQhID3eb1 +nhlmTfNQbz/9kXzeH1VDuIhlp1bmZBVyUF/Nr4iSIA7sFQr1UD2Hgpg/YpDHj/B+p0GVHhqMooGb +7+WcvyGORufOQ4nGwYdPA3ofNKRnMQ2x6EZcRhqJg9wQ8ojuBJ7H3N0tR7PxAIRcVRbQOYh46a3q +nd5hDQ0Fy+6G3CCURPI02K1Hff8Vcx4q/uBUSfrWkoIGMX7iI8PhXJ+S+IVMjD114j98+R3HOIrF +hLwOYZUNDLD43nF5bqpFxsViR4xzExovGx/L31SuQ5ojwp43A5eSnXMLEB8eJQH1L2f+PWYE/l5I +NjXcaTewr6J5BUKHZCcxPz56FIsqgF/dlGtshGBYANQZbHi66ca4dd3/cBW6K5cVR3m0BT2ZJh6g +HpirR/phNUo9JNNbuky8NESEfNRdmnltFMoZ12BGrCAfHtvNrk0RtcFcE6pEEEiq5dGQV5cmSqxL +FSfux69az+mnswlAISwL5S9/P9zZ5LF+2NQF4+XDwUQDyQ0+ALiiV0qHDtL8iDs+lryWgrbq2pO8 +hwXnC0OQPX8EVWKkVKvH4qbRnDDBhgDnzsJXjTaGjVdqHaS1Cw2gmC+EvClI04BmDg1NbHrEsqjl +SpPdSIva6n77ESxQnuaGYB1UhR7Q0kbkAvWnI6uBrw0jRRdylD01TuajlveEwASXXQ== + + + oUzPMwsYbLz1sIlpoyBCdjfkZ9mS79VYnMf1/itwHmYTcFXBPaikIOtLgzIVm1f10iiTccThNDKO +xa9F6FVST6bGehBBjng+sjV4mXzeBxF22npmO9Ur5AUg0cLnB5+aYuXjzZAP5Hk0rRc03+GBeTRB +OTFVQtcvKsFneSKG/ydEga7YfIN6VrCJJEC90o8MWheQt/TDu7LmTKOb14rwaMmEP5N2JWYia8lO +WggWGz4mj+NI8gY24l2llrzqnKEPwcvR6LPchtL8GVk//qw9BQ18rjRoJgbC/kZ2I0NKWMu8o6xM +vNIz+6LwQqQFpYkGUaE2FEXKSazUh8BVTvfAhghTMCXRwDql+1gHFGCsVFxkE8bK03Mx+XAdu6NH +mF8Aq6CG9cYqA+17jG30XLaLS2G/eFJZVIEKLh5SGMhDVyIOlE3RgcLbD2oxpn8dAnw93+WZaUz7 +oggg8XB0VqZOfR7bTwd1rliGadDLxk1N03nwgLxI0FV22dhGDwI0KA9iEjseKexzIIBTG8GsB9MA +BtIF9UbPkiDHXQphRzawFqaHmfOmUDfOU4kiBgwyq3hjqmMER7clOM8jUcqU9bsrqI+bo1RF0Ft6 +jtwrgnlzDZs7gH3osrHetC98n9CMP1JLjUYrHpmoP7qJel1FZ8qv2cCegwbsagDN1P5+tDR+2iaQ +Saa75Gr1nPXGPnrC3FPpVD2s4/3dJckQpt506GVsc05tLlQvB643Vkp4vzSAAXtQCp/aQPgD06Tg +cEp90yS1iogCNAJFs3v1mF45woj7xMw89fAERn7UcTV2bh8cB+1dtCyLGsCJvVG1YUXMy1aytURt +XfAV8Ya64SeG7RRMgT/AYaYKCBYYQbrGQzPYrUitFLWvK07Fi+WvcwesTcxa0HTaBz2y6MM7L0qg +pcn6y3GgjvseB96Xym/rq/DScOPo7tHwg0bFFjDWQrhF27RYuXntrv2E731bfgF4RQflbsjof2uT +FqQOYXTcvwJ5DW8EcWvVXUpiLF8axpHme3m458YzYTWNBPSVhoMchIWTbFIxKd8eDffLn27e2OLN +8v6rkXK3mEdJ1B0UfdmejsS64LSl03lsiy19ezga+VTZduK+wJ6ZWrkNfC/8avj3dIgb28iUtBVR +3oBueXM0oPCy+y64SzXNLwWL0gApk1Cw4GNIAyOrydY9sIBWE8Hz3MZ83BJwTqwqqjrXoOrmqasY +FDqsswquAGRTnQ79NGZ+GuSC74Z8dAloe+/cFYvVpgZcOhoG5NlfGzDquznoL40bXNKU2eXcfJun +U0+uUwwCSj2x9E1SpHdD3uMQxEAymEn6i19dmag8fDZehCakLw0TV8LHI3tqRH4NXExTK439bokP +hGrtvSWT0Oj9QNitj4Z7yOYGHlG4CJwfv8KHB8XDwqKEuUGsIK9/JYKst6fhc6PK3Awp0Om+5iFq +9g1vNCrnDZDMpVj8EidyN+SdnskbPtj4uG/bv5pTy5sLrxYemAvuWG9peTe3gd6GYh33qlQFAWuV +1yElbaQtDaq7oBaTjnb7gSr2yboeY4rzix64/VQpXkMTicYI/5g590SEfeaBq47U/UpD7q/9BbFK +/AIlifZuVEuNvBMaHYR/AKrKfnLKG+MeCZEZtG+MwOUSvVJjiT0L2YG7IReoIiGC5Q5Zo/dfYX6Q +8UKC8gqpfB7USwO54Qdf6rlxIWSUsYmMsDuGXAxtbI77AAirRNzNg/aKc32m/p+NYPhoGOnsh56R +im9LihUsAje11yNUWZtZQN94qPXIDa/HQNyOg0PVh7xrFkgYItfOc0Ih8sitVd5Yz02FevWnj/1K +RYGyhRaYBNlYnwmIeW0o6YT59Q44f9DYtSbJYCJWWgMGYpd3kIue2iT2I0pDZuS95TEs5kAxGjX0 +L38HONOQDSMGfdR3fI+6q+Fi7MUJdsmZkih02RfBzwVeuAmRQcodFpM0Ki1MKXxyb+dOPzQKnFxB +LCBQnc4v0hLmoygqko8ibHv8CHNBpkhwOoCe2fcCiXtp+MG0+9yI9ot+4PBvKHnGEgHZEq1dLY1a +SXcLvB0gfOrg0fZ2qh3rzlDBdSvAi9O8+tjCFRWWBCAZdLpMgNXcbGMZQXYbzXEQfLk7m7Ku2ISp +jgmUhCK2pYG4qop1h5Kt/v33bhBbTjl8v+3RFBvQNG2Nj+kkqp5Hho/sQkW34CQvnrYrSZJb15pT +qG3XbiP1boMF/kV1Phv63dB3w5WSotddisZ0lRoiSeR+KscZy3PzVz7saKg9BZxlXtgA47QRMg4b +ClN2Hi4+HIZ8PD/M3GmU5EHDNEUAj15xT6yq+XPjHWiXcirvDvfeYxEgsOmMQTlQoWMKtDiO1aLH +Worn8eIcB7XtxGhXW0Z00/wyoQSamb+ZAwEOqK8ynrWY8hJVsQsl88SXAwwWBgnY30c+b29puigU +G8++8mjOOzTgDR4NogE9GhUR8lgwkrAAmjcoAwdvOJkEBaAAkbE1oadPbCOZVsxiuLVkPQBOVqCw +gsQ9ZAo5BX/eqRYVU+L7Listbk7AokBHZnIXIMEOyBB+oS8NV0mcZmZunhoBvyOTc8nT6N3Xl0gX +cohUrBHppISGxj9VzIrmDmFFw/eCOR1Z90K6+wTxtTMoc2WGFgy84qD1yjPBP0fyHZ0hdL1afFyW +GVlm2TwyXQMKjPvOqbUV0oUtyYriW+An7RwlrACRJkX+CoKFakmgt9uWB5FV2IpiTdlDYEZX49ke ++hDDtq46l16o3lOER6j0epwHfh290qfDiyn+fObjgADf0vi05HEdP/yClbWdG6HWedU796U58cHl +x0x8ZjVv8xgjtAJhtIZcywvnFeuG5NkVDFsde/aK9jBSMwp1+6SBjZhTQD9jn4iBs+ZubP66iWCK +BjMZkPT5rhU/gImN+AGU0Hq2LBtC/RFHwBWQR0cr57ZBt1ejSqL9TIoo5MBZEEdangm8N2dChTy1 +YfIO3FsjeN2uuUmS5UiS5Hx/00Yg8Tz196mpSVCZYEQougPAvZFaV3tvOMAvNayCZr1VrO9Gienx +cVdjO0pvyLDFxaHHBDmjUsXnc93/znRXqvLcf2N5gTFU7nKL/4Q2UvXe6oXy5F4Ksw3yNeFv3BHq +mm9k0IAyXxaEVjKxdGEhyV1PcoXMP6QEqQn5ZT71yNcw1X24YtxQCfrgOOeWSuF1Nu00y7a4QyYN +LsBLD9lfbdvbbUmaD3qVNDSBf3ZaH9rqBKmOorlUNynYMt1WIZ3PfEPKZ1KU7zvXZC9UgSrrhXrN +aE2o1zwXoQU9LJii9SXOhB5gANDdQv2YHgqG1Yyk7ZB2ZVbvHydyLa96+6y8HPLkgGRY8uxxupk+ +5dTQA0cZCFOYm9mBZEPVAiBNrC72S4AIjv4+bMwhVAepfC43ZDwoJR+qwPcFo6kjFV7PvrO0pz6K +j4Z8AU/xyeNXrJ5U0VtMUKwAMk7Ly9/ztfb9Wh+f2VOnsoMt3AWbOzKuae1rQqqhrpRgMs6nIn8g +JcrjogpFZfe5x9e75G/2U8nnDzpZ/gWSUJRPSWMwiVpa+16WVc1hogWQ/MCHwQtFWdJ018YLU+ld +FrPJjdfMio3x2pBKW20rbd1bwpdeVFQIU0umCyvmaqoC9tSfP9MKFDao3rjUlJBfiYD7eNRREKtw +/Mb6pX4XvZTllEK0PAxakFjeNG2UrVmBcsF7gVVmW3LSQ2YhPVKCCk284/1Mrl44Win60ECcKsmj +wo7HgWZGDxwJBPkkMg9w/8webrfSmSAlqHR1xQ9sbNJmvZKOEkMZxqkSBL4jNCvGrlKY5osY6HAP +SO1OCc6KyF//oAcxyRShFdPLcZepn3vhS6B2ydBvxwlTOeczpXDAYTHbxneQQlgXCsAuis89vt4R +jHqFzUi7fnCcaeLYwhUYhpSZUYKG2INC6WuP40YtvraplFO3Ug6pFEVxVOyt2OkKENxQtZjfgIzC +UKbg0kAwMAc/93hMFOBsYRc1paGejwPVFtxfZfoaqYx44PGOXiGp+GrySNcy0hVtP+6ej/u2O6NX +h9TBsCnqG/Vt+42TIFVyepDKcmCJyGErXexRHfOcyXBDFORpD0PJAV3qfjv0csa9s+1rpEpojPO1 +9hWDvriEwLZUUmIPLNKOFBI9NIIFkHWtxNIcYGQ5xq2uzrPJM52w7DhOS6NFBBwgjFbAnQSdCFlt +JKDA7IG9vDHWc4eyn8pV+thiYi+dVPgaXYUvcV1r7tD8QI5rm+gpho3a3LKiacksIsez1/bSIbcA +W0qoYdqkgsjTUUbSia6ms9oUJzipfVJAQL9LkvCR7mGJgyVwuXez5ECBQbDwYQ8E6FbkJKhe8r1s +9sSntZXvQW83BS0YFiNh3+7+m4jqKeKW7ylPkALCiNmfXZ+500CZzDv5lobNzBbAc2fHrOCWA6YS +Qp0dF7freu2RxfK1MQN8986Vz8dBoYNIHu1kZvtynxqAEiW4D3pcG84WoVjvd1n+uRfwXgV042Oe +nmmDETv2yIQmgLabSENSUaf3lLFdYXeVPcoDJdEkLnLD7hptTIt6c5j+fJnVV164bCFEUekH5d7s +kZtqkCkJfpYNcJBRqo8TqXCqApnXuTa+niCU+iiXQkwAAl8VtuiRssSH0i75dkCT8XaulsdQXo2t +LwXOG8Oj9kjfpB/FleZBLTmxNpCHgL/0OlPaWIXdmGpUwPigB+m29sD2PDUeEpWrQDZmQqyOW36c +JIgVQz68+r57xImExT/3yBOsDPTic6EK99FxUOAaJK3BH6Z2OW70CMa1zHKcNxdlZfwFjiZfqpuX +zXg4N6gCyuy4Xnv9Yl+Pe6Z+6CzsyiA4f0i3KyY7SPmTgFlOOjDBVTWG2Mos+tqDWgrzLEnH6wbb +PPeCgUacIsiYjx7sg+jUgUDe+SqLxboNIPsioIDL+KFwFjssMOPk+qZQ3BfZrbJJL9XU7JIGcABJ +HvEcplDM5x7Pa3NmSZ974Rao0q662BkfdsPA0nKV0mGJmaKuhhgOOIgM/YFJOlOkJWYGsTNLyuQl +Seaq69+YiigfcitwN0tMrggO0IGklRDMQXJmWNhSNTjmBGGobpsJGaZOuY+asUEkBuGHCkCHukh6 +V4wjz8PTIVsfC2O6DUcEAZfpkEDzt7tIp+4zeaF2bPdjsAqT1G+lzhKfScPMHMkMPpOYbRO9vERg +xmAAvPv850zpr8wwHOwCP+iUZoQA/84W29WUdkjDuzoQinztwZo75q249tS4UuhDpUENY1jxZXla +ZD1XshxiMa3AgMeWcfm80SuybxA2LiMBavjwIBjMVlopVaowcJn50H4U73IDYqQYvhLtqBzULxlu +bUv7EuuBAFaHnP2xedey8dZll/rppPnBvD1PWHSpVHKYdoeMhqdHMprAToKXa2orEEbD4ax5DL1K +ETyfDxTusQviFOhaehtsxXNcwIeFCIwYKET0BS2F4VhTRbU6yvtmusXWXekfJaTQWQ== + + + xArtbO8l4mPrWjlDTacR/ixaLX58qAbMRrOxJsTyrsgh0DtClgJkSP1PnYSmPR4aiT2tY+nV+9q9 +kshAui0vE2cUesBp90JAolC7pmYXfyjasnL54q1jC9Y3sJ8vlaWaLxVRW3kYl6rbMc1Xq4rtrvY2 +SbUKBzRdHK7lLndlxst1sTnXw5LIIYktU+wjKMi72bSUTgAFJHjFG9fMDPlwao9MnJNNrHPAcSp/ +MS9tp64D9kXZupr4XbDk4QzriXCMZKo/MOgpqdJOUfwsG1nU1D7w73CGoUNAChXBlJVXts2U4Ijh +SS4N+b+36mZPWOrBLOMG4RTf5s8Vq6zqUNhAWYYGuRcH9gQtf2HdNY573OGYvY7dmISVGF0rf276 +50DUl+yOPZbilEwQJB5UHOGltt2OaBiHv70nRKARSFHNIIlWzOyi/AOfjjqzrOllHRtzpmQyiMni +RaBVgd5bTyXFZAAVtB5uONVK8tah9ifL495rxTEmiBqqvdZm4iLxQHurKNuwswacZf0dLXswGDF8 +BhjdehSdlPMOLmvCFfwh+taUJTpzxXXoLxmjpp6WFa5ldb6J9ganXLDRnopkWkdFSOIWiUBYXwz4 +QZ6UeRsZfubt+IjbOvMNqCCMFCC+h/Dp8OmNfSF6xsvB5Q4WqL8EEuoeyW1Dp+WmvZdc1yChHmf2 +WqTeMWy3zo3PL5gi9DaazLSSkpP0GIi2oBeqomojldPyTAqRUld41J/RBqCaHZ+Dvtvqp8AaYbdf +8kzUd+nRpe8CagTWiU7euXYP9sEcg1FLQgMwJdnK+VgVS47F+KoOGMg8mpzJIyY5CULOlAa8DPzI +Y8x9R/CrwTWcM5d/5oy6+YwyPWJyoSr4KIELAI0gDUSS/DY3+4PoivGLaj1yc5e+5ckc8ycxtgaZ +yQ6IFHtlQPvuVrB5whwDi5aHcOjRtrr3GZtTkgZk8A1TYx/PVpQz8do4E1mtN/i36t4mBnU48iYo +OnQXI7gsFHzhVsGUvg0d1pUJ1GOnkOBWaQXFpAxWgFIXyxm5XvMkYAKY0SNKEZ6LPBnykHwm1d3q +lX7lnzdSjpQuSDmzM/VAnZblcV3gqaz1I0ROrV8OQUHv7xAJCL3dWjOdpGYdYkiHvcxqs0cU0Qgh +UNTMicJ1HidWjrERhTrT49ZwUgqbeRrvM0Z6uxFWgMINQGIK7XIqjpzHuZiZh0n8wakLpB3Mpkt9 +5aHTgy1K+kZzegyY9hehSxtTy8k45Wm0/G7imgY2RdyohHOSs+n9BWw2j+ve5YjTYsfBBGEoGCOH +gtMGFaVI9wWVNUWxqVSupjtIF6w0swYrWZUVCHTzteRAY5tpTIOTFjHNIR1sgq1spMqA256PwL/h +4krkozbvLDu1RHJmx0aupUZPhBQcB0bmoOA5covxL4Zpd9z3x3Cq3lQ8MXSCBeNFxwKxWvo6/HqH +Bzh7AUFsgD/ZxTnUN7D9IPkG0pG9Are4Em48k4KcH1TfADby9oc2qDGXDPvyJXp/7P7cRIqc6lnf +P5iMjsRRPiDQNJ75q4V5wtzFOhsSDFZPNl4TR1BWgbX1zdCKLjcAK53uDFpOoZUJAxazcWaSAnNN +Mh8UIgjEAOaABewzRdHEa+dWqWW1OKYV9MV88W0HsRLFGnrrVat3aCPEZMlbjOUpRvUDrp/B8dqs +wc6XPGwEP9/US4n/KUpxiv8nC5gN+F8ULcE9zzvam0328hTDMaY00+W5L2TKyPsSGXgUUtkcntAV +5OFjOWZLoqq+UIVUnOsik1vu4UvLaC9mwZnoyR8ZWJ//iGOYHAy4VBQ+uAK3oEB/lfcjd/Lr3Qsl +XTI11Qx00SHcXrgEZC5HvZx4np3JhOMgqmlAnskeUewke5jnLKE2z8KzvHEjda9JypR0eyFhQK/C +4LcHAXZ3x5DCm0rhIwqGCIaXQuW1Y86rsvRIGx0Mo9cjaXRt0MYFBDONELrFG8ourD5sPKjhIy+o +sRF0BDm6SF3hlrIquCtBCxoCoVvcbpbd2ECeYRbQuD81HyKcUWmu57Y+Fri1mKqIIFh1OQ1xWuxk +m7L0sGAyvIsF7pasgIMBryF6Ta+CXqS0wIyDwpUFB0YtevAf9ki7ykM5KHs4wdJDrnTP4szYuOjH +idjh0IlNN72aVWZsMVpe73FLtZeUasdTkIZcdytwlJ49Lt0w0dt6cLygA8G8K/oOXSPfwziQqzl3 +3rpl3tqArWf5Dtn1QgAwtp0Rya/UXJ/no0zDp2xir3fwjeUmW2CF1DaIzCyr3jcMqHmZu6wUHCRK +USaq6gHkCyTBfmtv8FHydCIKPFCVJU+3nb5Ee1hgSDGbOBjp9iKIB8tLfLDBmoDRBJxUZUjPtJVA +2YcKyS2/RV0FnJ1HTSOvrqcMFZyxSCqzofFzYqtW11aox+gHW+ue4J8JqbbFN4vmnZu8ohJAfJN3 +rh4AGRjGhsBFzR1TrBTKrDaUV3k0ZgObbnq7B1FM9Oh9JGavW6qiXmRD8p0fRcDrUuiSxTF7Dd0C +TjR//bkwhQgzj773ojwyohrKErTXdGAlxqABzvPj8IcYocqKWXLnqBhqP0XmIcWAyhsJrH31R98n +5U1x0r7visRq3NUoNysLJQkdTkvW+UfcJy+JoWDJB7UUUw1ns2hgVY3roao2KQ6dJfFJMTVg7/Ko +JsNypBKM1WOqNBBIotLAvk/khwiAGN5ASoogK0plS4Pb+CkvKW1H+hfHlfkSN5wmENRDlFQ/CNpz +hErpjhF6mmBEYtRMR1FASdCPNZ5W5/DJQFZMd9B2HHedEp3TJAWO1MHXV1NBEmi1Xe5hJ9fc2AtY +jZjGOWAYlc1pmM6uLLk6zavrtItg4NsvzWGRo0gZki1nsJDFtjKc0kzUxbMMkdU+ZLxBv8292MZl +IqzirWp77AbwfMeOngz0BkBQ6Rusjai2dXxcud5zYy4ZAiOBeKnOspjxoFMeyRpvYMKIm2vNyGjy +v/V8YDerdMlbJiRWoet0s72RZHNvuSKAMN0AdIREWHzoMUfUpFwOBTHjroUhqM+J8EPcf7vnwbkL +rg2hD5HsVT16G8RWNuRxUrPdBJjSLlDuDNVSy/3xBbc9ZHgXJVW42KHlGLiqY+Ao+aua4kjw2E97 +KNxGerO7xNc0b4keZe34kgeT3yLBqHEJyUm0KI52Sr5umWyKjfip7XM5835+MqL5Y+4B2AIbiMYT +wxNddQBS0oZNcWfxDbDx7ATvkAjVxGQrZ6jtwyOeResXJiTPnixcx3wQgdj2rr5tI/4wwP4RSOYR +CGngVaoeRX0AnnRP7h8NE6wMkpgqdvZ3PUca0Yqnsat5298vwgAXE3V8CDlPNx9QszRNAzFH2tnu +WlRpeizhSTjl6pKY/O+snd2qNDmWnq/A9/Adjn1Q1r8Uh3ZhzMAYG5/Yc1Q03W0Y8Ew34/aA7956 +niXl/mrnrikaqgqK2illRGSEQlpa6/1pXN2RUmGuBCuHtCcQQ3aFkF0bZsqyI0JlPo6GlRDidrTO +56VECYVf90UcxIAhC1cOtYE2fOySsDSkLjeqzFEfaoBrcfVC36j4Hbm9jQTM8nN8DP08sLrMNsWG +q0xKo+XkBnB7RCMpLBrEXLQc6uftAOhtCHEDUyI2vIAQ9TjVUgRHnQ0aIpsVAlQnT3a3FHVgpBL/ +ADcmH02i/BJYWLLlAiiPS2QXFRiEIXRkhKdaxTsi1hDMaqTi2wenBrBkkK2PvidkA/TFQR/pn73n +osKOH6D8OqA1MIQ4c+aLrUaVngQcmxaB8iyCgRuSLj0O0J3FDN0CZC+Y6NDmGFeigoRpF8OFpJ43 +xXqO6GUE4yqFe/KGOWDBvQnEFUR+gYEUa5dMRJIj+56wf5UZ5/DbA8m8dgNISWGqfrCVhAiwvYX3 +vuOrbyz2MWSgERGYULei1kXyaQX+QkpbnWjVVWCsrDtnNmtHwQEYzX6dyZjCo4a+B2uPyRK1H8E0 +QB9Zo11KlcTLcDvaixdOuc+pHL7ykjyQ2Qqx5mhVirs0AmDs+7FnEGRCQhaQCdtlUltPuyJFhEMA +oqYiVq9GftJj6DyH2EGJlaNEgwEi4k7Z/EK+ZlHl+LXZOH3+Med5NPtCIveaYnwjlp1nSKq/VB5X +pIMrSb7IFjwuvOJ3FnAZqvdadohvUhnQ5Xa/sFOCRH+9Hf3KGIBP5YY9wUHlNFUxyYnrysyhysyl +muWmfoYtMVyE67TBwlOZNvd8XzHDAuPs0ECmY4WcpfISYaObfZNNkyIn1MjTEBt/h13wCp5H71Pp +JIQyTBJU8tGcJ1UxDqQaRQXfdOH4yoe87CwIS9xJYKzOJWhCy2ZzHEGmqqVoIy0jtR/eATEDqddL +MpWGs48MdZhlhi8HxUWPUC0i9jSw3HgFvPvsQMi1v5DlTPOOOdKHom/R7d3vXZKt9pjNHCaRQ71w +z9tMgGxrDkGSBLRRgPFJY6Ar/+CqC3nZyDiFIoryEyV+DjepH6tCP2Ob0UTz2Ng6OYtytlk0EOYC +G4FEWBS+Id1BsqLYIDf3Hi4tjTYzukM0xttH6MZmfzesohyFTDc+X8Q3aHLP0J4uN4+GECaIWh6v +Wy0dPxAzw5SuO1mlyOiH93NiC4rTDmDqK0nYIntGFMjLst8sOTVZIQxTvgCaByod6rFTw5LdYApy +KpOSXvcrnWJN0zYXn8YfSO+bWqZUR2oZ1QW+hfCTGXgBFPt+JHQQSJBcPIeNMBYAbpdQlek++NRD +8m037JUABfsQ7qch8gYLuXelS152MjRatNqNSHzaSOaUBtX59gQHgd/zqMZjA6v/wsRKKfG6XtKc +EK80rQyuHLx1iUogYVNVAHrygVo0R3ZRqgvyjghTBdrnqlrOozuoWBc1FdEObAXD+nq/quxTye0R +DVMUCh1uEuj7FYIvXk9uhKJTE0iJxLwYCR0sitIjIkmLmUG0yFweKRFQ0icWpMRHarIf6bGQEAVO +tjd5GATsKVKnFx54xLBPUPX2i2/6tYj8Z5is5puD/Uu+WQKqIeyKG/t7shbaOO+hq43zQV0dtBQ5 +/IC3tOrGhB873PadCSRRcvi2Pz9blwI5PH9wVNjXMC5IzFCcA7panBqzDIikjsyMwxVEEJM4dS0Q +IjA5m1EgPUu6ATfr0X0FaypBtM3NCzqR1fM5BNA+rEiMuPUPfpcYAlxb1t2dstCBytlbIrKG7lgU +dJxUwnLkRILeCDublCCZyiwtiY34CBIkcIAp9emZHcBDVcTF6f5hFmJ+js0niI8jnhvyjRXmB3me +EzsG8uERIRUYyB0Ioo3gFX/ZSw9XetVzmHE6zNvBix+EGKeHoG8SDOv0YB+sA1L7OBGLM680nib0 +WvrNlaGoTpkHA2GRLrRm1fmjQzXYfS7ausVrSI8R18rnrxNRGGL/2anJAebA0Gf3AoHUpZ9GeAqr +pNnBp7Y7VKVy1/G5J50kg455hDTgIJucxhlMI5SXeVK6OaLaAE0HFVhnnedASOG/gA== + + + bmAfH87zbOy6UbV6IyxBKBWDDhcnCcDjObAMe8lDGygPZnsFynngr/d4nBo0l9zDTTQFbRY/AOq9 +pAmWCcNkrHSPaxixGxMmhlmXLdAVO7zNcXlCJosarzW+rTXugE4Y2wIXeEgJ9R7fdON+hV/TBJqv +w6l/QaYwN6Ve4A4xkCqVpBU1OwfZeAdVsllZ7mJQjBMS+EnH1mfCogauD854uaq6kiMOC23vtZCD +4nOxZmmGvyKhuTq9SeFwyzU6lqAdshCkDgPpFa7qe1yUEDGUpZKxF7pWi6AGxzg2tXAvicbEpkJi +LDX2rtjvjAPtBgToln9vDuGqyvxE5I4skeWEL4BaELBYtlYkAlGh4faY5kBdhGTIIzUTp9/6IZQS +ypInCNS6U8Hg51nS+OlxPD1jGt7vJPtDT0AROa8jtk498Vb8eRVnHA7sLI2krPyW+xGkkq370sOP +dSzdH+MSGh8PLaX2cvHSJoGBSUF/T22MJmCPwtmgpq186m0KeGCzCc42H/DVVLmGgl8P4YvcpX/K +yqsuRnulvuloeqkNQOZg+PP1U9FmC8C2xwlNnD0ZNbSBgSxYlsqPhtL0UJqRlFvPpwe5H3q86DX1 +0AZ3L8qMdgKjj/8DiAeHjIVI1nOSwFyKYEtJQdEBtYzjZRy/6CpGCPbmxva9oslLZfbIapNiiMb6 +LoUmKzLKSMT8nMwUEbW8jj2mu9ai7LgO9rdr+gnaFJfQ8J0gc4M2X6GGQuEIFaS9oI9JpYckHEU5 +1MaZ/qQNxSzVUoxy7GPJhSKFWi+jal2CV4ji5Fxv9hAAZZwpOFddIxL5oLWyjjdl1PZb3XRCfNCH +qMGPBA1/MAYl0BdM1eg84u4XmOIVZaggJHSjg86oIQFOmI+QbFfygd9AtQxJT4AQVpOuako5eANM +7pnUc4oXcT+ySYTDiQIV/CDUE9VJy0rgFQgCam7iPXDXnJHxhKV4ma7P4YcSNNV46fT9pDRPJZan +FRBTqLApEr1htLbD1qYM3opVfB+D5JuUxbsw0BhSdfuCZyhp+ST3hmKGWMXSGsUOpurTcU6d1A7n +Lxw/uLCF1El7nSiWDzYB67ohjkOczKFjoSYgPK1yCLMRdi051HQQIlg0Bj/cS7LnU0zhqbwfA8g9 +IKA4F4NMyHeEb2VKrTw7xKJ/zOOwM6CaVCNaLCFxKfiq6AJJggLOawpz4jjTEZEr9XDr9bjiNVD6 +LO4MCjnFYKfrvOBhBlYMqfkeYovDnJECyk3x1zUDU4XL8hyB1MnosBKRlmwlSEEtMQNEHVJmHzVV +pIc4aaIYIFYcmfBH08TUPvSIDHX2bkwrZ7fiZF1w3WQfDp6Q0FjCXQue+wmq+UKBLfpwuBskqcdL +Fg97kbkCJFKu0CBWZ0R35FeUyTtOrdxmitjfLMFe+RSWZN55tKpBkBJwCwbBEkS4fsWvoioCoboi +om/c3YzTBQUjpHwfSRn7dK9lMYdfCJ5nPCxSTmOGZlxR0u1A+3ZDRe+UBmYWG5ycgTXN19ECrly1 +EI1OBNW7U3EjKRAb9bHK6hwdgj7NRqFHh3NBBgL41uY7g5GxbbIBHt0dgaOGJE3SNwkFMKJdRPZC +uwsEMqPbBPN+YdfZ3n2ggXRSd65DCkP4r5qPVDISxQGe7FK/9xt41YATk0ynhgxDnYQAda50MrhV +O0GN5SFixFI3p/IljFlKHsAGVJtkq6MkxpIBkGIJRHrQXQl0BwrfEoKfi2LqgdpMR16GmAjFUWIi +nD+FVZuHTJQsRxzH7RylNSWDccYiVmNv9fTArMhBJIJ/0tUUolwq3nAkAeh7ghVhhxLgQUeJj4Yz +UcMNlew+P2Q0NRSx8w36eqVAMBXwuoqUKar4DC0Ey+nVLFfh5PWEyGboYO3f16JDRe+CDs86d4yq +KrvuCliVHigWT7w10nfYWZUAKzSs8CcFbUUvDQfswcoJMlbeC76PoHNA+xXxwCkywuhkqaKUaigt +swyudCHTKyqKeyKYVOkNzEtAsZ1G0p6dcOV+eiQ0FGHqCpSFTP4MqFUAEA/Qlhpy9Tam0GOelF3U +YFxHmI+cpwXQFrjR/dY055V++G3omnbLrJ8cb15nEqKVmGyfcM4ZRjFYKKF0NkKkHiCO95DCBJBs +EGtsF8jAwZmDbUFAD0O7Adb88QylACfvaBPVMkmQ8gLbXhZEgz4HPielvdnDCt7uYZZRHsA8NFWK +SgMCfPrAxkpD2vH9srytohw1BHKwKdQo3UrhKCaPi32NRPGadQTAuIMsUdL8J8xkIv2w7/BqF9aa +Qr+AF5zdEEjMQHAI1W0+UlfMhBx+C8F8bWLUg1gh1RYvFqrwTIQiagFzLLFlZzCNIxFKXM+WfhyF +A7fovH/raK4aGwTfs4RVmUr46J4GGOCsBpSdUs+vw5scVGL1WKSEEdFeZkI6fcT+DA3qJG32ziP7 +ydVzpnMFatpHD/loSNN/dyYhLaQ9TPXS6+h6krADLC1NjOusWQ6uZVE6EB/1HCkQXbxeInE9LD46 +7iVTpMOQdyKQVC+3vTLoZtMCiTMk8cXbqNMXcn0GnNy4O1tgIMv2gvHCPItzzQ5cnDQl7FCbDyhI +YE1Ab7sL7MfYZyC+fJcDbVIQjpsYfo6gaOLHAm49y8Y4hOaE5T0ZIAo4XQkxTEj9QbGMwZPm0qjS +mHKRqnqQpPZCMrfD1yjRi7FML4QL/u7fBKnDfBdFFfa/Sv8157fQt0OzU0bqCD6+rJZ2dIKD7JHY +rvv+IGrB+7OuKwyIfPfRBAqZgdBAf2HImWJpz0dHFf0nYOEtRT2W/cg15gSPj/nL/kmhZ8pIx1WF +/NEUS1yqBKIc+pu6T4SRujrRManlY9ax/0FFcR4P1uqLXzUeZKUlOpuY1RJOxUZndwGc/TMFEKiR +S4o9lZFF6plAG2UQF+m9hk1mREibihIyF5sd3OEswwEF03n0rGBy4ou7F/a9czxlEBasakxETgj/ +2yS+WDfVvz+bOPkvBV1XiiHloIJzGGFTOjPSAn+h2M0O6ImuAem88gtIBBudAqbXjf0IxMnAUFGJ +d+lbFneyFI5wmalmgOY3IvWrGqPFE2nHgVQ6sdupbrWzYsrXZpNpKZqMwyOzu5vtR/gEeeUfD+DS +tMY+0EDkDSWwIvQBt0hQIw1jJl2Eo0D/SyCU3xLp8u9+0YjxrzzQrzgcxr/Zf7/yGpTdUR6VHFFj +MQMg42u/TqR6A3gv5L3Z6zG7+rmX/A0nsgXn0Q5rBu3DFZLPl/vScqJ8cm55vRZA0KpgdpGX4zVT +xiFDU2y+ZhbNUDK2hoOYELv4IRj5REqVUhQU4kZhYNEYxh40gBDMVEVRL8TzHlaR35jnG8lvvCp3 +novcNbq5zCqkWs10AoUw89caeZKomuc4nFja3YCXmA3PzYG2YzeSweEirzgND0JhE83JHTip+cr8 +zRWWEKNgIjOKv+rZ44k9CxO+Z5lRnmW+VbSC6jo1kyt/D2+3RQJD6J42ywiIebi1wjorZaHT2gUg +/wOZKoYGMEoql/k8nWdZZUWc8/vZVQPax7ypbR5jybrjY3zv/FxJ6mcZStHQgZFhUvnSoH7CF5BG +YlR4C+scDSQhn5OVVuFXSX1O0/R7/piRnjCZ3z+6GP8AfFZ0/QkSK2WB1Ch37wkueW3LmZA9TaIQ +dRtchHKEeuQNdem+XzJFRT6xCqDiKQNTePt8D4V8BBjf2nIsIi1PrS6ohovdIqDl96s0SiwNaJeV +NT6P60o6MlKUMa91v4NsaZlKHrYp6ow0k2umGfonDJHAjRy1K5sQTqLyBacTnAslMhswQ9dPsikw +LayCBgJ1Gvb8YcMLdEYj2RM40siL6by0tz0Nt8pe/HzH3yrld2b5ZnYlxBP3lr55tCuG18iLJTZk +WGM9Vt+FcLQU2RtmFBndwOggrb99nr6zuf/cSEqaBF1DLQvWp6UnBdyuh/Fj5UUzlDVWNBwduCaX +4fVRw92MpNE+PObCAKkaeZy3hp+Nis+NHdwMAxefnQapWkVFqUPkXxgW0+elvpWYn3IYLa2Eb8MC +lV8MLJwKGsUO9m1PZV+qzO1kKvgXv1RldyrkSJDP/mno1l2FRNsApplsAAOENAG1p+eYtxJ23oFZ +wnKRtlGog6fwP2pmnsSgpMADpcA70UBoPnVzu2NyWrFb4B0Zi4S+IBcZXXIHkakgxc5KEJ7SIYS3 +4EcD27wNsW0P+t79zEjabTxmv/t2rBw5OhWOl3xE0iot1i3SG6xb6Yqr08vszaIIFL2wBqcXu1qP +Y8Vx9xCRzMI5FQh8vLW/vgD/q2HHX2nbHCQ7661mDEkeZV2LLAMLsxVOTx1vT6VIx5IPJFgMLT+r +yuHVqWOP0lEtknSEeO65vgsMRTUqKLi30KRMkdcGmWgDMfZuKEj8Isht/MXhLDDuBYIxm5/Qb76H +q6E2uDdt5GofUwbiEUigo4ASVlQB1UIaU824ff+xwrLucH0KKYOjmILks+rc7Qc303A/RJjxc3JT +RT3AHXMelzIWtEdwEMy/lyOPSb4dDCdXgiZHdR5h54oHBB5ROQxJFFYV9r2nGj3se8jtXgyqGwo0 +++A6YnyBQKUN4sf2t7hoFvMAMhwY9G7oMKzQFUoXgjnPJpqyEfql3SpdKOWSoNifpxJHw989oGzN +8wf2pX+Hsp3HwWbPBoZNxOtE0GTf3ICYuZmMqyWo/pcG3I+/4dgWcWsio8E5ixq7wkqWtvMZ3g/V +NiKaUMa0V+ONBGzSnqigaz3ITvMp80AJ6oESINAErEzRUDDnKaToAo5ALbp81OrxRqOXjGfBBisg +CZ0qh9X82k8DLKfdgHFHcePKVov6Szlf1QJ0n2C8CiTHm3oPk708BimOTMeDnSfLDoUXZTBTQAgi +r5SsFitHjVWjXJe9LRQE/9Yjdr3lVDlyEsTxdhggoFJkkTPqwREKcpxCu930SDBcoTHPMEvuUwwe +E/uHrYFbr0SmXvPgC+jak35Tlf94lqary4rfLpnwriZNGCoE752yJlOujryPZ8Le93WmyE0oxdqD +5R/oPlBl4eYQcfFe7jWj5jjAhncPeDXRA1IHCdhVA1doKR7Xg/nyjOkxZZAMJmLM6zD4CXpWDqeB +pKAFUgVubNMxkm5klLppIk1ZoMtkKd8r1Gj77Cwbr9XIJI9Fghx0bVEW3UBzyCeWOp4UTw3Oj2B0 +QquwZfncQxinOZs9Xb58WN569VMBr6DXSpiIKNQiLiGcfC3OY5sp1nzUm+Sl+lzee/z+5GClfKcd +pIQU59txDqxqD02q2F6L5UEb2Cci0VwDviQ9bzCxXSbxWy/gzTpwUmh2CT8JcW4+tRbRSUHXwucm +G0Uox0dhSd2/GrECs86Y90QzJIQg04UBN2wUyVI5/JukRJq333s/Rq72QvzW/YQMSg4CJKloNUKn +CHAfOkXrwiJIHaJXAbjn4Z3uhxQxwP+siHrMiewe0MKix4hxJqZlN5S8yuGc5e4J0g== + + + obpU1xLvOBuMSJei1c4NGaok7P36KU3sO1ePV6iqsQUhweerHjWcZiln9efOB597QUmgvD/wED+3 +vputAxJuESAdocbBLjF8bngmnz+PcXwc13BcKWIIP3/b6EfhpyrigBrF1NzncwO4nUZtYb+QL0Gd +t1669JEBxlEDJg6/20fZA+4DQKx65hE48Xz5k/1q/jyrriu/hhRbOGSoYBocQB92AnAR5VWpZ5Rt +Q+zy83CwKmLaIj+RLb70uz1DEdB5JszdUKTN7IIOlC9kGAG11XAhzoK7niObSIUCh6j0RP6lkON/ +wiPeNReqIWCEHy8YIxKRLEdn6pmmpJnjHiFmcrALUifANdjTC8Tcs04+Je/HWSKF3+3eNT/tQ3TP +5D420uAnBnIGM+AIgbCofUffK3rAAKPHw0KaytFprR1RjTh+VpB0fBSrgTWskDRFppyTr3kgc2ES +nE6avuHQNqNB0e7aB/DDbN5EWbE9s5QXYKip2wwd4RF9mUwSsdMRdbg3nZIiR4qaO3wu9Dl+PST6 +LTcXoO8VAWiQKRnT2FeCuQHkQUASND5cboCc82y4XbgsBMe7lSbF7ZgVt75n+3YY3Ba7Bhopj9ql +6qXB6kRshx6B6IfkcSxd6CUBvx1PZnux2tFLR0T3r9BS9v0XyXWjXs6kQHM56uz0kJcfPBSPMT/M +S+sxPGf1yxEQPlrkskFsXgJ34qJGBYYKq/Qi2TOJM+02tHptRyVgFEkQ4MNC85gkto4XJopA2UVA +QGyNnm/I26yjdgqFXIftEQoS+5Wvl2M4AqACP7WCE0bDJlC1aa/JRbKF1TSyk+e9XcDDCBeaLLAR +KxLQn1RjbQxQZlZk8vyMEXYNVE2TarrlVGqB+/TgIVoIgj4GQce6l8JyZBBuD/WAIJitqIypQzFy +QL9eZ4IARK9yrsdZCylKmIz22As9PZhaY/EixGQ1B7bpbwL5S0NUDgHp3iddzFTndrKme0Hr4m73 +oJUbiOxwLxHOsCjvVzkneZBvPcqNRybgx/tQZsAn7aXJwnG9lwiAxKhppsY9By21vglqVmDD6EES +3v4gPo56SjtcenTS1+sb5JHcr2oA0EEWDC2J91hRD0Cd+XJ05uf17snhzoGTCF7EJCwCEUdiqQQP +wUx3BXlVOKxKK/DDhCaz4o72+txL/Oxk8/pSmZHUbtS0mHpJ/DQFM8HdjtNjnB7P9ey4wh6fG/VK +FnksfC74ZArFIv0ARswiAPE59H0YNP0k4/fL3d27RJng9LgEYMnwXWVr05n2ait6qVHC5Bs+L9N6 +pjrGeahjLPPnc4dGAt+Qol4fs/c+6WjpK3fHw+tHY7pK+jFmUvGDZ6jehBER9cRT9XjrcQfNVFt+ +3775VS/KdILnK7Gf9jFPbL0wZddJHQplWAONZigKDFlCAyC3l+PPAe1ItHxirxD6zVUN0jjOE0Gi +ClV4G8lQI8NA6Q/0UojXHsgeeqDt0pLEGJCJHCqD2SsseGC7q0CQgwK3e7B5jh6i5iueBSE5HoN3 +dO3GPJNz2F5BbkLQyqVOOBBngbXqftgk9wU/E+CHEUQOpwjqHO2SbsEGGArU9d4jTjDDbaOijrNO +UXyu02vE0xWHD56Ack2W20+sUkHa1q969B+OvwY2FfdMb70gi/J0S80mnMDvIKUFRFvFaSxCBWhi +TTKDXP1I48Vzrz7vPTwTwHboYkCp2vjqOJi5a2BEELYCJ+AsDn+gKi/0uYfVO90jcIo9Y/qtF0Et +QxhpmF7DmkoPR8VhWMnLSdpAaiMqZf6jGMMGkM3Ze4/7mhbvDTnv5/niOAiSSHrBpSTHcqCOCRjZ +8mUP9goCIKwbXT7XQebZazirKDeiIwn8YpL1IUCz1ETEPSWrgo5o3nTkqTWw51lyd+894t61gD7g +sTaUkfl8nKvYBb2ttH6iqZYimsoKm0ctfs+N8MBBMSl73VnS7xKLUbbR4zFPqvCw4UMin1BPQ0H/ +AP+sGj3Mu+we+zG2I4XdjxR2+jiuXi271xBupncFyeh9dgqc9BBss3vMdlBWkRvc40W5rBQRN4do +I04UbhoLfME5Twt2B8KzPgispI6WhuKZiG0xKZAJivi4iJvcS1mPN6Fh+6EvCD3K6dHHKwYRNQLS +Au7QWy9ZwRE3cp+GKpeqguwt4Uy9ftWjBbatkya/wc5bJ52huAAzIo0AgCcCRpioT5gQ82nBFAZ6 +cyH/15TfUW1nT8q5vlS3ekzrNGqLglQkiq6lXzUBmNndHm7zwfWBL7AHSw09rrqQrHRm/fKs1wlC +e4NwhXd1PofD21A+OWeK0HT/8hJnMmuLOhOM+3gm5TyTdXqopdpQDbj8zRUb/R1sJ+yhePqNOa+T +edXcM0fkT8ZF9X1EWk0rM+tB23vvcSBKe8wp2P/7s3/6eS+VwnoohSF1VKyZoR6HKM9XIvXoqz9f +S9M7ermPDT2jfjpNa4xN7iCbY4W8EAAgs7Kv0v00AjTSD0mRuKWZJ6WKttg8vLI9hymrs850sseb +8HKWzgrfDYyo2+jnvNXcQBYP4tUnvCZJeLx3+P2tbSnmPoeGz++Hedbl0IHs7rFNNX2EIizhxluP +LxfIt157MVFsHOVphFzK018EMEHee9KWCRA+KrBq9g2UCpoP2W8KZc/fmX62MP3s8qSO0+TEvpHV +CncuRFAKruZSlDC5ILGyACMWyRipS6JQ60kmEhLjmPctUCORepnHXpRJBHQ3+oogkRkYEBrf6AJv +Pf7l5Iicut++rlMT3sxdzQNF/piLEfmTfAKyC0gbVnP4Xsr/2/OL/L98hS1TRFd2KvN04nHTacxz +GNNhmJQ9p8eMHntxOz3m6VFuD+I4eox7pmNhvHt1UzfSEZN0xD1zRFotBU3xeCFChw8+gvSuDMl8 +xA8hYKLHC1ncjsYzFkwAKeSH5SAriNSDKTM0eqw/dImcA+zeNO9IQRo77bAMwo1RATIMF8pNC17R +TkqId0+kDw52hStKAcaz6BuKaC03HU183sPmugtB2vMqWcFymEl4YaR6lUvHEW7ec+EzQ1B+3yCk +uybqAR4Hyzh64CN8jkMea04ZpOb4dXSYP1wIIJ85LyeEW0bI6as8qDIbI+arHmp8DEpwoGQ4rrX3 +HRVc1X3ZXWjaz5fLcQkHq7TD5yr3AaJK0QdiytUGvzqDU1FlkD6H3ZbRWojYrhzf334Sg9nagK+s +ljN71Z0SypBIe8KsPSFeq2AXie+ZB47AX/SANCaBktnphURNIYVsrx2oPiaWg6YTgqpVXjBerYEp +wyCOkBSDOEyqZ/sBosxBoh4hCLidOfzW1QSHIqkuPbQV3FcJmjp3oeZYZfb0ycSFj7Bou8DO5Sj3 +5RGqmzSCEqdBf8HdAE3nm57QYLuIDb0AuAiazpd2aYA1hWQuZ6AOQkRIwjaj1bk8iDJIdmRMZHZD ++9vgCm9mRa8+9vV49cHYwV5TX2iGlv7wzPFdy193l9APg1orhVwIi5RhD7cb1R+Av7FjQ9t6fKnJ +KRUKLpyFSNQG6354E7RwFn4JcdjIhsbiTvZwUwngcjLCHI5tocRxKEWcnzQQmui89/NgBO8dE6++ +bwTvrD4h2s3XGRo9eU+KFFDWcQSxIaDIE73Pb893Sjhv35L6hRmMrCymPUNnfJRGxOQQMSlv8M5Y +xVAfst/PPSqwMjn7eUjqvd9BQUOgseK/63AZAc3g4wnQ8nMPdV6uCPznRjS0xEdCNeJKsDUCwweW +ROoSFjh5xt/XqYAXNx268b7hH515UlPZHiEh9+/rrPp6mlP8uQoxFOJncJkaF3KAdvzwDHAUNZ/0 +3U3xkxCfzukWRfadakOCoTbiT+hO4zZb4hAXx0cbqzAfkafxbyTuKcQSRzwH7GYDCwQNBGXo4qBs +cy/EebHwvux4bF/9tFyda1TuS5pkAKUthWGormvFQpAR3OeGuDefI4m3r+OZo7M7kgyOthQZuT2j +wJl87+HNf53gUyOsSt6zuKwOyBadkypjK1s+YRz7+bq7anY6YiuQFthR420UfkMsB/wGx9x9zwL7 +kiNVjnHA00Mokfy8Qom9XJGQfsA7O4ZoSrQILieb2R6N+qgvsKpgXZ3K80V69XOPhzPPD5yPlpg2 +TsW5ut7eCFuEdh2Rj4CepDFwnhEw571TFlJdg0YWgyB8hXjTmSqR2RbwgWxm9kuIRKiN1n2TZoBu +TVc/NWTIbrUVeGu1L4LzdjboVc6ye+ZA6HIUkGYIpoIRByrQS32NS6tMBcYkYOYl5bbKBxw+zkGa +C4wReNO3BkTCrljB5zZIAOzpZEUYN7OFolh/Vj02tsboE+h3ezXENDkiaZiDsfrxLdKe5IxQXyBT +VvIPIQTx+fMnVrhbO/5Z4xVtrNp6syRDBVsgfkeg2cGjqGbwUG97Nbxeu7Cy3Q+Qt+F+a8/Q6nlQ +dQXNzi5GxmVpSvN6S26wVBDhmH6WfVWPyj1P0S8DBUzRYLnGTY6ieXt5WfN1FFPl+ZQq2I9Klikt +YE7uhKqHM+igQbHaLCZRpB5EmzMinnM4BOQrBQh0MQBNQ4ijavI4QH6Qxvz2+YzfEofqEdTY+AhU +U/pRzQcj9v3YiQ1A7st2V/ncpQY2yXo1xCM88KW8t61QHl/fgrej89wewsxJpFJdKZTw7ahFCgmP +mLKHRSJihhR8kDxz/sZDSdeN/eqSyG/tAOX7E/tL0vJAAdmPrXlCvX7UoIn8gWm2sDgXKPGocoVh +T7Ansf6FPYnxng3zYkD6gbww1HP9+NY8wg5YM/Ml0ImYpn36vB0KUhzsU1sN5UDpZ8Gp2xc4gwiQ +nkPsBFu2L62jFgO3/HtEj4WL3ahYUMsBkKRBd+DEZq121ckAYtow5U4Ot+MA8l/MBhqHnY3oPTzL +BoX8Gej9fbzyzjZlL5cujgl/Kf2DUB5S5lQdR2mDgWdbJX66YnNvn+PD9LKw+NS2Qk+1XjwpMtgU +r9sTWorAek7DyuRdb0P8vgPEg1rKVP3xrXp4Jmwk993A/EsSmrQWuD47HlhDaVZvsKOLxiXMaRHe +2Eja7O/OuR6nHsMMN48DtdjAOoOTF/j03rB/cR13w/apMUOpFTGzToC9t7wA9FAkw7zRWVt84p61 +F5jw9IoUg00HZ2ZPecnMjIgAJCanxmBBlYkGoBT7U01H+nfiv58bWzvqsk8Oj4xy3HnA/mZTTOME +UZ0oqoSS6xU/m0e2ouJfCtkE0DOcNYxOpoLbFG6zbiNCidnNQ5pVJ3rPBEqf1v6q2Loo77icGBpu +ot6kSlGz56pg6/ZVAcnGXuTv/02oX0rdrUgA7i/NIEJQxVWxpIJTYuOTA0sPDe8RBJEQ6s2vhos1 +iDpsJ6uzPr5Fgmr/kicRmz2vvxXzodo05VReucLTyPTPHI5BJDUNXYuYqzAzg3aoqI7OcZ28ROgj +Y46FhIoGD/hR1GQdGJ2wI+r3hMbGHvZDbauwZi97u4MH/P6cPXg4lRq64B2LrMCvYw== + + + X35LpI3swV9kEP6VB0u4M/bvSYH+zx/2/4xvf/Nvv/3P//HLJ8vf/v1//NOf/ve3v/kPf/vffveX +v/zxn//pp7/9Pz/9l9/9wz/99OOf/vz/fvrT//rpP/3hH/7yn//5T//3z3HSr7/x3//45z/+7i9/ +/MNP+xQ/u7jndQW/QnT8r/xXLqBAlKoS6TfWi8TaAXX+odJLnrWQYvZ9ZIcNBFASOB4pZEC/ATBA +7BJRLrAfzCQVr6v5+thvAUDKVIJkxH9Fr5w7okVgFOlQNnr/GJ9VrNPuZ1CIqZ7jugnmGb3YzC5t +uFth3LBrICusyvwTKv44OaGXnMNm1DkQXZt9Pdmd5yOUjcTiMvuYez0v47N+CBhORaMcrhM1mf3G +0tCeaFCylZINqTS/0U66MzaqnEHKdoWuQbF+pIbg/KNnUfRtEFl2QyVf6G54xtGV+6NhHED23k4X +oBSqRJABQiVCAVt2cyCnPotMUFyc5tatQoKtHiefPeSZq8sVDs+I/ezOHdZXnRdm903wpLiCdmQK +kKc7/qiKPB7/Y01FBypRWeaZD5VJQLs8bA3YBLGxEBwEUpOLpPUmO8jhjYPiZHdKmws9TPXu5yak +9+djhkb3PHbYYon3588LkE9lccbBwkTlIU8R3+oHWmKtk9GC2vk+SytxZWc3pp9uD50Cd4z75iHC +RpCVRw4fYFjeSjqW+2dMwzFCz0cozyseBpoWmN4g1de/b2ghJjuE93qMj7Z5DNpZtzT2+0HxDjwr +AHSj19401gB41/t7Q6AVfug6pLx9i1Wshcs2HpL6lusEAVY14F8axKH3+LIDYh9Xjg6lKBA04CD9 +oZTcQz0iXquMlAOS0OAIjkpiEtQ9ygUG/SDxSNqPghOAOwHqkEwMTEToBuYQS2OgB878ky5jhBpQ +RQIbbgZuwF7Hi9cEYuCIpYMmHSc+Pl8R47KtaXcjdtoIK1CL6BQ7qHN3VOCG5j2I/O4XPePqSTSU +pHd/bvAVBneU+ntjElkYZqBLfjIffTEoUgCEsoT/mIiO6uvQgvtbkYkTWKTz+VBthxcW/8S2zowk +iBayKkfZJ1+W53p44QIynFas9GBwAn0iC0LxmPJtubPOc8RgJy61BBZEIAc5wkDDPOWu7zSKQkLw +XiKxNQ+KTKS/TwOV7t1AyCpB5wnDE9Wb+UI+NKvMJu4JYVs5LxCp4RtYNu+naqS5NKONLRzSXfn9 +c44msKV80YhBU5+hsNub61F6rT+HasRnwJxZo/aiGeZpK9YwuAyf17kb7ATfkBkU/Rtm0HLIAGgN +65QxQmLA4YDy7dDKaQhkP3Y0baKlI7KdVDzG7SqSsjMrR78UQWQgAHd2UafDly2Qq1MSIcV2Elj1 +vFzxoroTE4SgZRTolqM788iGpmCiGe4TekXIGo2zG2GKAN7JFLEkf8wnxHZ7O27mzjDccGaYHFAF +qQ7sanNgVMkH0qG0Jzro0d6FnJdzIkhn3ER0XKfwG6DODwVERznAJFCtiOCOg29RKBBwynDWemC2 +ucbgWRWXJhyP6zvK1qKAU4jKCLHYT63WEWiY1AFHLyyagvIQTu7qcwcBLbCvzUqZ181nWgjv0ERY +262H7qmHbLgdmuX3DFaHDgd6d2DbQ2Mi8D4llUD9JwDjRHl1fJwGqAidCkLiwt7k8exoUNd65CCa +sKHSe0D8dA6jA6AV6XMN0tp+y54Vl3ogfjtAPLxmQPZIm3KqFstioPTAYbcwhBrH+dq9xEDWOm7n +v/YS/HhfGXbH+C2NPX4LDHQFq2e8JcjbJjGB+3qqy5tVB7/lcG44ikOIDQ0UGpDL4HDwT2kY7SxN +NJLZ1fuAPFFB2WJdEz4GBjDDUqIBphDy2V0wCPfJb7w8QpiosgK6e/bjVZDQDdZgaU9rGKI2FRyA +opzrxHb31eAyQoFRIaj4DOC68Nkc/HGVr0jJCXiPyQ3fVrlaOxwib6iPKzJHquyZWX4Ud0Mp48AO +weuSCN+fOWeJAiHXoEygJhkTVkXFp/MgotAGIkOFggFZdTCSQ68/RmSBnT7Vhcyvgg6G2VA7wCPi +A6J7WtLtR0H9+zeCg+WkpV+fCWNTQn7szhozUGpluiXauH97aTjAzPn6DFc4kjOC+/L6+HsvoQcX +fj9iRz/9xlRNfyLoqRENyDfV9e9CMJTcbHzWvEmI0UUf1SP5DldqjHxyhUM9Yj8zdTpAZhpG77lj +8WdV5aN/VHx9mfd95VJAPuMqqJ5/ivrD6+8eNG+/cz7D4Fd9f+CU+w3lkkiKTv3oPv52rEGWauv1 +2cNDocidQ7fx/m269pAy7mfSn5CMhMuAKAb476ZMfmrKWfzA/OSLrQDLML3nLaACx9i6t+Qh/YvL +wqGtOw8DyiGCJyJ5qrxx05WK1BaMKfHxXeb5zECCb0gtLA1TO1IYLM8eDnhE6sIjmkk+tb+JbxKw +1FmV9KAsNI5iMfx3YCU7qpsM9Xw9ymlsZK/GnmBhAF7DWBp24EnoxayXbdCftPIaEfjsMKGMsJi9 +wTuNaGM+SqPFa5WlhNIABmU3IE9Pg2AxG+CRH4WbOAoIgqb5zr65jnSFu5iWFgQyXJvIBjI1tpjk +vpxpb/QCE2QwPbZCxhfwxg/Q6oLHRKmjk2XYD3JZTT0mMBl/k4XfCcwR585wrslKROInkcGRuTd5 +YS0zgHP9rrF282JUcdUJLIE5VZ9z2KBvhWGt1tbu82go+YLTaGSeRkmF1Y9tnDBzDlem51mSPVY4 +B3sBDUkOiDA9pvwXqg7j2CV3BUD8sFDVTauhMdb1m0EYBICspkYZkI/cojCbLh8WwEVtUtBBezWO +AkyWyJFV/jNHqMTKnSJNrgkcm8iYVjLRJk1/f3N25HfIwpi/HicnajLPP6FO+Sf1UvTSQHrioPTi +6tO477KNFKXZ2er5ltR0GWYEyQMzI/Vz9IFZI6flsSCWkz6eJZqQaJaQxmAkuhjzyxGWZmgg3cdk +HRq+nxvAhtyt7ec2+ONAuMhKLgzmARXXkHymksyEofIJ0MfJgOvQEdcXPXxvFn5upK/3E3KH8HYc +kEIptEJ1cpu4RhzthDKUJdivAPuDU4p2wpngUjk7AgSPG4owb0BIxEBs/yJ1AcnDU0iaUL5aAF93 +wJWBlA4lQD73iP2R2rDgV3e8oH7qp148pBRPDzHTjuwuxNT3houquYPhZ43SsEHAATPBYBx5WHYV +ZMMABXAL8UghIiSd/2rwMpEaQBmecLc/H41Q8siu7TV2h9VrRT1qfdFAGjrfPeZb44oSu2j7sJRg +mOQwGONwrHzIKey3moXpfn4f/mBX0TlBWx9fWkoRYqVTtTfulIXYOOGxw4TTgf50S5cWxuJwPd5U +GhPT/IhKmg28Lrth789NxYm1yRq1smupgjSw8OwHvk3bnkgp4YSpB40aMizKtGxkQDcuqydWoGjY +w4tvkPzyGy8nLn5SQx+zs0rsqUEIJPuYpS4+17DHMVeN8wFUCV+NHq9Gma/P47HqkAlonTDyo5Hb +jV4ct3v6k3pIR783VCxKzsW9NZ7Ks/vS5PwSqxZWeA0iJxHSeF4N8RMJZHiccIKf8vGtRwsBUNDA +2D23roNvDQNtsnvHPjcizUStPKujRAOOoo9RbWwcpjgkd6X9u8/vyCWqffVlcDStc/2vSLn3T4nx +ynN3258aVeSViDHOs5Ul/G3vPPC1CMYCui5aWc3n1RA/Dxd5GhHrJdd5v6UHkgoXg+pQrLnQjPTL +iuJfuusPMShl6R0JFWv7EXDTMNhO4tJDwh9Ti6zzFxrYTW+twpphKfEK9VDJIterNnxID4V/4G6g +QE0DdTEa3Pr5jTFteARLfOdCmahkQyh54rVD/VtTtgTuj2Ld2tdGhp+4rRVNr4BU3r9jBWr83KoG +F3vcj849hhv0BDmPpExwynxrINn34kp8bmRaPSEIOBLOAxiTbZXRIxcFUh6H13FUn8aLEZnTWYlx +8ibX8wSGh4aOqW3DhGfYMOVZ7On0kYEOR1hNqOcjOEkxH9Eo5yfF1s6joaixGxIifCqsjX7uGD8H +YDSJ3RQbmzgcktY86x62PgX2uyzjxrYBYrkFx28G9eurhhzOd78/QefPGpt+BBFA5L2NJUhoiHK9 +at/a5spf2Q37+K+G1/gYPVDOIANerbrdEaQRA2oIfCJ8ScKEic9CzYEfxP45lvxHabf9qmTstuAR +xL6JeRnxe+blhvPIOpvqTPWLC6AUx456fbfbNmUCJYGUCYK2r2/h8EvIAthUBEcPibC3hp9NsZ8b +IcapScrC2ykct6JHM65VU96HmvYkacgbqtpf736KOknkTiD4DmCGGtSSm9ZMaoCYBgDMgmmOhrQ6 +iX7qWDi/jsDxxPaMVEw30UyqhAKzQv9kji2Dy4y+n5u7xtGAmQf/hbP19zsJeKkSq3sFH8KjDRgf +S95FMcDjl8RHeyTFR0M0oxvVcWYd/27n71MYAyW69tqi/noWTopFuX/PgJfutfxRZRW0jt/xeIPP +RGpjmOtmvGsfu/+spEKJbVacxSj3EYhu1Q3WFd+AdcizGabTHsqA47scyKLIyWemCVCow3kDiM6j +nuFAS20Cv7tpILcPAhJWO4BJ6M77b5E4fIdUN64a4xRh0JDWYBbB0Ec/20G5BxocpWCd/fbSzDXX +46aGAwRetagr75WEeOgJE0CH9P37yQFxMjtxPgMkmvC3mFhY7Rn+aVEyVvhaxMND5oYAv0XuFpVj +pTeXaj4noQD9MiNh2ATMMOY8LvRMvQD2uxw29TiRRwl3vyHI7azHWWCvNU4zqDElSw3PKSHvZeQI +rdBpz3ts5ZpZOdOM0q3Rb6f+ivcg6fkJJIU3sD5hA7l7oKdgD7aB9KC8Gid6LOutkQ7NgF6dNCUU +EJ2kvJwcrhLX7S/H4Zy86YgJGg0B4ECm4MC2RSLv1wxM69CuB25NsHtqVWEFr8JxvAotBJL/VExn +tkdTRtb2AkVrQiu1wwMPEOP6eWKGrJisjmCTYOn0qh5G/2Z6uLnfPRKoX9nB2dxO064HZkliP4ub +gOLyXAoFDOQkrvWvvaouYnsqOESgGDLYBFM2ED7FfM3La9Y28IBeJNtL9staCskhyik4ROPjYbs0 +kys1dipB232oNaQA/O93jiugFFE/GhLAgcrdHuXKvN5GTLKfYw/yJGBLMIqLfIWw+qQUSdVAuuWq +rwYvijrtnrKBQ1Qmjde3qkh7WOHLve5F7b81ALsu2tS0LM47VpDPvUDry6EqoKqrAlJgyfnV6i1O +iKO8AyBlmaj3nop8/HuPeFwsSbxO5MzL+OI4PnZenTQEuZFLDzsoNvkUIN56SJ+oxwrqyDt80SuH +AcD0fvawW0pOLsn9JEGxTPYRmap9czHtjUkHMTqKne2Wq4oGDUkvpirMH9a2yqdjsiTTI8peSJDk +mLwsqSJhU2DFUSLn4aMBNs6ZSpj7WCh9ncllcIDMQRWK64FgRsm+UbQQOkKiD+zPGQ== + + + ehQkVIDMx8CELTodhiZFFEmX6HbFi++J3HmDSyHjB/vSjUwhx89TY82tpnf3nFgcpCY2p3FHeTXE +E/i0tL++hRGX0Pqi1Bfn8QG8NcSTbefJvt7Iz72Ir6GKTe6PToVc1ozLeg4xTkETE8cSKxHn446N +8ID53OH3p2RrxhCPFufot8NQ2mMlpLSnIiF4e+kOVX53uGSQ89sbioHm9vf2CJTaojKIANESJAgc +z0re7BbqFMAhsdT72+ehX1OPfs3ZYL11Qsa2n1pfiaIikYp1yueYPxqE7tVn6lJDzEKemTjhWhVD +8XUw78hKsmA9tHEQ+cqlZcXhWRn2x655PaAqHKcfP0cyxtpBdrPp/Wi7IDaVPs4Uax75SsAG4C6n +ShcU5Y5zJDgLegjIkJcAxAfc7GjHkZI3JCWF8O1xdKTJU53xTvxBSLrvlFUukNSgTNkA9JPuN1M2 +RlgXEjCH/01BPqt90WOw4xCHUvJ1cnzvNY+7MoqO2pPAH6iWEvF8iTSIYhNkIISEZLVm3ht+f0Kf +MnUnRqH0ee+1dy4x54BzVdGBSGXv+z4a0sU/vT5SZqIcmYml/+GOm4qF9gO2od7RHfc7GmLcz0f4 +6ecerxmhASuHSNe/OAyktBV5Vw2rO+Ys7SwCIvrRWF7n/rW4f9f8h05tdjtVgnl6hfvtnsVyDtCt +lfbdI7xRsePCZAtVnBjFObLoHCMxaWN5Rolm90j13m7XpLFiTWKszx6KenvkznkueLBTnBmpoBKJ +owRCqCOtEVac4YQFEjEyS3uOyB7iKhFzQ+JEqB3y9GcN0zFYzhTIYfNmkJqD4vsIdJL+r32Ca3u+ +6nF0jbR+yHfy/9xLORxijFJz0cHyiczBhFC2rjTTOtJMgmfGM9fb5w4plDbyfGtDJYElG1wUQnek +zs28QwgQNgeU4mzmkF8WsdiP+88IBwn2IQHxwbVICjc6L11wZUFwGHDJPNbemkfz7NFWwjtgZIEy +FlBTiZi/Y9PJG8q+AUD+Gu29wf1ViiryW6PuNAI1WghWgfeAafHR8BwE0A6A2pm+X43g+ZR+3Lsy +Zd7BHhy8JPcEki9IeBKDiqR0ynCn8I03YQ785PFGTiQONXHX5bNfbUsc97I/0Z2kcEXRrkDzT5aN +Rh8Kd1G8aco61HAetyG7IRQx93RLWVzWfA0IqWI+uwGnjwtmeAKiBNrOn4hqoYiEkY9qryqOe9Hs +TIYfDVVP9wNvOJ8l6W5Cc0JTE2lkNDWRkEU/9YuP3eWSWwU6+blxambt2bAmxiWrst2e+WxLP1tO +O6xylM3fGv8uTrXX6Zg4QXBTXoDCrgNBLBuUR1X0QSGkfteAIxXzhryP/MoD2LhqSAKIHuzWf8S2 +vUmf6CyL3jd72zz71+IoLLWA5oj/u27yb8dpK6q15I2TaT3yBrDIG+4r44sen1eRSH197oUagZKK +vNIrApZmXFKPXoo+GrxHe0tZRrxxEZZGZjR01Y5wrEDZGmuLju9KOFfez/0sw6IcjlI1NgiUF+na +GUg5NJwQwOmxs9EmDzJG76/an6EM6w9gDCQSVLxgLlDLZFKg1nm9ogAtX3avdaw9SbD2358iy/4t +6PUgb3PsK3WYxwyD2XvBS9lf61BsDggi8I37aFjQJ4PGhm8LOl9vHSKvmmKbvOeZbC3181H0mOJJ +JCMGY8vwMSodObD3HtQw+7iqOp8aZ9C4FZQiVGOTiZ87YhTo2hXU/0n2t5KRN+qHpv/jgSVAKlHk +kvxQOwZVKEM29pg76qtYecFZ4y36RSDDRTpIKHmnVWRoDt/zGXJIODIsiRm6krN6daIelg+Us53q +7YCjQ914XH37ByfMFnnVKlIcRYYayrXkf9Dw8v7D5RL5sW+v8OmRwnlObc8X6K+eyiaKSCFXfbRt +9xCysgBhmQlgz1FuEbSLDbm8EqNcMgSrYTpZDlxviiIh6E6+in1mG3avEpDiGfPRAG4Xevf7dVDv +ngyjWyES51qdGt/gLD3tMdyEuVlCqkeL0I/z1Cd08/e4D1GTFKBlskhxvRZIYD+uFsM5s75RVmM/ +F7TI+B1iO/feoB0QMK9uUfSG4Y286p47DF7wU4y63Z7X2lEb7lXF7kjlE3Oy5WC3AlwjlqfqRA42 +Ol58fDhQDOg72h1PrAVBxBIrEcL/+0VFaH9fWYpdG4scBe1F7rkkZGgVyguzd2Ny+OSIYIHW9i1I +lHYXhJ/98NX2YmfxjWJVgEWgjI7Q9GUPs8eAZCCxKVFi41E8cev2j4hS7ku0NktMYEqgnNHtRWLY +rxMQtajB20DenYZpoRHRuRINj2OLEuAt8EluRwWu741gi7OHrjd57RnHMV2BM6NuvPaYapIxaeQZ +wApqSquE2wLa2p7nSo+LNsIGTMG1E0BrLLMfcYM0G6S5aeUyrTOxN/E2HG+/jU3NWXEkgd7PcHxv +FS9BgbAg1BT1Iyy2woW1CBq8AD8ALKFgwJZv312q6aFeTFld/E8K0l+tdyoupwhY2T2cCRxtU0QZ +G1qaiFyBOmlVhIa4DMqxRbwpJMOKMExIo6lwjDTa5Qcjqiz4dK+uMvP4eYWpHPHWueIB4FFINV0b +xg5hB7Qt9Sx/MwUGljfsmualODaWOBu1Ysd0N6qXLdAhyoHzDtODjA09es32yGRnmsSNcwI15siK +v2qJqv3z3PF/HPaSgMQOTT1repTHHtU6Pd7gSA72HbaseXowCJqyK3G1Wj+jZTPucpjJ+zvC2FtN +70TM4HvFWlQp84gsRJOmyr06tt5gnmF/8pANAZCoNie/jmQfatPP62m3oCxoEymgYN9DBmelrsNT +gi/B67cXelVMOohh5RRBN4KYSxoShYUHOgCUWl/INTjFrFikmqeDu0U+WsgzSK7q8/JMrKpxj1Az +5B41V2NQjS0AatP6NG6EtzheIo3XTu6CHy4NOVAanpDtAKV2BfQo6AIGSykQllBpx6HCarTcdP09 +ObCHGihF7OcIhPDWqv64f03I4AGrIGOhKMSyIF1Lsu4NazGKhQ+FAFJxmJuWUwVX2XzvnkYO9xJ9 +gfftU1fEHtVfts7dBSnK3R0tDhC/c4/yenMMWKAQaYCJi3edi8HgEJHQOIz1YzxSRhTpTeli5SWf +kA7KBQNAb3EEKz+Iq7SbYdCCZ4hj8EVpBOTsIPD3QZllr4WY6PnBMXahZB4nkEjRUVrSKyppBsf7 +v5/gRcWxE6m4tKSgw6GsAuWcXFxofwK7LdKcCIiCXoHDPBY3IREMNOsxoYC6LfFPaqeUHxFOOO5E +4gO69wl9XCANjkrkI1Q93j3go3771SjshnW/hcHoofCIdsJLALQT4lU19Ln/8Sz6WFHx8hbgeu57 +R8zL4JEJmsizA6vmJ5Z00aEzLHnCC+ZAEmZgjkhVkc6kDZwZDU8SBcrQLzZkATAzmBXA4MiI6lZ6 +338aVzDllVi18xBBPnydKJo3kJ9kPx8bGEjxZV2LNIssins8gddkyCxK+Rq87w/IF8xSD89IjtCo +pLGg2I9TAibIsqgJRxOenY++njBV5gk+U+HP2wxMUlCe9puAhtYLZx2xXArmEcgHip809kPOU5pn +N4yShW7XGEjMJWiSEoCI2n6BciXtzWp4t5dQAdq6xttgSEr99PE0SF7H0ahVERCu0A25ayz7v954 +ttjmZJ/VULUfA3KiNtIfFGv0vBkR1345wH78DccyaIOnxl7z2VtStZnIaPxjNI5pKkA7VxsXLCn5 +SSrPt7BQMKg2o9LUn6BGVz0UOYt1GQyR0ciSikjGY581/ZbkZKRmWFInXmld+ASSBjZobIC3zry5 +mHKgAEVoivto1LyBIOzFMCrIlCsWOiPpKGxqxACD53CxRAem4GkFb3gHF4jNTXbZMxZxkB1I+9WI +n1LET1HV8JfhGEcdkEbSP2SUkUF0ljNcbMf8i2mZd88Zzs/148AqMI0XoyajnExjRQWMlx5sDlDe +1Y+6bQ51W8AEAxNwSHKCIDQQW+Oo/WNfhLIhU7x3qSO3AsmGPCf5NnAnWN2gSEtuyx9sdFFDBXSv +bevm459y8lnY2pO6xCCiBpAmEn5wJ2eYGmPth1wVkji7YZ4brE70qXKkEXsjDpUhl5IGDOcTC/um +kCO7voMb5MizTk1dSiQDzDxVA7e3A9c0WzifFMQOMEC/eiTkztU02BH0YJU101/N+e4xRfWZEJ/5 +DnSoKsLzKFog1ltbQD0QWQUysZ9+7FO0q9hvaH8tkxRKwW9N3ERdJp89ZbLWNcqvoV9mzmyiVdhP +D5SoOtYkPfBKjVG2p+9avRbGqT0W1kIfJRzchSnhFJ8K0Av1k8GQLI9jyXkqFDXPjo27R3QgfCMF +LgBdG+dxtm7J6Xq/RHdiRW5OsEg72u3ysYrHYXzTTvqJ9nZ+0YHHCz7m/Kp380vhrJEoy5emgkVo +ZVONagLrPa/sdEef4VUqriigc9aUjFhWNXVtWcULy+T1ul9VMr43NH9uFYkMQbKMOMwjoxBPhLZn +5JZMkRXy0p3KfhY6sqcXIR/MLjCgHU6RmmzfHVYSAIl39WYRiC4xaGVeTpw7NE5JIXwukqirexj1 +AUwQwjitAiyIl2wEFSqsxqTBJ4xtgICAUwre71DGcUatApov4xAZjANjYyOk7kG/pOH9lqPAWA+R +vNdTrcEAe5/6GSdF3I+5o1ug9ULFLfePYPxIDGDzJCo2f/C1g8w/CbQFmDTF9YECIAIlmKCsC2XD +ZNTbu98kPQBE+Tyxr6AeP4tPbL/KRTpYt0Sc4bIxXnHtvLOSJa8nxECCg82D9W8zNvL+d/QgWVu2 +ZXlVBYKwHaqzJTgZRe4rf6+qEl9VURMPlyM5onL8VKsy4qJ1sHhceEHkBjF1uI2DMHSdCnSg+75c +b3/LAJU6HBz7crKgrOXw6hBLrUdmC6ovsG2yeEPaXTsczJdmJ5+1rFG2WXhYj7qct2ACIeVGfbm1 +D90nXCjMs7bXca3WcQwktCjSMWuHt92xnka5YP8/iUjYT9CQyPDWRyQkWwYU9rSvOBlaqPtT7eA4 +NaGZJotDp2te0qF/8t6Pnd0F1O+izFjjQvaf+414/JuUFX+TPW8lpMPOV+ZciqI0khLD0q8CXuJa +FfYaIV12668DNhQO8zNCT/w7kxKuoX8F7DfpTfvDC03OkiEchtouCZP9ygTTAbMsfHjwWUQtT0js +Eyn9vVNvKk8jttk+EO4Arg7ncW/fp5lyVXVBLyzZfXulR895lMN4ML2mMCew4+Cw5huilxIZFNWA +R0hPlsAfBH+R2KsEsaUYkGETisD4szecWTKt/sYXztW7qBBA+0V9FhLy4ih5i5GIosRcszhFchzU +qbA5vKxqCmcUSBAWh4bL/EuCl2JjbEmWMsP1g0Qw3LZUg0Eev4LGlCRIHSzrwQ1LOWatZ3wI8MAp +XtkKBDkxJOYty++fRQKIaRqn18u4pPTCTCRvfu8nFoJxSR9yQOQWq8mxI/7xnH0GEA== + + + WTbL9zPWJmIseUdILGtW4r4pX3MFHU4IMGu8zX5nSWRqKB6vFKNOsdEDfMRcgdoDzG9m7qXLl4OY +b5SgKROA3XG5DkeXXwjZihuB6BL3f8RZB5BPgMBXU3oCYSuCg33hIWZjHxQmcSEpu+PE/Zq0/FFU +5agUeuDb4g6LWAN17SdQ5MBHoW2/5JdJ4uHHpWsaUUs62hUos5egwUo9FR/HKKWy14IE/kF/Ai6+ +BL3hyLsvPen4mw74HZdVpE4XerB7YC0m8yWnr120J8qDPFFy+ORmMTp9iqMlsfNuT4gKEW4eyk67 +tOt+vOTBAu/xqgolQppecpf63I97Dp8BixUAAO2XBGqWHi1prCtPJfFZPN/5TlrBbHYwUjFDDNTz +FeeFdb5yt/ethGgQ915JbdhN2FmboZcyy64Ib6jxXFtuJkfZWKLDpU83Z/qj9MzM5GqR7q/RIoAZ +v0Fqj2mbwgQrCvrrrEp1H4up/9Z/+Ux+00Lwy5WrAEzAdk7V1hW7IP5+aYjreORHUm7Rn2jKe8qi +9e/yTZHEqyO1UBm1TljBvlcTJ006xQiJIkzGmbZksEVOJFAg7C+1lEbT1x8cCNslfQhJk3o92DK/ +azHkFRaGIw5WmjWKFwkjLQZYl+UbfAEFq6awC0W2W6zxVKlImLjelBZA+7MV2YfRpCcM83IJw7yA +KwTygOx9NZpiLy6R1hFOBBthFiKrR75GYHO8SyAwWoDWZ+QHAkZvmDnExSbXiBRY5UHpYz/YJ4Wy +rAsLIMwkmrplMSHsIpKQtGkeEOxVy2KmyHh7vv00WCd3D+GMJVJV7BzyAYpaxQONvm4oPI5eVz7S +SdjEmRlN6dBFGrgRafEQt8Hc7Dh+HE5JCXTkvgJz0CLowQiDLQzsLCcgrMEWOgVQMiSSKo7cEZjG +T93b1+coiQVWp+ypbh3+zJe9dMgqsW3JV4dmhto/nwtDvIym/c2ljp099KtFIql9HJ9kwu41Djxi +6eBR9rb3Ocd/hHyAepzRA+UeeugWRFAceDzgWCH2gg4BPQRN3BMN2AF7oEZmB+zG8jjk47skHoOK +HaI0FYvaCoPvQZrFQF8DUX4SfiZxDCtXO9bYW9pxzsS6jSfKg37vcaIGs82km9S4Eu0k0rkFAvc6 +0z8tMS3KDBmipWuYjetun4+7/Sl+2ot1iF6rh6FpYOKG3CaPUwPzXPeJroFpsWEPYyKlPWWMci1P +X8eVaz7MWWlZkPU8tVoP4LSFy+kKJjPck4jlLNGARJXJN49fDhW2OwEQCmKb8qBvPdh2iKQi24PX +qkSUdBLnewoQM/MZjESoqRekhEpRcJ9E2HwQTPOAZwb7vxYabs9B7MYU0M9Y7RFOaf3L/mL/Pl4/ +9535whhih9tUtlItg41EmFSiIBHSRKKT90XnJmAXO4Kq74yWX2aKstUIhJZCfCecWBfuK+tkoNFh +SGJ8m/JFPBBqFjic5tq/wkOwtQU8vNdI+QWLXSx15IaPQuz2Ho2JH6/v1E/yEYs6MYoIaWXucBN4 +InkRmArUqdJBSDsNp/1oZRmnU8vBnkNWzDr6l+T3TwGOXpG5bgQ2cSattEmAOPEDjBRy0Kr7Pnv4 +sVL1CMKOOD/3Rdz0etG8SXdQONoHRDwXBBKMCRBI3OnIg8uFJiwfTrwiHiYqAcLVV7CJO9SdGiBa +rpepfr7yW+jgSLikuuSPVbea5YqyR/Y4oTIAISU6RGoZBwfx70v9JRu68koBoLjHJ1S1EQwowrpa +VDJyoipAbjtWIuvhU0h4dIB5zNCqcYR6X2iRjBhK7/m9uonDWzabpYEODb6sEDHxzkRCGmZLvX6S +4OgB0B5rqjv/GP+Ai9wB7yKLiJ4vUi+odJq3Ad6CiAQwna5TUokSNYUlZSaAjMcMZW7NS0uUGQce +5leHUjSA8H6kBHIwLiMTAlgpzmSpG8bxkL1GcGPEjKlGE03DXEoilEI7EQFIz1Pn64FTQVCIAPiZ +h1yKKympwoHO8eFt4tlu0mwda2KsmDFB7oqEphE1SJPRl0xGpJvE6e4I5CDhfR/BMl7TeUvx+mmO +4GSZnp6odM9YYy26DgBJ4TQ2I7HTc7olIqyncjgal2A/rfBTomCmnly9uC7dv05OSvOKvNflFPir +CScRMjJqSVBYXqsD1kWCvjCIZDqNWiAEjjDbjh7NBoHMk4LC/IXjBi1Km9/2OkGsI3smZsWXPzMO +fyYHE7iT2sVlMM3DsIkQawXtDm14oBHgPU3AJ9E4xWPcXEoON51savyCw6FeEKqVeazLJOliKOYE +jhZkM2fP5i3WkrgWZoTu3cahiLvdZrqMtKO/MzqEzJOO4G/SEWEiq9YA90W3dWJ6jgIvy7BWeVuG +DxIzZocp+rhwIJt7uT5PACQZmc1gN0fKWMouKwoRh9SpR046wXSL+ZENs4kbFPnDwqZ96DnIZ99X +MsiQu3GUqEfKAqQ6RZ/2TfJFi+LYCaMfJJtWY+zXV3jUkTYawKmm9Nyo1l6ppj0TaH7GFt5wKVyv +2PJ/kM5ZjJeJnxo1WBwiRd6H9BRiOFOfvJQs3uKF9DAWqZPc5Y9eVLjp5WyXRjyYiZL7jJJM6ZTP +gAuM6OE4nLqxZ3tUFzbgqz3OFJjTqhrnPVHgAbWpiuqBYfTuVNjUBRb3kcOxVGCkR7DoDj+IHl5s +X1P4EamCJyoQEuTiTCSckHVVYaciCn3I/WrGUDsLOPreV4XgiUZD4AJYPXYct8727aMwDxKJVXFo +06PmmvpZawK8G9BDZd0DHQEZFri9ithzD8oi+gTT2PkcV4cW8D17iq5nmZzoU86MYCDuqNQWUe5q +yhRIo9ZNOtdYCZvcjxFoYwBg+MBc5zXQcRU5sRZM/UhbmvKH4zbFuz28bihrlB6HcSdH3l/1f5A+ +6ArgtxYRQQvaClH889J/BWIs9GcP+Cd2oIJdKMkd6IJARLDDxY3oIjPL78B1/mnDWmLQ7rqVR5JP +d1sOJ4kHAPvBDW4lz8Thl+It6lgZCFsnnHEcKNN+b5071tzwCg6MHlq41R20pO+AawoqgXHpcaZC +BYSaZKoHlsYKCuRKEZ2EX/bjcXoReocIU/EY7XRILDKshit9eKMKO2js6LK65RCHQ4uF6QQgJrHU +0yMXoZxFV+klrDGeGbCHiCwPyK3jTnOMqJa/jgz5CA/XkDViSbSu0gLDhRShU8ySzaHyxQya9icd +89eZxEtQtZJkWBhkav4OcuF6/Br84QjLZEDQkcqttreotj+xQu2lmsp/hTZ5YGTrIAOxID3id12G +S5vqbRezC0uZHHCK9tghD0vqNKMm4pb5CD1TRHYkKy1ebeiQ6QOwVqC6sTcRDqBGD/wAdqQp1L3c +YwGr7Om4ecsarFmlX9CPLaTJI/ew15d1Of9ojIgwQw8mh+5t1IGFzTWfqQtnYzquIYSrMDmG0W2F ++k28WTvcMDkAPMg68BL6cV705+ir7QUF0UuhWlausRicIvlCsG6Aszls1jCDUPIWbTgx2qQQXXT3 +gEmH6h76dCXiQMXnM3Zq06+7SSPFsFpoFcf8geLKOUGceM/j6p7QQ+4HZsPfncB6+O7Vx1E0TkcV +jYR6g3xX43PtgobdowOZ4iYCNy5RNzR9Eq7uDtmnLIhrx88zhI7xcKfGCsnrwLwQ2mHV6oHPt7AP +/6yOeC8BASiFZBGTO3inDeYSKuU7vKp1xe1dakRC3l4HNww2CYel4i+JgjXYSveEe4FiufLaNEne +ofS8SrPFFBziPELHIhaqKJcP/HsFi0JxYgxTKOh65IIJ8Ke5tO3wUYNLekifH/K1noNRn3oU0MZk +Rhu6yH/3bwI/rVwbHgmq4KlUyAYZRQH1i+rRDlKzvsdxYHUKKW9HfTGg1ruz1wkyhR+w15mrqg5Q +1o12Q9R+RhRd9ZEHkApmvtUIACpUAcUJGMHQspkyZng6W4LDTcUS9fywSAJBW1Dzb6CV8YppISLn +C5IIXwb7asl4sUsEO6TaGRnQ8K7MZ309ztApnKH3azePF5ZgDbeUDQVnhcSmM9XssU9i3weY6Gck +8lkiFAcvRVF9KGxnZkz48P7VpuEhWCmIgZLjDjvQfJ1XOoWKIz9kVJ0rgqOYgmM1zShpAlKjHDcO +e4kqAHj0UVU7ISseuD6yewojFzOGlFQN1dSDZQNUYaAUygvrlYloKZQ7R0Nrhk2eTjeA1UO/A22l +fUmW5F3JBmY5aAcfyYGlnMv6lk+5ZtYovuUVpUVSEI9FDeUqfwx8FrcVzXm9+Si9AHJuUXf4XHz/ +LQv7/+4XHW7+ygP9inVM/Jv99ysTFwHWaPACsK7G4SWYFGFAdVhPAKx5W3evZWL1cy8R1CIpE2W8 +k9CfAVeLBXE3jEgwRJxP4u0SkNUdTpJR8oxgerpfWwhrEKVUA2aeqnUmCTEm6si6F+u09bUVxoBp +Kby11+QmmlH7XhuapXHhNUOLmaDXhBjjgKnQlXu6JS5PZQyO+O4QPPCY96R6ahpw7DUytKfWzHG4 +Edso5Nn9/Ln50BU64oeeEPpgyPQvdm6aGbPGi6Xb8cyOgqwB634b026JnQrwTI49o7TIhFpjQd9b +BwqqRz4YfpxcSlyDoRn2Hq5fHq2IWgbPj96zlUrFouEuOC7aXp3whGCvzRNhPuwx4ZIHQaTwZ3Nl +BJxA6fDsS9aGZSFIasmYDKlsqKwnDbI4IcYhMdPQoTtgEhulAqKgWzxaXBsNFSoMdLqiTqLixJwm +pmqMsPz8vrcF625qP61AJJgULH3n4RU6I+JTwH0UioChGAQ3aq2nwaOoJo5ZDbHJ+Ggs5qkg7IBB +jPsYushvDXBCrt/JW2OO1aDAa8b7vTKAKvVISj9FyTaWsh1vwUo4n8elUQPe0TphrgXf+50cLFOs +SeAgIDxMtoEv7GHBF8LxgGL2leWlDULfbiM9rQAwBTIbCC5p4LXDIYBSPw1G6rthv3Oqm78wPjSa +R9mNT4lTqZVVIO2SvMC11dIyNF9inFbMhXGUK59UdEgcAUQC7V5P2sbApytADmTo/fP0YRX61liP +X3ARC5VZH8IKjkeLWEF1HavRcHWZQfA+r48KUFmcSWtWFpkqeCNz89bws6f/ubEDjCFEBdNO3Wmv +xyhSjqLoVNFVYd/0Gog5LWUPiJyRZPReB4rNgqDi7QfLAxNk/6YC4gnZON7+f/FbIxhUsFHB2QCH +J41rA2b08HlJFQ5RKX6uF2CFK9UjdXUHoKq32YM5a4Hvn+cS9jzul1YJ03DhLzQQtPB3XdfrCL5a +0Q5qJZX9hYUxhODPEsVZu2W+D2e+o39EmbrN/GqIPfMhzDQdVL/7Vkpn146yJcX2fHJzlJiXTKD9 +Q5/QytKjivUqXbQzvbo0G1RWYj3UEnaClKQaB/iQIuNeMUukFwqoiuGKOS616V9def/VeOOvNMI7 +TJf8nGThniLY0oNmBQzhIk+ehjIeOzPIV7yDy9pRvcVkhG+6MVQu4apjfm5aTtMq4g== + + + I6TTcgdwZaopeH8BHrMBpxa+1bwTB9XG4dRDg/ORPJzKl/dwUZrHV40k7RMpgnwEoFm4ZSwcmwEx +AqEU1IrZCoxYL1dYSGi2Pr6HpTGfu2dgB/qk7EdFVV/BWbVBZYRRCd/TulZiUpw/7AxM60XyeQru +UVA6HVlMxAApV2iUVY59uMDiCvBXL1nlFS+K0M3AbpTq3U0MR27JSZ5vcdk60KbQ4AEEinhGumJQ +CIEVzbCpaKkchjg1CpdXb6yFZhmesTa8tGfS0fmfaB0xULJO4AwF9wqsf3DOWagCvv0LI+vH33IQ +g4fsEs/3pqWGVpBiIdZ/8hnHhcmKzAqw3sPubrx6HencJ0rlegURBYYR6gFKixMwgwQSSCVBaMZR +tg+sASXn8lGUh1ZLr6wjIUiCFXiDLm9bY2Y2Q8BtjtJSkE3N14eontHlAM2fzjGSuvORsL41F9Ea +JIPWkQkjqaGfz9miV/jOA3YoadFx8sdkjhAwAQ4Q+HeEmQl6P/eI8LSfgga0d2sgn3rJeJaRtpY4 +WPUBRvD6H8A3JD4OsywPtd2eY8Mb7vAfYtDyv+jVDkdTQ2noleDa6eFL2q4YH9wUst27RwNCSo+g +ma49MmswMFWpgcj5vHJF/eQaSIORlZLuKW2SmTd4pxEG75VEQQCOAxaUxRQFQXv0pQlrMzPO1XJX +oHLOl7r+ikkC2NMUB3D4skQ1Er7ZnkoPJ19umV6wzA7J4HKY9VGzXpaDNnUrBAj3dZXRP9YfCmes +P036ERt+QBVEAGLgkZM7WbtVSd2kve+WgnoaxBu6Td8TzRWlfzX2U8/e0z1obMXSRRmg+TpUW7HQ +jsuVmpDPuJna/WaaP/3U4/cnfyqZEs1yFR8/95KVmMLC1qDHvwMzJEFnIHp32e63EQ8B7bCoDFul +OKlrjJRVwgBMFOwMtLSyAYD6b8Cr+flUml3nmUfGvCdIIbGxh2NWUA+k5ZBRkY9PRbo59vCltmJN +xQxpGzyk0sFn7BMtVTS7TPeijsdK43UihOjoNQTIkYvo0QvOpccRiYGjs9xfeoxjMswutOFEMS7Z +BI3mfYL0chduZ9wtmPphj5apt1A8B0JHBjzKCCDlqS1xy1X527e8jeerHjXM3ig99ee+1597Afhm +z8B9mufew6DinlUpbRRERxREn6vorxZpz2b53zrEVHUsZ5DoFqj0dhjKm27rOxv+YV1BPaC3BsBv +jXoAcJ2riPTWS5cicrR5/w5xYSO0bkkDzOPEKTwHh0pLEcqTWUQ5vKl+FTHQr7yCRcpXdIE4zcI7 +MbOPH+23EfXSzPxDzRW5yLcBQi7wJB1qICPa5fHsuYf745nYTMywaAsRMGSvbp5clETG6i8UykLX +i/ICsYyZPBAbOw4WogkhiXUVQhKJwx8vkMK8oGn+8IbjAamwhRmcuT6RH6QqXLuACwChBLV3StfP +c1QfTY7DVeo6wFH7PEtijxQ9cDQyIB4XVATHDffefnATWLjkAKqp1EePR7W3Hkp9A2twpjFOlJWo +Gx9laMAKlAwAKyBCYC+Mz4aqFwfOQFJksHrUIFdFsh3JwR7CmiHT6nZkXJtexHoU97vIoNblaifU +ZINkL/qssHSGN2hgDDupshEYSLXDnoY8xLdfj5F+y21Fu9Tdz47gEpXIky1XsMMEbcgWhPuH0VI+ +patBhcLEs45lpuPM+qFvdhTusUGZz2lkRaMRYRD3pDNSgiqicjhDahV2Z6gblPjGvFAIzVtK3B7m +f45ipSIQneI2ede1X5GPKAa027C/WV5gfqUN3QgXWQyyAeHdDJiDMxgQ+ZJqR9Cs9yt71kRt0QD1 +QGwJNOueqHFwqVSyylnCUyzh4GAgozdhluWgILPiaXFF6KKtsPeNGiiAmh68++vIKeoH0ZjnNKzj +5VkjMdLzNRKkUXfu7rzB9GCx12/1g9IlaGNhJVDm4kLfs9y6G0jXc9MJxFJ4DwxFWwsqLJMhUcVU +MXvMgGGRMfpoKHf9n6AC49bZKKiP3XzJgYoPUk7HC5tlpH+TS4tqt39ZKwDqPG+7hA+w7vAN9or6 +PMeMWYndciR2Z3mJ/Rvqp4v+Ir1SBIaQ2SF3S2iKa1KOKn2+bKcrv38/w7sg3GlZENVbg0k2omEc +tfJD/z4faUYoelbslywc0b6mrIk091gBRbvWIZ9HLvs0nHBAhmgLEWMMXGzs+aAgQr0egaqrFsnG +jh3Ter7o0cg0u3bW61vyRad05H6VO4r7FIKbA/o6k3SfcKp5JuGk/qnhPLg5zzz4s8al2msU9qti +eBTyQ1Nd5Vy8l4XRA7G8HgSCRFZoByp8Sc5nNb/kICZxqY8zUv5TFphuvCY0WdPIg56t02rHR55U +qI4Ae5+dlrLPwUSmIcxfd6xRFEB1jHi48GLdl3jCG7EVNV6JTIZqBBHMAqemrA0touDVXQXjnzX4 +oMmNH+BEAHloHN7m2vR4JQe91IYGwftdQ//hSG/vSzvi8x+NlN/1z62ZBAQIjpgP8sHoAcecsiRR +fnpv8Dey1a1ffAtT0LML2EetYsUr3Kvxsj7Y70sslPOAJ26bCX3lEHc4UXWfaEelMSgY7FyTvhwa +r7w13AFcUGoB66PF7edepJAU0YGbGV4I0tXBN5Yv2omVrUuzQbua+/mgqezTQrRVejlI8DpuoU0N +AgBly9C1Ab/ZM/9iacFkQ2zv5wbvCWHtV42hb/KcRbOlWDTDTLYf23TFPzF6uKLouMrOHtyDEn5q +M4gYFFN0H+64dqqIEp7JLXRAlP9Mr6MQLccpiLk5RSl+q3lNkH7N1yxJT3whjNnbka9eVsI9GBoS +1uLmuXEdcrSUvMZmQ2yRkUmJDTUauo45G8ppOBvrfuxf3hp7PRrGsLKgjO+ofLJR+GhogQTaC88r +xni1MaeRYLNozabf3XVv+3aFy11oSULDZN/Y1bWLYc31OhfRqGw4ilbk9VaQY5XlEfgBth565UKL +LNy6G2nMbt5n3cOF6PKU3UfmAYJ7HM7AAWGHHXcocgEwzBuWw4LcHaN7t0NflUFi8EXuNnn/0c2x +0uHaDFnV1Fpjf1u/a4D2R56rUOI5PLfbqDJKD2WUtUwnFmFKn0Vp8bkTGvqVpq3o/3Elcae4LXXK +9IHn3Uc0VxtxMDePtYgZ0d48KSJS1TO2aXMEnfOgOHqgOGphIg/B8CedpBDg//0okB2LC/jU8Pub +jQeaz+5Ez/vPveAVBOsHsw+1RFnO9BMfZWrI9LnHV9P2ey+4nTAo9yRZtGUsRwR09+ohor+A+kBm +NLGmRHgOiXBpS/mwlHbMAuPwO6OneoyeHqH2iNORg+8WCODlFWGlkx3OXlSbWfwKRlJIIJFRDm19 +cDWYaLK7i71lOj5SHM1oCOHlGYD1osZyAJzfGv7l7H1jt772qp2fL74+FDUhbC8m9VQaIrJEaUiI +PLCSkUVII5QXZCV5a3vxyVcLq4aTjp3y7cTGk05jnsOIUEAndZ4eM3ooNGKPeXqYu2ih4mOPcc90 +3Ot2L6VlpU4lqVOUV8wbmLwl2eyIatf1Z8fXIxDUslF2h0JB1B562I8P3OM88o+wWHKAqkUGIdHm +nayU54j290415GnwdgmTIQVVUF4uV0f1insxvZ/B1xR8n4FhV7XS44NqNRK+eTdiuFCwDoNitjGH +yBK5n/2Y0vVp0cRkmkhaSgWBAkhVugvpYI8Da1MMulOwx2HHvaehaSHvOaCCR3ZOUGbWxwkWO1hd +WntI55IJ5OuPVKGveijbDWyl1ZjRdFXiBFejF+IJ2rbzpqLwHdMLOYWiETBvWWSoqzyWX6jMqcht +YnhPxqEUwZ08t72ewY3vi0omgPuBXKc+pbisGklRdNyu7Eolwbc3jkUi71sPWCwSuZiOXii3eoQS +6YVrmnmz4BcESqhTGlARISAvo0e4RZ5lfwuUHSj+k7MK8jeJjLCQPVq0QOuBcBJI9MOJLN0sBOqx +nX2UuB8varSoSnRwscndVxiujnZNZwFWVxryyqHLTgKDjte8nc/kKesqgfoIp1gnA6LP6sIe3D1c +iGjwjQDo7hB3/ySMX+4OVhMZsOFgC3cQpEmcoFe/HqLRE5M6ZS5mCNNL7EPkn+Sp8vJXk2M3hl3Q +HiDw32zs8a0mUSHrOqwdaX6iwXo32jw8Is5zSfc2dr1Lp1wTjiL9dR9lR0cvZ2HPq8cJRrvZBhFL +95aF2+7epqAwNo+JqJmpx7yMmW12VwqB2xCwRqalSaj+Eox4+5YcFUiDE9NepjQDyfCpms/JayQz +3VnR9/g8cIf1MIb3zilIXfEdSPkrzNmDgyWbSgOMPbZyfu+BaGeuNzf5qXE9gSdj42IZCZ4B8ySR +A6wJFe/z0ChiT/0RUuRrVkM52adXiqIkr2+FJ4IPpENOmadY/enz6wT2eqjft81Qd8gaj0tpfIBO +y7hoKXYugoG4RwBdH43CPu6fpmHwCfcuFf1R/SBbvfDQhcuyxKgVu9knOAoXbMRHLsu79/6R0TaO +LwhcoedAdPybapXj/wkzRozE7pU4Q46KZjZXP81qiW723inzFDV0xPhm3SftAQCP9G7GJq6994jb +diKLt6+jTwq+jsQv1qiKH3SxIBBLnvcePo573M+N4gPTOJfV4rJGaLPo2UTqo4b8ysuGG71FyfwJ +GaPxagzAgHZhk4DRgNQ6fguYPPlQeVOAPx75wc/sd8VI68ANQPTkyIgtLa5KCPYKKtDWCXdp5szP +abG3HtdG/UIUMjudecypyZCZYYeBH3JJSsV301TrVPqc/R5nHvaGr6P1YzjAOgk7z23oCD46iWQa +9qKsAE9fUTcUFLg/106lBizxHsyJfsg8gzE3LO+lUAreX6GkLAirjKO1BkhmN1RynIj89CtPAwbd +uLjCEHeLBj6MZ8kEy4VL5jh/16mtSUwl8RGg5Kgs9BMp1xrKDv0sfuwipcIhJCixIRpilD1HFxiN +bem351tQwAnhmEpDOln5qffPn1jnbmHsZ41XvIsaVJLqswfsHIIQhd4dUc4Ropzj9fnrzdJqLUGt +bB9fgnOh4MC+NyWJzROhksMMFk2BXESEcnNuqIQovzNpypRdbVQvvIc6LoRJHaI4ikvfns9JocKp +XteskEY2rNjdsLXDCGRdHxzR8mm/uvBVCJeP94sINeziVpynjHoPV87hMjZ1Fcj5seC1MlrcbH8T +LVK++HzGT4ixtCLIsXFPLy8zdXP1yvWaXbQgqMDuvgoyYLchHuHRsrmdVwthRTTK2SH2cZaF9Ryy +ZykhiiRCNQJKRpzgBjBUgl5jolZ0Gt1OpulH0KvIXeq67iI7cuRdwCumN4dcdSQuCUx66APJwn2c ++CwGo9BuiWEc7X196fbeDOMhP5+33r1OfZ8Bf4omfikf3jkwQjLeQqhWfW9oh+0QQMLPjTWEs2TB +SPJB5nwvL4JUn0M5e/yF5Xu8wtTHm4JqVycvYLWpHJttfUNCtAiYmA1TMtd02w1C+A== + + + Bbem0YrowtoxLFGApHmeGjJ8A8z2Z/obYO5ULzoGrx3ROhWXCgkbOQWMZwb8JuXzm0MX6q2B6vVL +4vpz4woZvnIRb2ymYBVhgI2uGACGaMAFpPVXQ2x8Vizf8N2QQriNAE6CsQv1b6g1WOYxTDhMhOS6 +uX+PNznG2Dwl/UCH2Igz+d+dcz3hpjOJUy0llEgt8WhZeAOdcP7mLl9jyvOZhrNa+OWDI4X2vp/k +h/k4rxz4KSQ3AKymV8gIDj25t5OMgPVt1/wjAPvR8EQDdPQ77fr9z437nQt4FuasLplK9BchiAaP +wJeNjCDE5Bmyf0dpSdkocC0gVZgUOymuYbhoPnyUADKyU39C603686mRIWZI4Q0svmKd1ToIZXbp +Q0QBlHxJ2wK3XqF9QG0XfO7e8aEH//r7FErdjJyPyBjppsui35/X32qALK1Hn1zO3Xk1MimjRA0u +DU1TrZKZctHg0MqlwwJTaQwUmuvtvm8W3BCh8AcirlaOGR0Fuj1S0BuJJUXn5b1k9IDQfl0f/y2L +8HKJfpFP9FceLGGL1L+nCPk/fyCb+u1v/u23//k/fvlk+du//49/+tP//vY3/+Fv/9vv/vKXP/7z +P/30t//np//yu3/4p59+/NOf/99Pf/pfP/2nP/zDX/7zP//p//45Tvr1N/77H//8x9/95Y9/+Gmf +4mcX97yu4FdoT/+V/0oIwk4R21MiAabmhHUOS8JDaY5grsBF3hNggYzMr1ddOmP1QWD+jdosInOo +8lDLHt8AVJB/fX3st3TZyDPIcl+SrRqLxSh6RyIM9q0QVoKNwZKcI//j6bXff40fF6H4Wy96kGXS +GpL0WFGJH9R8DfQdPbpawxga7VewGPKeFylZ1O+BPQHSSQXhkflb2SbuICagZQ+YdWjrHdlYtF+z +Vt7rQch8v081aZSzbwF2S7FWtlo0oaQT4uUVgBo26ua4WMPoIO8/YWzR7IERJj0Q54geBPwcAlQG +PcpzDg8UOT5qssxr4FCbtKDFl/bXECSlB4D63cOJremGMgWIMldGDziP9FgndGglCMH4uZCG37fh +lBZw6AA5ux8zLjvulveeFTHXGrx3SvFInjagqzh87KVJlaKyTgFuTxsPVRunEcCDrYMpmmvJMVkB +Xy1NP5o9sRBJ7ecBlRWv+8qjR1MVOWKFWUka7/Cz5sO0JgGzDi69QmuAMgLlharvDsrCi6wwHaK1 +iGkWwjjJk6Aq3MJ3Z78De0jsDszMIIogJu8tWi09iuV7qM908ET02lvMQi9m3eiFsxB0vnaOM07D +QgOKryNQQYPg4DTAi1R7iMTcT0ra6T0B9BF6qcxHL1GF7F/ZgkjG68PDgOmmA4RyOgwy9V4BHJnd +A5qKPc5ub4dUO5RlTwesagftFeFeECqZFz1xw4FbwkDQqGofji30Pg1ipyB4MSyrqmS266Vbe/Mt +3JvLxhry+g75HKpbCKgjolFZ4skR7hBEm573HoXfzwfUIc6L/EWvFs6pxBxAeCooIAZqviO+jDBm +zvu9Jn1R4Rb4XD41xA+gtFi++Ba6N4y2/QZXV0CdrdBoWFTzUPlNgQpP6LCzFUT6hJwulKp07xC9 +uM0AAlH8pZcYiSxZrMZxQFPQAyRJRZFthelQXl5LioJ/QuOPuI0eqKvsHnUdyA+9pCeRvYBiSi/h +kbCvZlxwo1alvVqOdjTdZGdN23vF8Zypj5tCB9Tz8tNuhZz7sqMjJ6BOgr6iOk9yknQBQJRqsppU +F3YEq3rnyFYTQLiZ/aJHD6vkzMp19F3fe6FBhjEuMH1SFTw8gXLo+Xc+UE9pIB7yIKlWFVZoDJ/9 +BjFaPnWIMVbCwXY/hEkN5e0oxlaMrCeM1PJgPV3fNXw1dG9jgku0x3tzSXhAVXc+AK/sMAZDxvyB +vIIvJBqjKMsiXxA99nJxjFgrdeIWa47oShYHNaiRInfUFKJjplql5rHlAMlTrRDaC/ohEas+nB37 +oh5fJ5mXGWit2ENFK/JJGJnUpk/bogdlU3tgYUQP4pBzN2cAh3avjOxNCdy8vVZmHodqGbNoiTSC +avWz2WOsbg8MD+ix94pxLXsTZW5r1kNFqDACZW2gKNViFdOKtSgKMRwfVCX2+ABYlGMxx/MMI3dc +yPY4CluyNGtVlP1zD8+0hFKyPabE/sVxmhI9e21+uNM7oGEnwDq6F7MUUUpeuhcapSQjndwOXsRe +tYiSmRSLjXZw5SPaQZmdHvxWcTQw54yYmDKImNAg+vXI6wbkQZRrlCL2ZS8dvVkPqAvs12+/+mSg +W0RqqDcRyEzXVNacGhYNewVe1LsbOQ0G4dyrC0KVvD1DPWRYrJNEALDd6Qg7i5Ft+z+07QWr2NZR +dN9hqgBkeywT3RjGVXuAKqJHBtRED+IMelTYmPSYqAWi5bNOIq+t4XCkFzkteykTu3utrOAyFnOd +M2WUVqIHJUF67JfLHvtdHEtcQo13RTfffS3pmnPuacF5HZJcpRLivILUpN6lhEx6ZyIyxSrCKgnT +HGwGtUegTw3DC8RnSbwz84SYFjP4Hi4Hf950jANId0AvhDxa8/G+oRDQkAvCCmc2FWtclTUBLkls +ze6heg0SVysbWdV696Bs85991r1KL7Xtc1TLy54GNCp4zpKZ4wcTj1Gtb1asByyXVeCXGLABiy4K +Gr0Or/7XJB7lylKIvGKUqwA/LzFSH4QasMXswYijx4587MFzWADXqIx7HsCFhSRruidqAur3rcwR +YGPwuCKqX2pxIwQA6oHkExFJ7hGA4QmSfO6/9or8eF6phmgDtbnFBfXgg6l9BC0BqZx/PL1aAg+F +itUxyxMyinKEW3KOw+gkCFf97DmKMLC0yPQgUf+U48NXgpt1Cy00Zp4ZsB6JdrDSSB0Q3QI6atoM +7CVKesY4HYIm9pCPb0jhj0P9CjPBeaWb9iwC/ndPCXvgaPDApmZYHNuzAQMcT9kVnomYwDza8pBw +I3/GdkJVHzNin3p4gqxrMGIJ2F/OL44jRagkthM59LlQVSQDXHhCpOMx15sqriXLdJZ2qVqTELnB +8KMge7bXOOh2dLTpRTGEDr7MD6ISBxvvYko0pF7B/CHMhVD9VANyL6uHNVkjByfTUhMOe1Xh/sQI +2a+zbdk9rit3Cs0+4kA03OlQodTy09JzSJNZWiVz4jlRd7549rqcLcWzaTJdU8MXFDFgM2vMg1IU +0NXr7LCR3GTNodpbQpPjFj0bHkZ5itcuQELIeQqkgGCIyWoD14ncvoTSFT6PygHt/Wg4Arz3wHF4 +ohInSuE888+92JsCqASyucwH82hyXYfIE8IdUzU+pDZbLH2lujgiPv7eI35T/QHmzyKhAazgi+Nw +aqYIKozZSzH+wlUcaNRbh4ys0k05fG7rqsN4n5/QyFNCtBFGJM5G5oypjxi9nrw9oQEZ+DnvYZFM +IU+AaBI+imiyInq6x3sxMijuS+kQx1Cb2OID6yhn8e5hYTPtUPBp53Wh0H5PQj2LffsefFEpYJnS +FVVIo5RYROQXxgBP9CChQQ+eW1NWl9zEDukwOPFMDZbcnn0B+saAfRyXCA/kPK53riKFaKTw5lGW +IbB9GJ7hlyyiGBid7gFvPYrOGjxI7Lzvmd56PaFeRk14ngeABAm3RqpmkSuV1VpHS80syA7b0BxG +qK2894hsCuUpFR0oRLcvjgOgymRPQdSSQb5Qy8TRvSAN9t5BFzAkXWHjnhrrF73QFYcxCQHFXL+C +rITk7Ie6byWi62hANLAbDXnYFq6bFS38RtyWT7YGbBdLtwucEpLpjoM9aIkbKJI6LeF/ozvy55FS +rUQPlSotsuA17NPpKLDHotlQOdy/YrG9rOwlmPsLqn9tIXi31xLqFoiesl4VDyP8zYReohqSI8fG +PpRqp7916FW7J5kjmU4vkhe7FxonIbrmytzwCyMTR5y8l4q1rJMWh5POiHsXAQ+mYcNCpoykkk6/ +iPD6m8veCN+Hg0vMXmPplXqJXmE3XHaEtzeC9NjR0X5H9peLo2Ccqa4s7e3poUc5DYBHG80Hh0wj +smp8vUjY1t9j+fUR9SGc0QuXQNRX7JFqtQfy29EDcQeOkZxte2j4kyGc9f+z9m671izpmdYVcA/r +EDgwGbuMyEMoIdSSEYgT6COrVW2klnC71RhL3D3xPG/k/GvNMe1FS9Ulu8v/+GbmGLmJ+Dbv5v0p +gJH2U4RifFx+ZySpMVrlXadq4i3eB0FoOPOyeoQAtXj6w4TorUaGFgcLJG+TguTMD0ddviVYfFKn +wUiJjZ9HW4QTW+xlYrTPuMBPwJV9vCPhrocQd01s6X8b6vvsZXLv9vpGEyHrZ0e8VicEFarSHbSE +bbq/whGAQbqfnmENjMcpteyTE8U1+Jq0JXfEnbJENcYW0n84gJd2DOdM95tnWWMDegRM6fHpy98o +dV/5mjuZU4SXtcIIdHD4jvNJhqiSC2aZr/TpUNjt4kugK9WPWIvGzr3ikTJEeZAT4XWsqMhkVubc +cMlLg7FyHyAqfd0u/ellETQ5hPvPmZUlVTPLh0uBqjonqI8R7Cr3Z4IwgIywNeH7UaNXC2eQHfJp +66UfNs07CVpK1xWVQ9SaZd7rYbAoJ8LBtRFPdlqWKAOowQmY95G9RcNDqu34dZ6rvA7rLQ7rc+av +9z3yryELuGONfIELkKm/g/92Q2yn41E0Rfp6pJxEoNPh1Fy3QPZvtFzxzYEFuW/TitpvNy/RE7Sn +tv8hQjnH+XUnfv8hPE/EUNt5ovaNpjMBPBnASgUOvVMlZCr4Sr8NzNF8NXYSJN7je4TnsTpCw2x/ +a1Bcn8e5tJjEsPbugllY8JAkoPfWVUzhl92w83lW+a4rbw+1xnPMgzjOPghYFER1bWRIkWp0QypU +035KxP1uYuFTsVbAKbTB0bn5SWQn2KevS+bYR4Q/CQt6GrYAjvk2H4cB4pd7v3TBqri3sbc1+qR1 +/hABsGkxpt+/Z8xfD9fvo/AaMp3eLz8iVqNBPmgo84KZDmSAIZQa04A7wL/dC2Dlgpr7/XNPg+73 +jbjzXnjsQn0/CLi9DgKoRVJQNQ9aHVgU8TU+AhAsQlQaHPt8/b0+ohgzTN+mK7xkhkP732Fqw3Xt +8uvRBmIMdkNT5Jeuz4j3UbspvvRS4J3/PA5GWjt5oN3l5ajQMKgt9vO1lP/c2R4Jxo2KN/m3hirs +qbwX6+X2PGcJWgAAi1GdhxVMMe+yEb7cNESobeuRyGYNpiQnwlElYjaAR4kAPUkEZilfZ3LkybRu +/3mieNh2Wl0Y3hBRIX/h1NKVNWxxENkRupMTYTqKhkw7vylJk3O89zdhC8azvzcApAVcT2gJ7vXE +zsdgFgN/8ubN9HEEQHFZd8/zsO1Ldd51E5LfB+Q8lCvthz8mL6PUpxbqSc8p6BlVMFz6KeKYGO3X +++XBfgYhg6XqM5YD/AqWXfmkUFuyMCcJ2e/d7a/Er2nRzGI5/va5J8FvwX0Svnr7OA== + + + BEMhdkhkMeudL9rdOY707g8RM7NDAEfzvSUfUY1Eg8zvugQ98WUfmSGPTavfaj+tG3k3e9keyEFX +rsd+XBvl6/eI99VMb7DdWsB9D6Jdu5foQrsWXIBfZfzwz9RU+72xpurtbXF+j0LD3pdhAhm/XUB8 ++HZORddVoFzkAIr65/uX3ljXrqVygC2ubxG5YkO+OJjupivXx3EazbTB4q0Pw8nExsnEuGLtSc0K +HuVeUdq5DsthKKB+C1a57iOgnmIfVehW/XNEmhBi/tLt8Z4p5lkMsDSHV8x39BB001Qd+NpkHnlm +RGHo4qKctZ/uikdBwofP8YY+YDEVeUJwyRGWEVAojHgNVIceGKySuswdeXZuCfqFuNeORvKOlE8v +Aa5LI0a9WVlvEqSuLBW0jkvk//eIbGLL8Q+ZzH6rfjzOc96mworW4ry9lLueWhx8RqxySK0qnbav +7PVbVD8KUa3rvUhWxfx3UbvCdKG9FRpuper2J+2NlZyvPf7oHaAcPt7npb77cn8zN/RjTxQZy8A9 +FTE7MGYgPXZEV+JPy/nmB5CB+L8facf73SyjfR03W0KlYhqSmNJ9q5P8IsfFxYMzK2a2ZtpDSKVw +df1uXoQKHbElgo4L6k7juJ6SpNsSuPmSJbf/kWlF/QiqbcSKjsrpSicQLeilPhWlzw8RyJ01lboZ +N7955kdUiVPMuEHopAJjREAmeouVvh0YWhIxYN0/BSey8vXB1wO8UzQe4Iqq9ddfNbUvcCi47Abz +tSyoIVKgT7h/gHCHhXuOx2VaZZu1oiAaJNv+U8U5F4kBcygd2+mt4B6KVSz76iUHnpNxqUF/22sd +N7pse1mb+ZJM8Vq7PyP+/I7UmGlOGHrz+Yyivc48ehdYe3+5s6g496Krrpb4R8QPe+NnENg+GhiM +F3jcO8a0zNx3Wo0l+N4I9K3qKPwv+Jkdxja26Pux0S4V5RIUgdvIyNHuCZCQTBTQ7QDxDWJ0l0eg +/Gm1dsVk6CUUpv/K2uI0zngGn5nfOhqw9AUXVasZsmQboGTX3g5Pl4bJxV5V9k9QtoSkAoBTd1aM +xgTm6rN/ffDPNpGurOFsijdD7fevdGdCbmRfWWtPKInURLg+0cijjwVehdKsiN0Fc/X2jPiQTYwP +1Xf1Q9WdY1+WCBplRFD+tndRB/3e3oieCBuvRlyaXlh1vmeidCdqZwvsxjXup51d/slxWsATo3G5 +jPCJ2e9a1+AbmbthS24/5cUIzVc6Rg71be3tdQGuObNGEHBE7Q/Rnq4KKBBx2+yEjcPVBP2LpzlO +utxiSFOcUUeC9eJEm6N63EXvGA085HrAfxtTWpRVPerAZGP5gORBXLvcZOZ1nSkbbRaocBUG2ZSG +jbb5r+79oqHJh02xZ2Xv+HcyIrr6cPATAL212W4qRrhK0Pe3Idkw5pnh3gBPfo9vnwHlMmx8iVIv +DZpwBvwu2CqbkQ7orFr9PB7Cl7TFnKe+6s0QvNuT/D3ngRczljZ2S+7GOGU00o3cT6qfm92uI9Q5 +fXXZpB50VPW9BwjtdKbtt585GQssf9FgWJZzYy7ljOhKYyXlq6uAYqMZyqtLaWNrsNmIqMj20RED +yFC0LP8esGKEAaDgpSR9BMF93A8eVkFgVnh6guTE83kAjbgz5qjIwvIAtJWcdR8iRZgCOUxq7xiY ++HtaP6M/3OpWUCOeaGf/lYFD13GNsvBRYUqIjKsiuwFt1F00ZYdCXbsLorkPcJMGyikKiHKEuKM6 +3XmiBGhBg2KSQQREdSIKO4gRgg73zjftgjMLZ92ieAFUwJkEoPL2zf51puE4VsWPcr5P8c+tbTBH +Ib/ZF1OHef+CxzBipMMPxGPvJQ4s+znuVKmFK/pQGoFXkRNfX+F4SIoeH+oznX4mvnS16mhsWDtC +0jY1dqMfacSjcSeqCqf7RBSo0nxIoU3/2RM8aYPCae88F8y69wUigrLytz6uQGN2RGE47VcA4VGZ +UZ7XkqCdGBvEo0BQnh6UKcqTE2ElzImA5BMBJsOvRuNrfzDsL/JBEcJKbre+boGJ4mJlfPgluqHs +K92Eb+1cLNWrbaL5Fx9gmsBPbntjmy+y9v1QphLYToQlS+4oMCSuOEwQBfAHnJeG3+3FwKNkMvP9 +g7TkLzGMn391P3oWoW1C0YCJBF4477/z/5HsYTc+j6LM+9mc6Q5VNwba+jQCWUyrhEp/u75EoCgw +xehIO1La4Qaphvz3iNw0+qt7R9r/U/QJ+jzOJWLD26q4/lxBwsAIY2r6GYBiDuJtF83i/uvp+F3U +vWLj08Sk7MPcSfCXLhSAom7Tdq9n8GdTV0PuZpbQQi9+/rrq+2IQxRZJkHMZ9FlRASJAZNAOKOgC +EwAiDi3V4cfdmw5Ua53P2UQ4wFj311mSxoBqZGueWtYb9YhWJ4JyeunM1IzARIlvW4UoEUHrb0ew +ye8IEGqI+ysH277OZOMOiEkTM3+f9gD8GEZIOOOQTKBmj+pNvaslPzqmF082j2nGUNTO7TMgy8L3 +tO3jMKQBqKOAJgEAwVdhePOgvae9wkeEj0DPI1De9/cjaiVltekzxvm+83zfnX/gXUR2vjenwniA +mdjOHslgH9yoPyP+fIBwjl0mRH/m8B/HARYFiG9CtCdCjr+P1K0FPYgjRyITUCZSyJgUASPktj4H +4AlwabgOTJk3AqKmLR3GhvP0w0dPP7z/FDEDNHuQP5qHFf8ZxYR8XyAsoxkgBP0fnD3VFBNYy5l9 +shUqBAkhCH/cFPq7QktRvBnkqsZnFKK6FTYbufZQttVRL05XiRA3ihJAb4ko3FM1o5oRLmda0bVf +Z8puiZJXS9RDKllb7EeNYIVd+NUAGsSHsMh+SPXkmaiq+S6UaEasSA5fryXBvuyBZqwWMZaGTiJ0 +jp1dFYuamYb+QhuzdpFheuBVWOROlb9HVFmCQJz3Uvj+pI+oXiKBlcRmueIyyAf2+wQIv287byod +DvI7us5c5o+IP5+sCY9dK6G9RP5wnOosie1P4X+BymqQFa0r5w8RO704nc0fPivB4GL4I2QLYSYA +qE+5WGVE2h+sN2/zbyQrk3nKsr3fPwK+FhQYKwtCBhyE70eBpwaec8mbb/mSNNH2SktBKgZtxCKw +a8uUa91zrds7ZYcMN/Va7dTNBE0Q0dj6WtgRQKeWADk4mhoXI7wRnsjERipBM4LUlQh5zO+JsmKf +qRtwUbuHJUgmj8NaQwRpf3DqIzh1+pkETNYTUZxPEKcXM1wO0Q9Muo93a1DTeQddMSsVUkU2Cz+i +AZHY5Tk0UhC80JsoXfeu1n+IQKvUq0IX98gVf0YVcBID1e5SRUn3lloADjAjDrg+tDb3e1UBM4oe +EQ0AeuSGLfE9Ik9dd4nZ7yOqPu2H48BcYIq8nykUcUXhM/bvRbstOrT7KrKICEC7eHPpmZ1qmTmA +8Ly9XqHwDX0l1INdwzMy6eUFfB95TjgA4lOKqFuxQ/ZXkK++AdnypU9Pir/mlheGhWDuH5VeAjii +U6bg7ZwWBLbJgcLADUZYnD7VfsYxjPsICPSpu3yBCnyKC+Xvg9pzlM0usIclCFopEKRN/JjPgDuw +77qzqVdn5TOqyv6uUmQe3ZuC7Ie2sl/fGuYTYGLuCv1efhCSHPygfecSUb4wdfS+4FjxwKzzodwZ +Rog11yNPAqJ6hxMlFnhHICZhQPoDPAcjBKKQu6iZ1teJpk8FPHu/Zw9NDWxGEV5/KVwokc3SEdEF +uhTIoAjv0f+9iWIs2MgbQauizGj2v8hTpLPE49QaQtNVvWZ0wAMNzY9+gOYur6pQ//2zboS0f4ig +Vdq+sKe//7BEaqMJ+Yaw91wTxT7uaaNG2fd0tivwxkQs3SM/I3KtIgMJyWjvJj8e5z6kv1nVhOb7 +iagqyplXyYOH3jnEZgPF9L4uvvrLHRwH7qZm2viM+tvzdeBm7Kh1yHVnFFxmsL22jqqsqF2L8zJj +asIkp+wXFr2qHyJaMEh7y4Ru8KsF9bso1JnV7y7hLAAck+zRWkDCO6eVVnmxE1A7Ihg+UM+YyFb/ +EPHWZxDxaJkytf3hOOuwR/ca1YabEL0mVINAuNJB+Ij4vjEnq/0ehTiKzIalHgnJYbelzZDDJatL +HJBJAMUQpFcqhr0uCuC8HhlGyWVboCWToUWfrrYi0sijaP6AWWgIIk5ABvCQaLRJVWjpBjHnvbRZ +vULYsEJv8EDvnX4c4UpAI6aQk54+FQcypg+kIiymQQRcQKMB3pdHqbYKdRQobCX13yvzvz1TbYTZ +F4pxg34i8zTYj0xzwawMyF7k9UAuoQxTCYQMtB8YSo6xky565d//PWOUnoaGJgfAiT7++pimkU+T +rpjN6yeJEid/8hnBzqtn3T78od5/BmlbsL+/GrPkyN6ZITAWwQ2+GlDkpW+DwIErWyOWWe2MBIbG +qwATdWe+A3ReUgrBgO7jNyt1/f64DNfKYAGdFwCXf4z4e7GB0v4/ye8FMvrvWOeqz/JWQWdkSXIK +P1gDcN4Zh8t0QEGoIRY5nzNORTT5LaQ4Dh1+ZiJ0bYiQ+IQc7T3y4klRYNgGJNwIeqI7or3lwzMP +yoXMDiK3QHKx/wsoA+Mk4NfYkoN1s76g3HhQd/e1KIdhjjAWzypSzprK4t95v0gPWOaVZ9XhmVEu +bLt23Hv/8DBCk+norzsREECtWpGHJKKS6cCzn+dMCHamrr1+nak9znQQkTxR4RbCy81xsMYhovlU +aWx++8FgbMwHQk6fHk7T/im0fM4JEJlCvWWXQ1NmO6/FfujQLCd3HECRg3+QQWnJBaQYC3qMtkWX +hY3JjtrcJvpxDwQUs/cM8RX7708aQNVN+nI/QMbgHe2HiN47coR7+fkb2lHKCIB6HaijQBphb+sS +GZX7gLSG4uQZN+KLwS5xo2zCJoqSN6PvdaBG+x/zryLJ9ldEJo5BbmACdKssPNBSJuOk3/S+1JiU +sXrfrE6WFkPEsH9OV4c/99ujKw6KAV8Gih4kVenD8sH+xXxpdFp/jZGlgPMhA44igClfy84TkH7W +hESwu1adVYwQrUeuW8eJAFLMCd4ES/htqrNp+671YwVYACWh8QTKgT7NjQpZCeEPONUgUjxTBa1P +CTtDw92v1HxLdsblsF8Zl3PevWemTgMgONcVdIJjLNsU8q6fVOQXzQIeIDQehT1d+8qwW+Go/IIS +kIsCckBPlwZxA/DNMO/ab7Hj74kFLN00xBaLLGcH2bKiKItwBuUBvYujdB6S+eZtO/0PRQohW5x7 ++ZmVZR+5OrwCvdKw5u54LUls378XatT+j7CIlSIYBQHZmkxsQi3vL2yr6xLdJUPRAyQGkzgVIy4R +r+tADZm1zwTQQ94BU1hUh3R1iQTZL9/KadDNdjj0vtLgRUTuMpekfgVB8Hh5dj3bciKKKSKkZirV +NTkRXaYTAHyLQ9DtJiK0JhkJ6+tEj09gaU7ZuS5Z1y8daoEi2zgir6FZAHPYX7STtQ== + + + jkQwd97sYd95h5KoCoRSyVDuBW0rIG7ndr9avKOajCOpWvRfHGjAIaqLIu/SerWHXrx/r0C6AQAf +e/odaibcVBna3/VatKhOkjCv7Gf0K8BZNQ2ai8IO6Ix6Jm4aZ2LT/A0dDBXX94VtwvAGG1NHThlt +uX0MzKSAT1yOW37h0G3U3m8Dat2xc7sEzpDMrDCP95WSJ64X3m2SIyviRmhKKvVCZgz9iv3AlrPu +IqfMoHwvfWWphYHlJvM5pjggxvQhBJ8MN4KVeU408PZxOujd5aifKBnSyo3eBtFZJ4hWh8v3IxwM +ee37RMBVIqKyF+LGDs/jFjJUciJ/6o4fr9o7LCGSk9sNc52vgzZD92d4nKBOwJdSozNHoal/0aDi +0hPB7eZJZWEhwuHfjqDHf4AvJWPP23ErUdd5ixgy8n60KzowNHwvH3h6FB5fciIiCKNnRSSpfBDr +OZaA+7n5GzAjUEO4c+44BbgWIB46FoOBNWXGrtHutN3EYrNC0xol1+kzLtxFCjYK6iAJCxTzg3VK +RtRPRmRMmlTs0ydjcl8lp6L55VEUS6ADsFKq/OvZ25sP/jXc5MN+D3i1mK4UNK+wXi6g0IVvrMM6 +KfgRg3lnDIsKEXWhD//hHvHwMU+V0AX+QCtcaRphTwBdLi84k16iMNBG76PmQxpkyHyYr9EphCF8 +I3FegqAupqf7aZzC+UvQEgi1dL2g0V2z0bUsKd8zZTfct7eJST7zyI46wjxnCjgS6/lmhDzZLsU0 +ZxJxwQeAmLo2QefZvVGaBrSFe8AhO8lZAF7XQypQqgjemeB6GjNTrHLhFNZ17Drid2mg8EukuvSC +a+CbuF0ZpGOAtyRf8YA1aFUIvpYk08JJeL6esKeWHEiyWLYRuClKFFRyu+eTmhXobD9KAWT6PUHs +v/wkjO54Xx4F/QUL5Efz5hJRXRqIAAsFLgRJOZ3p5c7QhD/a4UStmRPopEcVKxBP4V1+CbVmM0AQ +9g7ooHk9PoNVvgFZNxF6RnUaLS+ijoLLtvEuy688guDluK6NDtOQFOiVT96697IoDfWLBKn99sev +x5/+iq8knSnwL3SmcHC3Mn/YUqnE6Cj9w4mi409Uw3KAKGnglXk49HyFCYbHudGY9DiAhncEGjJG +gPYgwpXSyTSIQXUC+kvffk5LiTxjZX7NxJco2hI5DnhAjiMlkDWMlINEFUBEe2UU+C4obK1jPcaC +/GIfbZSJndk3lESKpoXgqIqa8aFZO2pG6BNgCSAGh3NUPzxqKgOsgFRMAICytFfnqx5IV6sMJq1p +IimFE9OThrPtDtBtF2svqRF5Ceehhbc36WHjB7plkta9cb/iRtDsBjnw3lhvEhWi6PRd6n0Nj0MO +TsQD7pCIqCaJIr+NYB8kQhdGInxdrkPd+DrTLuCMou1AFOWnj3EfOdP5nuTAjw2akl+yMwe64Rjo +9kSgAk36vcovnvVF2vLgBUSGcR+c2oWopJMDGvpdLWWKLI/DXNNarzEVxEDpySROHwsyv3eAxUpg +x7NC8mCaE8DZzs7qdR8cX3rQJO/TKQzFQWcaU3ysVaJSdejcRM0ZzzjpSoEL0BIUIC1MPQkBRiDj +318aHFRE5npNRBVSLrgyIMmqQjtF+iRvL6YMruqs4PN5z7Sv521PkC5gBmCTgXYJLi/gIoW6aQsh +EYXpzRXJQeZFwTfRJ1iiBE8dW1QfQlvpC8WE5B4xuIxYEdI1pPZkruelSaMU88vnREC7wd2O+Qnz +TzIIq+nlB7+MghyOPqr0kTeemhsTTsbhwBl7VO6BPLfCCpx6e6gAd9OqMoLHhXr7Unzm/sIDowAl +ZvBCtHCmNGZdozSGI2yEgnlSdbo/AKSA5+XF5bzz/LCi3ufOoV5MJDpVjHco+wBGMDPT1l4rOmC7 +SLsplHU5VHHoKHxsQiCq/qmeXmbnL6qGVo7lh92SSEPRaUEaChsrYTVCJlAR4El6ArkaND5BztlU +Wzad3wSOw0oPXNzSjDWEYZZ9FBTXeECVhgG0TOuVyYXkALRRdtkj9CrTL1J2R8VXTI/pwdd3hNuu +l6PebMBg7EMaxPUAfMSrSBP+0Z+nqmlEjgaWdTqyY/J9JSXuaRLtyuJ6MbvADJENAOnml6ivJNJO +VAAX1XnUH0lrnTmdPM9RgUDEswPv//tuaunM5I/7p979i46/kzaQFU+JVhRjTnMfBFjw8eC7BH27 +n/c5A4pU8o3WudrEsKDIKB9tWtnLHhMzq7LrpeNDNZO0f8TJ2IhkbgghZQRcTznpzaADqB+h1bks +An4S7b+lhBMJJW5eTn/hko+vW+MsGmUvgB7qcrLPtets3dxGYHg4e9ndg8/BpM/s0H9/WyZdhsDF +VYRwGZXPejQI7OPyBOxLlQ+gFgOjnyURiMYSwfaf4+J6Rgr/vHyn+oKXm75y/mjE2J6qneBQnET2 +zqNnclEF083hD3Oav2ZRQ21PhstyEXHm5zTlURa6d8ZiBoW92UAsoVcdODQNw0sJQoV96KmAPA8/ +2n5FYj91OAo8ijFxW8BQMgup6jYc10uYyteX1uSOwqgNvy2klYgKPwFnQBIR7rtalh0ZEMh55fCu +6cixFk99i4jYjyR3qJwOB2CS+uqJzEf0EVEBJEobtF7bD9+VM5FUE8GTmO/Cq7i/8RV5zsemqhFC +xMyPl0IS/TqrSsPSye6Vg7jqXOMeqIqTAzARXhyYsfvOT7oe7bcA+kYhDQKT3j5aPqrpNAcedDPO +4BaRuV3w0nm5lVyVTsYPDnheUR/6WNDOST0jOK5YEC1mHzb9AfcH8ArQF5kU479Ej9T82lHWgESp +3Ciw5o54kgoVD7Om60TQD7azwUpPxJGTWPTRjeCWEdG/9I8Qeb2MokucKN5mos5hVgzpanemdx1e +CV+4MFchIhJKFR+ERNAW2hG11JcVUCLy9YQlpAxBira9q1G4kGLbXtqvBXtAdA5oYqBz0JCzh/0D +s4uRBqkSIgVfiElQRDJtdDMfMQsg+cIsAEmgMbHxcK4DAE6lhQKKedeTEcgmTQR/X36x9vrdj3ZJ +BZVwh+XTqc87qcFvINCW+hlo5ziLew7zdF8DXLu6nfmh2MwEl4ASHcalrufjTmcVcEl4JSQATThZ +CL3tsD/aoNh1R2d0zF7Mes9UD1UepnqIgX4Be4U47Ih69Lky2luOPAKwH7gq0GtQYGwFt15LcOKS +JOwq8SS/ZdAIkxhuhAJIs7tlNDwqD/3YF2m/AEw5IEY+tzPNY3dOJ/Klpws6oTnxPLH5qeRHPOdN +Mum+uuqKiRlAMJABKl1J+NAK53bhPZKH9auHHwS+jCLJgX/7Cx1lhaf4HwDTNNfBVOqlQUcGvdPM +Xnmu2RDaY4pQj7xXY6Rwy+DqCrFEJfY9fHZLcBYlnB1k8mD2aPzK7g4JCGWWm/PTDAL05qlBRAJ3 +ok+M12paH89LVOKlORQOslAgetzMtj6CuBqPxcvoYl1DyL9LCPlvhAXxfjLIT33gWI1w01r1PRE9 +SeakrJstrYlsQDx7clKasmr2gnBcpheEKjTfMe8x7Y+er2B9BsDrftk1+6l1MvGMUt6ekmMmv7dX +TJMjOLwgBbu8LHW61I02UWJEQKfPwomMjk5cDv/qI/FWeEPuI49wxU2RL+DUHTmWBmC/AWyHMvRM +n2l+ISMZniw2vNCEJN7RvjujXfIKgeUYJGNzRpS7lgMWysLrkPjR+1QOqK1I3jQYJ5zpug8DaFqY +2eb5BWbpRyF9OkcICmBMFxj477+hod4oInjT+ooeQXqI+wZfUCRQdmJx3JdsmkTVkslchyPU3qd4 +pKqUWqLk13MEoUAMkHe3o/UJdApHAnqFivvgZecLSyHKQsDQQcED2jf1V+kbc5tjZc0AT2BjOyRI +5fHoplqf0MVitg2OBoQDiftzSld4FJ3p6F6j6hdKhn3cl2hWSTeg2SvWF+zn1enLNNt7VCi7At62 +48/5C2DT1Y78NgLbsLGKPOLs/JEZI3HQ7YL3PEpWELbpN5HfNRa+FtSY2nVKULV2OwJY5wpxT4Cl +Ayl5fbv9kIqPHoyEDOF89HQHxJCWP1ckvUSfnojIXAyxuUYoaH7B7ayJiDzFXonGGZERJekJn8oj +/pUVa/ACFK8UKBwCHnH0RCiFhqGjcypUrDoGRhfuXTnRlS+73toddXhR8jyUZjpow9AdwQSR6oJR +zAwnFH6rKubVrk+MqFEck2VhSXq/GtrFdrPdo+foAUnzkzlHKa1cmGro+3E/kntT/8t9/US7MZtD +Du6C4HZFCU+qAApkXxKUd6asjMtuTDDJD/BpIHO9MsHaaSgJ815JSjKIGpQIG5MKrPCA1c5nYl2D +xenm2Tu3bu9+SBSKzBei5D3ShJoh7CiLLSIqkH1kQqEAVDmIbAAI19K1m/U00Xj9VcoYJ2EZSG9+ +nUjP8gvpbJZHhVyaX4eOLQEM2B/5rE8Cogk1gNG+EbUb4UOGXbXif+Kg/+I8vC8AkK8jY6NLgCtd +dzYPrg2kIwOw8KwhzHB1ZNpB7UExlyeRsYkmQaqU4Lt79hPmt5EGVzd3mdIDomp6pylyB7cw90Zi +1s7DfYeZICOqgC69vrQ1BqY8b4yVn3OCYUNamNU4YCx1QPddfUTDqwm3P71Y591zykm6yqBX73AR +tDY+CeAEHBvshMGxQTuiwbEGYLaOqIL73vFZVoWIuet+IFNDYlQnU7el29BWBoZNdhMP9o0AXRij +DQH5vZ6OdgihDl5Bu8NDi1DUDKcZVt998KEH2LmfUTygYOSzb6RVVuzEZF3eV6bYJ7jTTNiVswT8 +JOcnPeThZEsECABFlLEceGTZXmB9efGtBkY/LLx96dBvYp3GNPOh8keYIdlzGkaAZrqDGB8n+u8K +4qWPRoHLIzkLBS7vGFO4hqbDldak07M5gmNqNrTPCUh7EF8TOSRB7tWCR4pSp48eThjVIJ17tM1Z +G+DoaJn0z6cBKKUH8Gvc1Y7K3s7O6ZiyNdofspQ6HhoRdQdzyc7aT320//7C/7YJfYenue8Qvh5+ +4R+j2AF3FLTtc5w7EShwJILOsyo+9URIWNlfU9wwEfSqiLieX2fSMx6Z5TuyzWgLGKXIcD8wLCAf +6oES0RStZNSf73LIIlU5eQLufFl25K8T0bZnTDaFAyCmuXIYoeXQrluQa6DwDHDlr2DUVDWemRMt +bUpqFKRFOF/OOc/T1HRgoWgaSvsi40SixkaKsYc0QfvlDaH2EVDhI4S5qtUwnuimydsYclvUhCgU +w28aRJCE3Z0AVlZ1iDWSNCCqWOQdpQCUBaYjhhm9hPHoJbAcEvJDtGecX8c1y6ODahebvrwAr84F +TLEq3psHJC4LMyAPFE2KVLInGVRwHucETgS6+8xXVWzGuUhEZgwfVMhlhSbfJkKowIIkWMsnJJxq +e1mPgzJunx4W3hJ2aDnA1Cqvn0YJmzbrA1sdV7qcgm7G3nzxpS+9UaYGQsF7xgiEgQ== + + + Fk+tKGep9vjjggOCexeOHdnpjHsDsGem0qh1/jbgqpMlz6Y3wn7hAS0xz7uxu2wH5Xzbflt2XpdM +eXcL7J7b/QNsFAIq/LfbRj3KeQ9F6f3gRhLTHpU9GUFfryoWbwJl/v3m44jxs85XPHKr+mACTwnQ +K2KN0+tFD+49EWv/OqlGBZB1LCL40AE4HzIAp6FBM5EPLGcRFxn9RPjPKivcVPSnxwp/v4KmeIE7 +2GzAW+ONIMnBuhH1/arlbc3wXHl6mIBcvHUgoHsZKUUAaY2kFNtS6Lwrasq4sr+ZJ1Hq0hCl9CW6 +NCTC2O+iNkKEALq9JO+0bBmR+fHe8ZCvQ0qKF2bCE24ngJqYgJccSNQVjf6iH49RUIxqNs48NOIN +GnzMmq9C+2tHXKjoGkF/mohsxjzQ5z7IWME4fi/pS647S0jRhmC570D1R45FQwEexj41PEDqRlEd +ZDR4UxFmP7syWyFagetK+gGiH7YLjbxLhQsGvOg3omMWI5EngL2a6jqsx9CQa0SzsJd25rIfuZ3C +fBHOQlDtRzFvXW+bv+hww5lCGW27uJCHTBKG/QbteiDfmiqh/nvZn7ohjBcJ0Sgenl/0BNLLcAOp +9Hr3o2HCNeIXrZHp8Zw66ZAwKDa41yckR3CQGCgM7eviXL8i1Q8Yq5X9vV4xhRXcExykboN2Ht3d +Cl2PdWSNw3LgMTmwAmfBVZV/vgm4I8YNx46vMtq931tzhy+vc/PIi70zFF4Sipup/JCTk4XGDBAl +WvmqDSp0orAQ2zpr7HXURL92iv2ZXV1IibahZ8993dvmUg3GiH4irtD6Zc01JWd+OrqyAIjLrLcL +Mw/2cQfVfq1DDL8PMZzsabLqVCO0ajIiWViUS4iIxuiT9dcIBl4NoPMpzHk4lOfBDMT+2ryj0gUi +gPlVv1NZg8G8TKvXdRIsiWHuKH6VtQsF4e+LFhWGF9Nl8ZzoqPEuEKkUp5hTiOTfv35e58qwxWLK +oTtPO4cZIm55IW+R/qLoHlkyV3H/6AjAnJ2qhX0yuQl3VkneZyU9Bfw0BVT8pSGZX+A5oLfTUuYt +UQs8lP7rpX6yWYFRmBC1eLBsbyx7IjgVu3MLRYElrQ6QJGL6cBeU6qpex8m6B3rmsuMZVT24GyK7 +8mZTmHTYgnYz6CMYBY3r7jCmlYpemmcdHR6z9wdtiOzyAqlX0WPANp7KN/1S7fDXrr40zUM8M83V +aOsXcansOEvqEtmcmo0z5KaGvr5qiMubhPLG/rD52nc7KDgSvdstUUAFZzu1iCtNBHVZjvlAuDLD +WZwC+KApitFeZhCv6Pg6XJgYgDZbTmquDhYQ5XS5UozzpgTfOxHKUiAGDUKMiPOVzC+ai/Ur/AlH +TIoUCTkiIyOCaoqhcALYslNja4QzmprEFte7KtbXXraFyMo7gn11vMUmRIW/AEwmXWFDpi2MMiDN +ouaRj+o3a/eNI8t9ZMwgpjTkIwm4w6tgScesXIkQquO2S6D20h8gB6sufu/lMFv6XmJVaYAg9hvo +fDok+zB7aRZ8to8rjnJmCwaz35yvr4DywePNL6HBGtuD+9U3exhdO4W/IYBILrE1DrRYT286aVSU +tHBVmxzhE++MZSFMLfxNz0aS0kP2RhJvDoHKCCoWC1Mz7J2KwAsKrFOmCOOlOxogi4IFg6sxIq4I +7BZxxeHwHJ9Rbh5r3MGeqMAomq1wBxNlK7yRCpcorke2ErDZOnoYDJrRw6jROpcMuQP2O9YTQM+x +YfbX/oJGoHZyYTmqRu0Xlkdt6opmBFs4ESiHEGEfvOFVisQ2Z3pCRbg1lpmAZsldRLq/FJIRDMJe +JZZKVZYJlUcFXtKIJKgCvA2U0uMamPcDuVVUzwXYqUq6X0hbxT05bgN1P1+Q+UtIWM6UzBcU7YRW +AI1MCWSVKaFqtLRIRNczkmqKAR8iMcv1lEj4zaHz60z+pn0mtHd1+rxNtXbeJu+p6ZpFm2zJKmGo +B20FoK0ayzdE+SJJTYl3Jp+g2P90HrhwOPZvRH9UrrlmTPulF2ZuJ4TjdJTIIrqlFGeterPKmKLT +BYk/Erl0Vn8RCCB7IvOKB1aiCilLJVGJ1rfbOC0w2bJUX9HiYOaCSO+w94WYbNEprNa0SaDKXl83 +ZUbr8OahHQGqBw0moeHx5rqXs0GJ/IFTWyLoTGtZrdW8fkdaskk6ABa2j/pqTCAHHkn2ijh+CWje +afGkluUlHUc8Hzvuw6z3lWlBlaKGX1fqU9MA1BPrm9eriF+jiC9jqqx4WRZxHpHEt468VRuNFaSr +zY6QtUnE+QYAY08EnVkirtcGgBYhg1Q0QIToERVNfjm7N0BOrhTfk5cN2AytYCNW/oCigg/ou3wt +l5TjdEpY58FNTUl6ourVJGPZaVFdENen4nBoZLgWK8q71BOoDkayOk75XPyb5IyCtDH6nkyKQF7z +mARYFuAaLBe7sOX1ISWxe5VL+/GC2JlA2j8o798S4VnLfRxQjeDRr7etKqaKvH3XFC3BD8o+CCUZ +DhTjQZpDOwIg+uEUlnjt3h5mJooVjqidRvztfxUGXM0B8ODhI4D1Ln6RiI1IWv6YmcyOEEWnF4TM +ONIv3x8dCvb7Awbs0IlnSv7BsAJYLTkI4HckcRqs5F2smDOsqNCr7+dNmwcAQdXE3WyClM6zeg/t +LEkYlXins73GeQUuyBIKbmUi67rPK0t1wQJlb/G+2eCTUlouIT55f4nJr1gNUjyqntwZLSsvuS95 +C0k21e6FJ8NtSmljkoHb0rfgOeWb8NT+s3CTVHaqhUmpTarRfFp/Q9FJ0tf+7WD7nZPaY+0t8xaq +ttBf9wPp4AREJzS/XZejD27qS1LCFYGxaOOB2dd1OfvihZCLr+cRIrUaAECFcHwSUPi/PdWsdETn +mWyX5Tl8Cf31qoQcZxFMgDNWAbZI+fbkdZ8Cwh7BLgdmVu8XNIcvhBn6fvwuPclm1FPHMH3osuaK +hMi+1AleQdUNiI6UAlw4JS/tnyE13cLDHvsLXq86iDa5bIjw8rvnceZK5a2e3XW2fW42FDCkjwWY +7JW8k5dqWvWo+4GGdnxSjt/ePs/hoIAgt3P0PDZedhTeREQVnEbPcJRWGal9jlMyHoM8KE/8DxF6 +f0084H/7L9jX/xcf6A9M6POf4n9+soOX3FcfNZynLmg0WMFj7LtyXSW+iJL7XKFuHHs+g6TuuTzf +SigZQdfBD9z70VemFXA/pyICb3squaFvVrHGmD23SGMG1gbFgOJtnbXB7Ki5zXeNLCSM6DF6RvPy +OIA0lC9DDKaUGPNhJCamYz8gEYonS50eR4Gxic4Yg0SgPHcEg0fakyMGER6j5RiZGhfWof51JkcO +O6rcz5Em1rAChDDUNMBUen/iY9SeA3ApnKmDzDVCPbZJilajfRzDHByM3j24HLfHOwJGYC/MpCLW +vSsbYZtq4FtbU98tc6QQ7cmQ2A4skEiRZ7uPaDApoRXkjdF5Da4jqIULOa/4LCmvREfdCdl3oypU +JFQmgf5pTs9GT82WEfQ50xh6Ku+l5gZeEBsxvdkGXYOq+rmPKLBK7Wb2xuZTsh+InaaGazvc+iZc +jaHrQUxCUHE5QoRyf8n8BzlcP1HUQVQR8sJ3vQzN1A90S5lZG4hQQmVH3ECDiRj6nUwWvPvrBBHe +gIBw5wT5KQjror9PhOg8xUtW7BnE0Uz6Bj3fRTDlPJod+2L3V+H9Zle6mfZe5qogElzmOgU1mfp9 +VBr2Xn/wBnuHcAfCs4mdEvVfue49TLKPCM+0qqdfyOGX54fD2AklDS+IRgYkQlYENgOqymfAfoQL +OJMb6sJ7mm9BdEbY+TtlAfnZ6s5pcC+IuSLFC5MAxdHhVdWI3b8feNgJQGXvToPZMmvC+1eIriug +0g8aFcsre1z7PqFYyZ8KGBzHmFczqdfJiQ+R4gBkp5MT4L0gbLhaNX9OeTGwDbpjaRLQFhAtFsQ5 +U7QNoGsrEYEaDwgHv36B3T7UYub5GgMZvB0FQn0f584ofUcADk9Elc8E3r8YYSt3CDPIiWBBcKJ3 +ojdo79K6HdiC6fFVD4bspl/EYU5HciBkeiwHwTR/fsDj7opJw/qVQPmMqkddHtQXhQzylncxeadJ +6BYvMWrgyEC3Csq7+qykgLOciHYiDitmHOLdx4c31t8U3ft7qUkGxtWhW7ezMX6I+Olp/YyqIAU1 +1hmkfb8NTF3xYxnsPDNgEaQoeFzZXnmfpv0rCBCv9InOEtwoRC1WACRZSkvXs+VJ5wZMBP0326F2 +v9ip7oM1MGqSSe/XWu4pdf1RlrgLuykRqOsQMejp0dNCFoFmF4ieodfck97v+zbxIfKAdCz7iIOW +lr57vYbw5p+zm8MCuO441gRaypKxbwkB1zquOvJlGfC8uhoriHAGE3vdHO41gdVfsjl9ZyT0SDNu +EdBveh2CGaDsnkd/d0Td4zMiXcTQ9T//nDPawoIkRNe9r9Mdn6xMPV4XS22CC7nS5DGUT+Qx9VVp +IUqNGCYmd6KYPBBFy8TjiAEQQrZOKqVKfdEJ4rc/zsj+1Ty0yZp5/svI9iIg7MizXuh0Ow8aa4h8 +jTyTVLSuBwf4PcuPFC/3M+koRlVY5Adw25ZsXU7hxfzolBaKWcuqju3xYSHSUn/nhiXmQjSFyb00 +dbk1TcGf7Q64XgprKLsxhjGf3y/ZpWhmOdLOZBY9Z9LJg+bferGvoxz8DYLad+xjxpU/VyJKA9Ey +8oF2lCSQemkXkZSCkAaWI84QhxGQjQ729VbVjWRu6BKDCz2jZpwrCsrQQM/BcC20Fe74CwX4Be2x +Rkk2puOTqv14IGqVNmBP/3JstdPOmwSXUAyplmsYyaxInMfpAwkDXlRK73i6kgx0pV6XDL/9fXBe +0GqVOm//rbDTl3NhPU4hr+oCbn4MS3X0eCIZ6w7McdydyP1ilcaVToTyBiB75U0jooiGBtkhpMac +KT0tWahKxFdn+7EkIDdSg/s+f75U48M4NRFILNPCB+mWiOB+FAM/t+eYklIML1OqpT83j7K1PG0J +BiK8Ekstgf5MqKx//NL86a/4okpIURy36lEnQCeik32SAPmG3gzySWRAcxyEEVkyQX2KZOr6kRuB +AU+QSi1IJVV4geeqyL5TP8mr7cU6MVfsv5BAutaC8xELS2N1iXiiQTw9jmox7dVwkxYWEfuAshAe +7+dPgdQAg/piIgBlFCKGosoTZrxm4GjDAIfsDHIvESVBKKUdDNToPndov2qyXXeQLLePiNRRT+am +d3itn1FUQ11JD270DJdYinwB4GZLM2IbjZ7RI5QZGxuKVtTWzubwROTi5k0GoncfACpTv1nih+Za +cR/NeyLc5y+F+HKmaPogIjSjTqQMKhHlbfriQWG5DnMyhznyNK3TYXNMQtF1g+Y6EQDlicDELBE0 +bW99DHIiID7PoXj8mpo5qqrYtUJjfsWJoJejNdjpNaGRQVosw3oGowdKXhO310oSkg== + + + kKpuIzr/u95iav+1sdKW3Rs0uKMo0AjgKlOspHImspbuXUmNt4XcAPGxZ/3wufh5m6wXdN3TiPiI +OhS/nRGC2oqfYFToyHCWaprB/OCZPs4GnrHMrsolBX+L+PMZm0S5ZiBhOn46zgFs3hRAJd/FZNIP +gAfwwR1gpNz8ejk0Oif4iMIiy0nEXutKy6V3hNUxvCjBPYasDcV0mhcps34Law1P2qzHlt31nqlH +LJHJ4eMsBMopa4qek8mvMnTr8DaiN6vXkjrSV8SqcllRz1YjsESNRqpa+9XQR4trMTko8zDHR6IA +EHuc2DTSUZ7RS2V2z48NZK4DNZqHdA7CHLDi8z5n6zyucBHPFbnVsYKallHYGTBiUjdz7RXT39f+ +1u34I+KQVfeujfvPeXO+R8G7EycEWfJc+2HzfJd3gN8qusE+IBA+6eejf1M+/z2L2uumjXC68OTv +f23ypsRlEbrEWNER2ccHoAHpMgPf/dIL/IzCqZaRzROrU0VsZiZjDlhJlKGuD5W5UbN8tRPqK2q4 +l70vj+EnfDV3pRUJgNxpRZEC3XCsBIKv/PQsOMa0jXZdpDu88nLvy4OJyUmbnkPCQk6+HIywAtUg +9kgJwXQpjEJnyh3o4f+BYrpPzxDrTr9CPdvtrovul7oPpiubC9jss/Ioi+OEu4td1d5uv5etO2Ni +nATE+xiECXt9IscOnZYF67pfzv4dPV8+lKGNDfnyb4Rq4dBURzTY5WLWGpYLEdGvL04RcviiSnv/ +cjAUILXy54glPIx1nxjYyHG55hmqVd2G84FmKKU5PGk22hRPpSgcXyjEjnYajBghdBdFUtOwLnBm +9MnYJ+uhAEC1mswn/igX+mtWSPCYGM/s1Acpqqo4tcC9ctsgOMx9XB3ZyxGngYeP11XUXSqIrd8a +tifcuku3zaPd4mwa6gwjTMpo2f9F8JMRjq0LLLB2CCnPdcR3MNCJTmlzn4O/zXSQen2/eOT4MzIy +yYQ9kWq3z3W0+XCoa0d5ruYYq/X2dSLyNGuF1ZMI8th7gpsrUuypv2B08eZBa/MdIdwLXx9+MEb/ +C66bXCb6SwlSnlDbsVtChQ8Yl1DBM3QymPLtsynAsyMQue1K6CgfVQYD3MMQW+2IdwLuRb8INT4T +WKB6M2TA6FMyGhXOT65wnVwBihuy2B2GKunbnY1AsHehuV1fGf8Wx6wdhWRLotS2hyeyIgigcDZ8 +6GecMXXPFnuVN8KM6VLyyAjnF+UJgvTrTGhCEdXP92HVIqr35zCvhyJNI5yLR3Ccezn523Nko/j3 +zPmbgIBcssf5SytpxrOZkaH50EKepxB1IkyW4hQYtDAUke8ByF8lF9kP8n06Z4maJ+p5GUc0GFGv +gpBg0w6y7LN0Za6SJZTXMnNg9EjPPv/sAgJjXfpr2+8cBLHzJ/TcbClorCRI6BYSChgTdOF+auQF +asJTjwnPM3/ZMF6tBhX5xKBLfG3cGUJ9cu4ClI7UkhNEeg3GA1NYrOCpwnaNz5zlM8Lv/2FY+D0K +mwhmLAiUTOyKuWz0RR77Q4owEHEnQiNMvdXeleLbhySQTdZDiWyaBGSHxUiSdmssgFr0wAoyirDg +HRaBn7KyeWdeRrztGsVyhrkcFqkG9ZUgkaOsz7HjGwW6cEwgOAA45NJ/iCgjU6l6mQ9/NR5+H6Wt +yIytiITieuw5duWl18C+yJU1pCo3NNQW0jvwOVO8j4j32Yo+Bm/XT1HMtqfKArTNKaQBFyBIi7/J +6of6L7ubqb2UkufQqfZFeZ3YykHp0YJh7Kg4P4y4CsTuenIYX9wr5Gm88Ir/vByM43Su7n8Awnwu +mfydwDu4Ra+XwThRcUpEHxSdHXE/kLM6MOacR8IOEWiDEZGnmTY3v6NcJ0Ha36S+8mai3eIRdLuc +a4cezbXoAiAAaZKx4rqFWBweUHmR7/Mi3+0zIrekx9YMxHW0ltZBaBJFQoLaY5eDoEmdX5TxEpn3 +mPo/fETUAHdF0ryqYJ9RSBJwa69CIqUMFVgctYju5L7JUJA1uJqSJZKAWcfxk/+IyDUj4+42P5uC +15/HuTKe4Xt4k2tWeX4ySdlHgONnfhDCmfPFYfw+CA0qhlx7jd55La9NOUbsIH0Ls6J1ujmwuMhZ +WRajrbc3LRfP7xHv+wm7cgmBrP2H46BUJteO96Blv1DfDKhh/ynC+qnE+mbV8qut+oTfyTgsK0qk +yCa9kym/84jTITs9FDRX6hNWF8Czrug/dtl7bSvjh4hcvBJ4ErgVIDWfx3lFP6FJ9zff6lfyLfbi +Z77wFCSKQ5vTLgSM3KvTS5T1Uou/Jf/3pIGJ1pp2NXxQ4Sbv2lqhXmo6DW3JKHkztRAZsRB5i2ai +tL17UPZ7chzzfYHBI8fp/gAoXAc2mToGxvyTXxAhieeYKcFxlm5zsyK+Eo0lcsjI7nsvqlDEqHFO +XYboU9kmMoW+IHdoqVN9Ex5nzPcJqCdg1a8spalMzc+jX/E9SpUHU8uKAGRR3lvRMLRpKV1/iChB +q0LdfhH6n1FdQ06+AR2Tx6SFNAxCgWmhovbNH4Kw9P4h0ZNFmk/UTIE69aXKWbOm86FmctVppH9+ +9HNyq/ptE4CAgWuoAewyBLy6g3CyHid0LyveKJB6+NEofninuV545b0j9U1d5+2jf9vPVbkRW+vc +kZo7Mo7GYFohFcbOSTHgHVprcFzaGChU4kFb0G1E6n0XRtYGuzBaWhahTW/DGRkTdryPiBFg4YP0 +1nzLno8oZURHZEQVQXSO2DXSQwbh05Sn4Uvz/AuWPjL14LYtWfEnSm0bXuNbsJoynw8tRx/SkXq7 +AEVjIkQHhbJHNU2v9pLz9aezCFsYjqwnPHB70Znurw3Z872/7sIuvgJptT6wpbsZbb4bJFtEXL9H +/Pkd4mm0Ca5KldPvx7nHS9/tTfXQK4MmsraLXON7wI/b47cgdpOm4/AAKUVbocYnl4fjviSlyjmK +/xxUvrFzNMllh2RM+5gf9qczxDijBU0DZMpB/KGmshfdMUWF/b5oqelHjTsYYtKAmhw+wDiQrjWp +xqQ/6igNDRF0Ujoz/ZjaX+ipd1OK4dR1P38wqT8oRh8R/3xaSK7c3z8culsurJpYtI4GMHUPGsB4 +LKONTXtvKXdDQQXvuDNHQEWpvN5JM8kVUXO8UbRymozlcxzbZTc84RMxT0SZJ2Imgt5UIkjjkKt+ +3rYbCWMIUWg5Hx70FR60ZA790f33GFZbjtT8O6xSJOHXk+9YaVuwQO814+v44jnnLtnnkxvzyINd +QcYycF82RK+/GSou7CpFAg6lJ3d9giS8j2c2+qR4Zh/Fa5jIoclhNv8WRLoHjjbtRdfDUL/n8Gfz +8Nit3g9PjaHCGewhSAX8FUOc9E73I1WP9TBRoYgwbb3iEzURDwKphAcpETANqNQOJZDjPGqB7sNV +I0R74Si76tdxNce9bWL4mdqEFZUqHpkfAtQ8IydgROtRxRgM9u9j6COJlK3qbeAiJ8VI7pZRteQz +Vc0LMNRkBoKiJG8p8Bth2Hc4tI4EerK7Y2ZPv9kn/XZ0cPvSKl1SEcjjXUBA1VlCpAki6GlfnMIC +GN9nBHbXFMfI3rwjGqM8U4UdoCKUjef9uIPm9FGKSrvWPb/Vfh8I5C6ilXPAaJc0dYJFEVVa/oYG +DjvmGq9P0BWxHGjkGouCXvELd3CI8guPdQ9JyLiD5DTd6PiloO72LPckXmU1qmudB3e6v/b1ysg9 +K/NDXviMqsFRANVCdRxgBfTurpoJhUiOYzOWCPQbSDH9sjurFdnGIQRJVgSBznnmMQzgSyCFQ+9M +f+J5WL2AyUoOH/VB9FTIcflTHjoi1GUBsqvIDYX/fH21nnC1cViucWOA5IBMVpXMzcMM/GIOgONe +0hvUPVQsNERhWJvSzgPIIwIINxe9vPQsohRfgRGlT7NRI1EAr4jo0upvjbOMUJ4Fdb8pUzvmIkbM +fBPwI/tzFYre89BBIUZ6NFFTLusD6bXnPCXqLTe1a1VZAwIkbK7zTexsTUAn+aqB26psVb7ujLSZ +fXknI3C94Fj9ZNj3WCSoWze5Z0+M5hUlgraoYQQRYTfwaNH4OmJvDVraO7L9OA6MV9uEDCTOrdaj +CHEAygwo7LqN3GdsM0ub4/3n9PJn5E+AX0hKP3+CYpH27GWmRScRHLQT+m+Y9X5EqA4GT7VFMjgp +x/co5DNpRjQV65q0eOfV60LPNASQKB9hbCMvfv0Nqu354M4HXz71rFY+LvDAr/nDn/MowOgdPTmT +nTUMX78+WGlF7UUVYaVfD9AMs0YJsl03IT8ueGHG7d7q1z47z9MLMZ2qHN9Rsrv+4jIX/0mpcdJT +HaLnfCdM6PwlQjgPIFFvpWKnOVr5orQna/HfADPswwFL9q90UZqUlaopHMgmanpCn4iQkPOMSEmj +3SbTHcDcNb6+rjsMCHml7/avDc+5Ihe/vArDnAG0yhWOahjzEBjB+ayjPPr9g7w13wngH3+Od+NR +wp8AHRSKosPZyAeQgfqI8D6O3Mfx9gM/ouDCu1xg3OfbMY7a6xP7B0mwyCTRxRshuaOe9aD/+wWj +oa6MuC/K//0zSiSV7Kn0z7zUASitMPgWlmUqxUASIMVFY6W/ulD1ALH297jV6TqsFvSDo8FIPXYL +5qp19B8a3h8RY8WIiGb1C1lOVHcXhYohuHTYE7k0Roy6UZR/RAAGXKYkG+DT/RP2aVPCzH1HQ+a4 +XrG1/Yvenuk6/pg7FV4klvqnqCtXZqNhRwS3iQjlIDmMLK4eAD1J9JDkcR2kP9zf+uv469U+JTGE +czFa/lyDqjnVAAmKV/w9S8U6J45NxpDdosoqQ2mkDta7KkDEo8LhMexupkOlhi6R+3b0OZ2TACkL +7Hs/i+pzfI9AJvTVQv7+oSQnFaf1mJjyw6yLqHMv1ZJrMpahbwy5UT3SA0MB24+AbCIt/lbUNQg/ +fEQp9nPrfkFnvu2Ipbjy5wc0I5+sUHvlfSUSvkV9SG0z3DcLQ4ArnI/7RZ9TgN1mefdQWWdONV++ +R3ytIZiFIQ3lFObjOHvfU3IKguvdwqkTSDiuoLvAmTFKyOXeiTWXe9+0cwJ0o2Y+pLcrUf+g00RA +UofkuCXaE6TtQ5Wf4myQCBXPiEB+g4hRvtamkunLzIiMIO07be6uHCa0xIFKUU4UOl9xSmyEAOv9 +QpU680scdwxb/K+R2H1ONFlwiiy7EXcwOA+oHtDgR8C7HZbi7z7gWfUSoHfyvE1Do3Q4Rkxt+swr +4N2hNc9oHVkyjipjciSF6MjYrQPzsIhVkLF9RqRsCNgODikKzz8cB0rno7YVk9nA+6Mbustk6KtD +G4qhFnhoKuAo5iGXYuWDxBk7ESIeqqLOwG+BR1l5xiJvAsePoGj4QbuGRH0ERI8NElqIgmLpKEjm +3EUIg+k/HZBaON37dl0tYqBqxDDbQuti/3mfx5+K9h5Qazy9QvW/REExYD7+VFgsOw== + + + Qr1fnYV6CrGq7ckPx+lHLil4n3HwvUtwLT33HyLKy3RFevK9K59RV9SYsRacz+Ffhy5eb4Wnr+Pn +i68jNC5/0zPkcJNreNGqnlv7rbnGW1bfmejxy1GwMkpE8gTEnOOAaQPlWa/YIkfKGAvQFkCe/lYE +2L6CrhSaGdq2v5zXZFlz68Roz52NlPz5JCNAT0R9HjVcwmM77rW/k2GQ53apyY8I/Xt4KFJiTRFX +usMBVqEbSY4ZcOcMivRu7zWNQu6tQ/dPEXi93irkXkhKvijSb1HjOAmwg0CLe9Hi9GdknJT7ODfw +kl9Bd54IkGPtMyJnClxW2YZXUPjbca7DR2S+qupvC0KKrKDYSimHgYqurjyj572/cIBfMYwS1BpR +TQeIHUWHkyhYAn97vs8T1phJbXfYl4bOgKlEy4fxHEQiJzKwpEsZnxEYeEw58equ/0Xr6HdRC7mL +fRw0WunqD1V1WQjYpllqFTitbs9CkTE1BWNe7l8lksw/1toBIUJZykNZlT3OFkOPHEDxUFaxngh6 +GJ05UvncaNNa/h5VSjwaOloU6keuWO+tmJDKLCAp6mqC0rNtuceL9HbMY3AwYnAwX23Ro5G1pqYS +8vDFljFOa/oxlQgXARu1xQDB2LeUVkd0/R+nwqtIkVTYX41cORdfIA/zQCBBRVsARGDLfky45EyK +SQzppzC+pf6iINRKeu/YTGzC1Cdvu5XzQ6oeLm0P6msvhdqzAAVZYRgiPFwVgZd71LA2QKN9X/BH +L7v9roU99S3iBTUFy0Fpw6P3PQp14EsO9aQQWQrmCnB4P0Cc0Cn2I3Aox30/ZMOnI7ur06pzLjaw ++rYM14CIBCrGiMy00B8UmzUkaDG4K0f1ucIFafPIGt/KgQGfWxHsnCJU9pr6NwH37kwZWlOrrwcZ +AGxgxH+IvPtr4vxk5P+LrPz/woNdv9Ga/kuivf/l3+//cv/2X/83v/0f//u/fLLy23/3P/zjP/5f +v/3X//2/+V//3T/909//5//4d//m//67//nf/Yf/+Hd/+sf/9P/+3T/+n3/3P/77//BP/9N//sf/ +5z/lpD//xf/29//p7//dP/39v/+7fYrffbnn6xv8gXjA/8L/BowGO0heAI0xsARITO5NSd7B+g1p +vGo7pdewzhWAip1cFfb5mypHuN8CLAGQ/hvFFbI0X//sXw2bhfuJnru4/lGyAAkAlfARC9S4FMF3 +8LQt/WwBmQoFLNtsdVYr/29RyoxQ5O4IoL9GBLOBGRxELHwLyuUxgKYZMU7eysIiJE+weI8QY5RU +YTRVLUvMFp+zuIMLUvjv7kLMwHlNGQSXXRoGJfeZLoAFUzN8xwAldpqiGh8OMwiOGNEfI3ZaFsXa +MvHSPFStHINZzD4GlmVOZJ5z/Mi/8k8KcFcF2KKcqfvY/qPHSTERtwsyPP51elnz9LKAVRPRu8eg +F5MTjB7ZoAYVnfECulaqoXWFAF0rkSvdZ8Xz7/nUx2KNAwxIq3TniNGVFXoBV3CdKZ6WvzoY0JMg +69XcaD+blfRhxIJAFf59V8e96gtIdvdn1wILOoKQK9FhqggtHDHiquC2mv10v3uA4IidkCwpwAYz +I1pOjQvjWqaTOqTOJ65HtGEQZYFZFMg71x2O4XUqOaJQPSYKG4dEVbCIc5ek5zi6HNZIDfjnz8wH +Q78X1FVn/jRMDZp6Bw5mFIsximWiTxHe0qlSvdIchh0dv6DhojwEjwiraff5Bs4U0Kx8At4/S7EJ +LRYakA6FjwIfBE+Krp5C8GDI2U/7/kGB+eGzpNaKrKCBQOjd3n/nqMVm/0Vhrcrg199g2gUAYIhw +DMElgOpHJtYPEfj16Gxt72ic439E9XTWGT7u505VGjyGHnSVyHawHcRRQ7N6KNF0NzSZ/P6BJ6BM +Bij/8VdP0of9q2c2XUyHyLxQ7qX3WJ4YHwr3LXJ32v16u/ohrXL62KMnKlrbj29z/pzJ1KAJuaK1 +7VKjMZBfoQUKpvv7HRUxF6cik3J8nanhu0QvfBytscOk6Aw5CCAtJaDVFbyb+R8BzzSAhqu4ttU/ +Vb9zmiGuDsWdHhm4K7MJbOShu9laIA0al02bkEs0q1hQg++fIoZVG0/wrl7fW/I9irzyBihEI9Fe +Tg2sniaEyElLZ2YMHWCxqTR0q4d8TwLMtwDPM0fsKTTP4L3/fhTz+r3EDRrjrNFgPRjaFAQMk8d/ +j/jpIf6IooNWIrnELgEUGqk9WD4xMpBwzu+YwXyjySTE6GpvRFe+8U++JC2IftZ6qRwN4V60o55w +d/YTjQYhaBDlPfc6t6ht/tnLEIYKH9LfBSpimeAH7AEDJA7NH3prqvOOQi20v95l4SNmceijqaDK +eXWvIxfV1aYxyllGdeTe/XOxRDsHn9o/EkECL41sDSNggBMRcbHnuNnsiL0ornMmOjNEoZ5esp3B +1WQ7Y0P2gWEYzLv26C/Cto4EWRXwEDPHpXsZeM82PyNcREu8rZFaue+fjkNjXVh417FiqJPuNoTZ +WvIVlXySrlymPNqT/vkkRoHeA3tk8knaM26jMAE6VuLLw0A1TeoEvYbUCRLnH6dgb2YefYFmPe/C +hERkOFY03CEaYA0UDg0PNs+qrVaQwpSI8W2Fcz9DAjO/Qcl15p0LQnfZI3TVYqIvLO6QD46+nEtR +JaPpRwgAH9RFAuZahG2xHb0VXB4WgXiT3v1dN9tZN68cH1FOgH9MNM6ZnkCwvbgt4DyNL3YUY7iz +jg/ZF0ypEgGmgIi2wttABuBxvJeA2W/xgwq7e6LvpgpgUkvQYcPXEg5zOD9TfloAm4LVblqly92I +Nj8phNwZv9tyTeceHVcauDN4f++36tbxgTYeX153qCdYUVJUV84VO5AB6qrqyBPito5B+73d786I +xUk7SEs+vB/9zt2ypL6JGtrv/91CJnD33B8cXPrhPdU8tpBmRbGSu1F7VzVQvw6PAS1BzcSJXhg5 +fqXdQ5GJEFhX9uMKNpcIHjoihHS26DPoZJTvcdDvHcrQuSGHl1dQ6i/JXwJhv4YcYI3eIbcihe+3 +HUnF6nmJ//gd+dN5p2QasDXVysIdpTrVUpkYoiL1DycKX2H5CPeInB3zaSZJgIA8DE/9PgxymEYc +aT1mPwaA7OLfTfkGQ7qT1PAhYqz8dee6EaX6CmnunP343c/jd9/GiSDV3hFLcsb4mydfX8tJjr/O +ZJT1tWhtSWWhIlY5qSPLgSswi//JSO2vQOO94qDgpgLoQcnp7xEpUEpgi+1WSvCH48AuG3oHLr+v +WR7CNxhqtRldNvxfHo2KyU/mFcqalOs3Ld5RGo7SQWCiQdTNUBCAIjtOO4/2fiALcoswINlDtffO +EJHWt//ORse/j4OH4sP01eHSlpIoU61bdqx/nvplf3SNBDBUxSOtxQkSq0s+12bDX8EOyKDwVciu +iHnKV60CfHfU7SCa4QAYFAaaBQwPe6Uv4gDz7+i720neF1LDdE1HX1ADE+8oK3N+0AZQGDS9Qste +PdAR+9/G5JVhIEMCTcmAqFH9fEbgCuvsBQLSOdNHVD1w+a7K/K2hFhaTIKm6FnQstFB+cfGDeurO +V+XnIR5QPiPym2LWyg5dEX77PA7O9iy2jJ48TEnStY/ZkZz7CAD29t6Kj8/G3wTD1IWVq1kG4w0S +ZFXnaTjQ0YLW0RZmaBq53tU1OYeNgwFRgjro503V5Zzf+3nLUbTnq0dt/96bDrMkzsLV68q4jFMW +TyPkr71nsW3YIXw776vHKfFWAMzjwEZ5sHoRPUMEnQ0inpUzNblGe4+xpaI0AqOUGzvek0m1eh5M +wOgKtHAXpiJqyv/TPJ6as6LWRIOHqyySYGgU+UOEbHYaYXCP3pztM+qJ6jFo43nuANxSvdLBMHux +nP1d+NZV2yF6TO4f4FDxIyKrVgtHuAEGHc8Px7kvxT8ebQcV1lmR5O/wwscPAQ4+eT2RBjgUgh+i +oOwxA6SFwoKM7RQI1MZOenThgFejz1x4fsYMDhyCOO5eZODsqH86x5e30Pppe8M7y2OwH1qeC1BH +LEtYWImS+HhQ7ibMQ2eUdaw1vTcjaaknAuSNxgdaMZQEtbxzvY7E0YjHStXliDcmo8oM5pA/p9n+ +xA0arnHRHUBT9UcD8sq8wDMBxNV+DA37coZdigQPZahS3VypboB7BgHjuJMGd1qBIRHuK6phDhNh +f3NViOrsvZd0GqDRT6a8Vb0oOF9XgNEoRfP5eN4IF7qKkMwwIr7NMMGqYJT95vavw9Oq58+dpPEd +aHf1GoyjASL+m3RdI/TViO94voGlDodgzvShDpo9HtBq17SoWXmUow/d9YG0yFIGvDLypLV3kaI4 +cAN/Ean6fz0XeisRCNDghiFI9wY88top2aXHOyyBkawJDIbeiIVGxbKfYME+dhUKZgGaurr2F9Cd +mbRG8vzema+lP+ql9gZG9L0Jwzls1x3Rvpgz13FBhaY38sU1QSEIbWz97LXI1Hb1SYT79sUUHubM +k6qEiFWSqdkB07j4dXwlKse3skaatCp4fCkDzTd4sJMkot8KHqNqX41Q9f5CXPTkkChGE1HKeMnd +1B4oXjVQStFvFJePbG6YOU3zHKx1O8mvFu90K7F4X7AVVndoTolsg3dX1LXN9wT3of4g5tmTqZX0 +IHmcuieoGha1WAV+ZAjOktib9gXt3EYGyJNeKYKm7WWYMazaSRRRqOoaleki5vJUOzPUE8dZ1b22 +HWlesuyaAGpwArRphxxI0x4Y9vh1mmNdK4GIVwDHED9wwY1RaXaskfOj1JPfIQMt5gGRIL3m1zMV +lQDI9nfeJzN6Ohu+uaRm9DDhSHdRMD3mPD21/Q8RAKPr/LoTv/8QvSfcE1oeqRnfBGZ6Q/NflE3A +ALL4Mq6Gk2SL+4KLKvz4W4Tn6Uu64UMOOlr74Tgg9lGDL4BOZoCdQt0aKcORPgOTjCbIo1Ptd9Si +9W0v2kw9SJVoBXwfHYVGO6RGsCoFYtUiT38awfkwXEH9wwNzVI91hZYu3yMyaaXSL8rVarDweRyE +Yrz7+7UYM1Y5+xpRbjfNUD8jvqPN38fr91GqLWkjC8TqiQWzbtUY01yRHBR2SpXODtKP9zHMlgww +fh+Q4vqJj8B+FxVl/DgK8P8uXx4xrHYgNcomN8ctHwEMh7VrH3KJznm+Rwnd8oXaK58SdYvBVkzv +Obz+ayGiOiEpTtHaZ8T7tN12U+i53OWH44y4WsDZu1FUY8NzyrG3nFtS8Ahs8lHW50j/B/7Dq3Gk +VI1iFZIPylNLh0sEEUo3rC9E8H47BktAXL7RJKYo3wFOLdlwqmi3vfbBbmGhRjP9PZHTz6Kt1kqU +jJKGXvXwOEg/UBDh3J2IKDTeF1KBRJiQUpqW85OSOLUoPOVMRUYHvns73+lZUayJaR7S+hgI1uAy +WvbC6OOIraOyuWWeh03Tad52zai+BeQmHSD4xx93PSa05rxLEvTYRO93RhroZ8QVcw== + + + VjBb611xvgd9QyHaErQRxrq0sjQnFRkYfPAr0Y7ZP2InsKt+/zzXaogwY7jUx1F1/t0xnsw/Lq95 +vml389hPeuk/RszMETvZyNc9+R6F7q7Ay/2EPne+7WPzbCd9Ipn66d40taxWOorVC4JISf2MeF/N +tAfRDq7jh+PwhCPuXcg0KBMg4vzwz9RVVS4YFhtvn/N71HVsmNBLL7bv2nn8hhydnUFckQRCDXG5 +UwDIZ/XY/5A217eIXLIVZRUITSTen8fRqlq5cQZj/aRj46Rj/FRdz+/jrv6Clq83tahSlp4jppoP +g3VhOYxXvAp6KPKplowJaeCyKkEbYYGuWWM5x8i4lpHD83Umabd2HklBoDanoWJrfH+O4ygbxgPZ +jc/tDHbkha64zUOq9ghQlFWkfRt/N6BH8hEKHdDE+KlxT3axTgK7//zSKRcX8odRTTFpmYAIG0ru +OqJH+bIr3/kZkWyjyEUlnaE1+MNxMNdM6hkgfaH1B2wVXnc3F/8esUq0CbRfa+0rhf0W1SNCOTDh +vpMK01qht2UlNeKKxy8Bgc4vmf7WdbyzBmveK0nF703WdmMnmiiB+RW3j+VxRjzisWyOmLBIAsza +nzTVHjLjoXBr+zqumwF/RfsRYSs7bxWCXf6a19cTT7/eTGto6Ct1boU/nVuB+joRNFt2xJcGHPm5 +3QB9xFZuOh27HYXh65RbH9UtK6HHobnISsSHpyoY3yMApNGY2DsfyO2c6TOqxOdy4NBwpwBjNkAS +SrL8hY2k0HHYShMD/4X3g6/H9h448zAJ/ou/cnRF7bArBfrAfC3L6YGuPhMBBaQog3YKTauCH58O +617M0P4xk7wvDXfBRF32gldJW2W8VmOjKvPHosxa8xvT4fRZQYOCtgCSxJfcKcJjK/dbwJ/fYZqg +EAqX0X84zK6SHU3b5KDxddVMvChaVGj6iPhpT/wIQlKFsoe5QpnHYopu/t76Ue/QSyS+uxMIX+Qx +MUVELGxokYz9I7zRNjJt9Npd8x0m8EoU6VXtkX7HfhV5TIXUoBIJMAWjLgmORqjjhpqeIBZUzjWx +oxJ/TzlWT4vmlvHvbFcte0CHEhaZE4Mscu7zfH3wz7aQWtZu1rT26zNqDjJ+WDzLsrPOlEMAWycz +hftAIhtksx7Hqa9+ER9GoVOQ0/nw1nIGfnf+3CYZ2kx0etu7lBeJNiein4jneAdAIiGCgvM9k8op +LXr2sa5p3O5dP7Unx/FO7ojaj43Ooe62aXuPiCK/ZxcwIxGaOPYjUpkzcXrWnsb8fRoVJnHZi4Fe +pEXlUyKeFqV+DGX498YdBiRWVuzEruNHkzrzSZ1px1/5cJk0ykZJ8k77dKoY7QOSR3Hh1Rw7BAds +XX3FQHHV89wnvPpftO5D/lrpBPNt4M2B3t8Xi5b+Xpp6Am69zDQqNMJlAqrOCnpt0gbZ13e9uqyS +4ugwdBGTiVJcdUfdhzTHgs3n8woaOP4Az60UvqeJh8J+aa9QBpW2aE8S98w6ivQoxpYXeRiJWSpo +3A5LLA5uoPL7kVjVKzgj9b7XVlAEUl0xRwLCBx4n15hdsaFjW86daREi3OsfgBJfXZWZmQaLoqSk +CZsV/ZjhcW2HAWJQqP4zYoXjAZrgOWzPzyisbCCt7IUKnApPUACdPJNqVN2ZcmB057xulqSrMDKs +v/AJK5f4bWRSzzM8M/eDx2gXCGdlTsQsR2OfvZkMaOJtLxb0g4HFuDKyIdBHxdXVTYofCP7Vaaj4 +zSr7ID8JM2+hlOgHGRNxtl1VMsXgcyU6WqEreidiZOo6JAipohr3WBynch5RqPtn1MOXJwqtCqLi +Vum3OeazuSCltXVGsgxX+QueQ/6CzsP+9yi17GNCtc1hr8NeBtKwAlWJKEhH+6p7ixAuwY57DaU0 +Rkaf+7lhxwpTHH1HbZO82CAjmfPbYT5nwo9o3udDtDpwMdfMt6YFSlJWKXQZcyNshJ6YjaHVAorB +FwKUnF+BcWxlPnleyxWXmqfqwhpZsjw6o+2b++REsNg4kSZRT0hXfjV6XtgCuZSqOGL93iT2vHfA +PHH/arn5T0S+oESLv1+nalXWY/7FBxOArr7NXUBUhjPnw/HErKdhMFhyPx8RHDvF0BZpALyGS4aM ++xWskMvI9w/SkD/KmN8/ZHNlW/7OcX///T4smv3yrZep9H4GaV007nNYv4hNiPDo2pT52zUurbBa +EOyAGUmnfO8550X+FpF7diu79pDroo77eRxvPVANXLnZ1HdqJwhGXb/5UwD6BC1G9a84wGcUDtV0 +/JtYlHjBk95HmTCOzbZHRWj6tO80+M7dzApaaMPPX1d9VQHiTQ453geaamIU4kPdAgpCJWDUEwEa +rin9wOcK+taUU36sXXjRWPPrNGYxO4jxU76MO9hOdr0RHwDsCSqSxR0V45UTxTpU67c4QsPWIGK8 +RFGibNjRl/KWI9hkV6AG3ssVi0ewdLoM+6z0yWPyQvQzhNolqPvt94jcmu9p28dx5gjksEEvHn4V +Rmn7qyAtMz8DfAR6HoHy9fp+C6I+NGHdRcMY59vO8235ByaG4zoTQ+VBcQXg2tKDfdpnxJ8PBC4+ +wxCbfwgSDSUeG6pBdBHEGWE2iLycbrqMQuCbHyGLDyNU4Eq258fh4gCCmqK8GBjW0wVXOoTp7k8R +iue2I557/I8+o/D/GQczhT5XiQmhKK8ngH5rmUrJvFxPJmgMiCBXf2/yCBVpBz1I8hql5j7yH1eU +xlB6hxfQqvtkDdS64oqhoOUINH1HqGlBRJRjm0q+X2dyn8RbUrE2yFkkkdX19fE4aA8QMZzBSYWX +/JDKyTM9qp7hFBfpWAafRFxzvfCmUGwflDBWdMW8bShSW81c6eHvzAzpaAup45mNVuXzQ0RdoWeW +fW3q+UWfURg0KznocrJcbPVpoSWogfLOBOyVz+jXKs6mvNn3iD+fZEk58mYVUn84zi6MIX+CJND6 +R3lItSMBdolA/R6BJHj/wiF8+6wEeIsIZBxFuzIjKMb4zIBsPIhvXmTfEefLDYwfD/O3gK+VBL4K +eDu+9sdRkIiRpcPKN6J6Tp31QOTEOcfdZUgAovHVzrXuudavtzhRUJeJksNPFErCREVnigias0RI +wem0QIoR3eedM5nTPND1lhGmrLqvvrfG3W6e3Y63op92YWmqGHocDABAyj0Kc8qWBH3e7KcaMX0u +6XTOIE0vRrccox90NNcmZ9KcYdjIWAqcIjpLJgt0ztQWh/eg6eU37US82KT8HlDXuSpQc46A1UeQ +wryABC/kL7kw9ykBLhunRyB6RSBabMd9YAD74Vy9ts+I1BpHAJTFYan79/04I3xjZKD0owBwj2Ul +ZRRJ8gNqZVxx65ZOgg5Mfetk7KXA5O3i+hJGW+YhIDxP4Ij9oLzJ+vp9nNRvPVOm5CXsxHWgk5p0 +y1uZpxvFX9dQYhauWKBk9M9kIkaPDFG2fmSrLUhBwGit16LC37FMf56PgOCd5sGT8dJf6/MoGl+X +GF9XrWVKzkvGJEDqI+AO1nvXtOOeL67qe1SNj+JzOm0CrYTzgzRAJ0veE9klTb6mSy9CdIDlCjVc +IsoXkq4p2sCvXWTzfugsEKXumuthc60zsS7lSJdL7WJRSkAaA6D/wx4Ks4tiaX2dR+cCgoZfs4ej +BiCjtHSr1ImFxYZ0MhFxG5mPZDDvDEBr7szTcgxbFAUB/tM/tf+DK24/lFrVUCFDyM5ob5sPWOQd +x5I4Z+zyDBvDHyJ2hvEmdh8f8nzNWCELiyBd14QCjxMqEzxOdMzFzsaIi+S8f0bkBDN5YXty8X44 +zn7NwAXvGh/fPb+fECr9LZ60dQ6vc5qLfaDlfUHaOvg2SBXj+Yz62/N9MkzcuaTL3zv43Rfgir8y +Y/2YbE5XHBR/1PC+2dqfnyJagEcYP/XygoS/R40rso4ocYGuRG1WcsdAYGN9ytiyYUNoguC9EDf4 +UeiWlKbQ98GWRGedD5nccnij1Ub6dIR23Q5o137xyg8R3zflNKq/R6EsKZeBVm4WhW725xjgDnfA +Cm5fnv6ka5I6QauLEnn8o4oqn67lXtDviFkXMDRyKPo9IBQaMt3oUhGA5YLchJ0rBOdwxwlkLwi3 +wodK41iYBN31gkRMHgtFBVUGsm7QTXYNgbGIJ3qGkt9w46diXOqq7C1LDuq/PTPs+LmQJF/Z9ARG +MbrFqha9arAe6FU3/DIpAEL+GcwVkSXGxevz3zOlmeliXFSPP0UhNuCw9sEJrkUOLHbsCL1g//cR +AbqFQTgIhVcP4iOoR3BOnXANJpkuB2CLViDfTL7ghbOI0OujXti7/bpcZ5R+NJbZNU8ZB9isC/YA +86lLCOU5LiG9tkioRIVy4sP6/PbHKL8XDyjf/5P1XmCh/yXdvB0zD9JCuDTaEVGFYz13o9D7DydK +DBBR8UB7bQ95m3sSeHGDppcq1s+wiAvSxccJKULKKCrUHMM2KK29dyjD8mJayiy5xeDsYP0Xoqyk +XsCtmSH1yVgaVm6NT0LzreiHW05HHslz9WGBeKMAcR3MpFFHtNb1bOdEFyN+zQ+BIGN+yDDJIpWb +QJGqivmOoPrhOZ9Dkf/jV2oZe/06ATKaRHUBz0SFOjiLPkV9aBZLhIo8fJU79ouDwfD+d+Rp8gN0 +AhgQvM9wlBSICgPPhiGTnbehOc+6yRZbby/GoSlxoY6SOpjoU/Wk+Fc5+2hzb+jHtRngC9YoAF8s +SgWmdOUr9iodE8iqhxCDbhZaZGWQjeLF6a7gj3a5Ox5PoSOcr+md1JUzWJzAbhgr7p/2lLg1gQXZ +S0wgjU0pKP9duJiyt1NQZYAAVNdCITD8Yzmstq6/RruyIi4WpZqrDvTKP1eLvir45QeMvfhApuNV +VQXwA4f9BSjh/DUy9jD9NXcTpZSvZZdp38FdtvUTMdWef3RfQgZQbTluajsRagLvE7w5lTBbEi9G +OoDuKU00Si4gj+C8qWEyxVzg0xpWIG0G2tJM3vBKEuk6Zli3+02ab43OaFyy9E4zSvbTkcLsQgXq +Cv7AmdX+kpcQELQTqcEv6O08QYwgwDbtx2cIWbix6/plu6QNAGs687pr4oCnfdYEunjxhqpk3zOr +lvIEh4b2OiX5/U7LF8TM97CH/7RvWsxrxtRhe/+6OYAfeIF1K6u6sAphXDcP3k4x9JpgeO1vh/Ah +yJF52Dh24l/4DHfBCwrVSsxkFHAxZdJoqwRGiOQYWl1G0Chm7CTkaSFacYnxuDS55DzI7zn+eV9l +kCDichuM3GKUhEHT+pYzUTYR0YNvW8HIX7J7TgQVM8cQ07fCDokT2Po60RNVw4HvkBcmy/hV6oEy +2yG66LDz4LT8INQ7wf1xw80VLnOMwOhCmGTu9mKy0ewDH78vN6hBEYZ2BYpM/X2nmU0CSOM55WXe +mYF/UfCIvtANurxlUtOsa3B53WWpLq97Qzk7dTvmPXvlAkHVmCeQ0e7s9YZsx5m4aQ== + + + nIl8JRdquLvgClV86m6wtkiqj4CtwUcAtp79F8jcRuz19pnW6wQLXVcEdgmDmoZy5TjAP1jN7xnO +A/q7Kr8DjKWovfDfLWe5vW89EIDPponDy60bCHMadlx8A2A9XJgSFZEtyjTyZvL2/7OHaWE/XwLf +R/A1euH1eyhMgL6qOK8FMDfHActohF9cO11+2mI4d+dM/tb97o+XRYFhrpnIXkPlKvt9WMcxgblz +nOBKEFwZweLYtr+QOuPKE8GthcXPUG9/gDzBOUHPMJPQxSWHVuirw/CQlwI7aPZRurnx/3U03hQQ +vhQ73/t+lr8kjg/964OIiw8P/1aFuCLwegn3tUEQ8rViawhDcIuhgYCw3qtYjVPU0E7XDbUdWjKv +PllR+TK+Me/pyXu03qjrdKEYpp7MyK3U3MnSd8UMq1Dkr1Qk/3qW9uZ9P8o7od+5993/v/JOh9Uu +JFUo777Rax7iPG1QsBnrZIajaPQLdrj102GR138fUtG+K3upeELUQs8Doha2afu5iZRgHIXPi9YP +tpMxAA1+PqQHhqCH+dmkAcHSPVTxSIRpKNKTwvR7kBAXDOTrAKfhdaByBEPrPVO2P5BgIo3PtNF2 +8jxnCuBxF8x8F3hw0F+73NGcab00OrsoGDGe+eAd12yznxVMdagIIOd6uAJKESFEVGskO/UERnaT +4XGY/I/k+P1SRZBXCkvfyfh1n6Wjt8zI97V1qu7jhUo/FBPdfa4gL0v06vwqSubR5Ij5+DzCA3tT +XFRu3zlXyc3n4f8DGlSE/87Gy09SfUNTKlJAlfoPeVZXeZSyWBSIwHAPGww7pzsilJgaR6GcCUpM +vobeuhSrguwUw3z8opodEhG4yM6yZcC3MzblKwCeV9xTucydZc8XLtfRYkBXRXjI0ViGa4nGclO5 +oKVhUbgZPSxftYT6hQNq++2P348//RXfSXFEj88whXqxBIe/oB42raN/OFG3VFLg6pL/9nk041Wd +PYClCPZhhQTwmeOABN4RUx1MIE3C4ArJzRlgN43IQjH88zlTWkeKoAWqwDyXKHKDHIeKoVsBBQsh +uLQq5h6IlfPqbnt7GSH5GCbeC220JSYwBkpjiXub0Kc6seUOdptJMiuvjq1gFJy/ddRERfRUEH7h +7N+Hs/8qeY0D2Br2QK1jIho10ENOU9m+xt6092O4khU9edPO848HQTFfvZKvruvVMfJ9RBVrR91+ +C6Jo6cH/FjTotoHCSzwpjFDn5UK0yEbD2TKIMIcoxyUXc46n/joRJVsXt5mvo8InfjF95ET1es2l +SsylaskvMZnoyB9SZgs2oqOx78QqvxjUsEwhuocBcx8Q2q4B4/9h076laU8WChqOySUCt7EROD6t +tP9iE9Vfy2TgHuls9r3cDV9Bu+57Ybvug9GzzaxbZ8/LTlkAQMPr3piQcQv7ewsV2T7zopbLs1Pb +nRoNG5XHw3iy5jteiSDeBe4gx1Eso+y7TCZBDxK9JNAe7AGh5rCqI+Ywn/dM5N7gIp47FsXMwGiO +lEDuAhzi8jaqzzqPp1YkBRkIBbo0BMbszPw5dSvrGKp04z3RpS0S8ARfIF3MJgkILbEStXvboU2T +8BPhCB6XHqeT/KT0PeR0o1ZXn/Vr/Pk8CrmzySdKJZDKS9P8c9EddBz7qa7taezMjkeOz2uaGkDz +9It8kSdglEVhVXb7kkKYNY1CWCAIERCXG3in8/VFS8wDh+Ss/fwskgA6ne1do/aPVyKUZYAm6l46 +6QtpCuK4C8G1cUg8QvWYKfKNmCne7Ix9BQOGfth4ATNDJW1G4BjYe3LUIFC5GdV17Mm0Y1+kOnxQ +n4Omor3JiIebNGKV+KZvHFfS3/69ca1jHATEsmDaNvKAqveCuTIdVgYUsSJ8cGIKNMf0dSerwwuD +P+ljBA6A74VpL/d8xLgLYAbFRdFJQeRVp9eOZtJ8pYlYWfEkdCqHbv/MsLmnLzRAhxzU5FJw/ZF0 +2aNjdqSOWGUfZ+KRd+y4H+VrkuY5EGiRXHL/3V9zSIVBu0BjPWQQv2j2OFvf+vfGbxqoNckPtY0d +b+pgobU8ASNoR3u11SbsFA2mkgzSFSaqoHeEWtMGeXn2g4kjEJmjNMatlIsBPFSs3n3qyP223/IS +aRFVoXkyBNSrUvgc5TGVXJBRYL4LTXx83RpnzYhasTKou/mqXQl53eVvnTGYSjtP1YVX4DPGU+9E +S/T/daStSlQ869EWsF3LE0B56QcQhgHDx6nmiMLSrKXX43ExQahuxi9q9cUlkyO3AJsU3995xd4+ +h6Ijds8QgBJEL8Yk+cG/ntH8NWsaxApMcbvkmhLBoCUdfOA4mvwJDYaBIs8d7wMY25EfhwT9RJzF +osDrqYw2jWQmyviJRTdEfGS/6Zr1I6YwFY4ATZTrRlTn69z0URIV8sF9yxZRw0TyE7MUhUTKoVPT +gbujGyIXB/FxFdXLaW0gUlZfmRA8dS/FO/crwSJClF94R7H4GfE4caxlepzr6JPfkA+OgLrjDFCD +7T5iGEuBiH69q0ppGs4iWq49jYKZXk1SAAZLsMUZ2KBDUVc8K0THU0mr0YEFneLw4zheLWwyz9OM +dhwg1U7YfAlif6HmbcHgP1QUWR4lzJdjbGRefdhCK0VWHmbxPh6Yka/hsvM5GS3DIPUZY2ETQSSV +JyjgrgisIipigNzPdhxJKBmACxmhqPxEF7J/nccxf4dDcJ+ooRT+tc5hRMT0cmySrkMY4es6OlLp +XVkkO1KJMIPbj2X5OtHLr78gJ0RMKhnrol1WnTe78NO6YiKndgGJNNoFYjqh9Vy8L7ueJ09CeOAL +CjmvcGh0ddhBe+l0mjZwDY9zJUn5g7IBPeYiQ4Xc6TIJiWkgUujlFwcPCG30SF49dug7Akl6tfDE +3lVZjF05d1m5z2GS7kug8ohd+BFRHxDwSAPtv85avr+l3VQKt/BF2P4zHo1uSDusDqS/e/ZzBI8s +G9giEC8DCa6E15vo0wwfAvn23t+Paq3jO2B7V2DnhSkSNfHObFWKEo9O+5OKaD+uaoXtHWV8XQ5m ++Sv0cuUgScX6caWYVxjHvkXU9csSYucCzi2vIKIkObzKYPU0JlCmGUDkSI+0SJtUKOPY1lXN4jAS +8BnAuQFuAvm66B3pwG2iGdyyicLtcabf/kIkWTWpvR1OjQiX81LwR3Km2XwUWBSYpdo07iVPtAHM +UAbMkNBPugorqBCsr+Nnr6Rxv1LcFrWSEQps2duh9+AiN4S50QoC1UYrSANN8Ew09cEzpfXxvByk +9bzYYrgjEiKmAqQfQVyPx9JlJ0eK+cixV5wJbY8TYaqOTmdJU+pwOdDMe08U32+jjrZZth/NJ+c5 +Uf6aNc5OkIj+Ps+LjE9Omcf7CesHNKG+eDMr84hGm/l0lJ5YmGEHOuP8taS47dMe00fXpP4c8TAW +thkCk4UTCR103dySV/do35d7BUASyQMrnTxtTWHxWV3IVhxR2jPzUMNE54a2KFmFACSljt7dGd+S +VTR2tb2ZN5DmRLlnOVaZefZNaMhyXENp8AprBws1jpeZXndP1AlYLn8BVubRPwewNtIe3M+xS8x4 +DkUvTzsqcgfzZf9wJ814X3LFlPnYV+wO8f84FvJvvb0P8UpJuV/7Ehmv58g8AQtg17mPfidM065t +xIhoD7K2vrAA4pX060fCYK8To/6qe10+9iWzqdzWrTUaxw0prtIjifmfuXxTB2pZrYdvsddS7K79 +siZzPRDFt0HjXKxF61hlK33wGnadEeiQzTNOn5+zlhJFqyhqh/arU+l81bzLUQwz6e2+3BGlkgtU +/WtlPuh+CobXOUi5if1MgI6o57qgnKWELrnHsRTxQ4raLnQuUX3QxR0QPY6Ani3bznr+GBG5ioFm +yTIi0m00y2oiIjOxl58x1teZLlAjqN/ZbeSbu04NHvtscAJsOrrs7fy0en5aDYF1ab26H795PGSU +8SWf/SrXdxIg8J1H0ewGkRdNs1BIYOx+BdDPjgFR+zmQHegaNw2OskKa6Oj73K8+dk+HmerFVWPf +mljuDNXJ4hl2qX0Juv02Y4y51K6jqVbY6SRCORKY0bQT+7+fuPalJXmdiary0awWiKliV7jfhEvi +JgkdOXKHrfLkOOI/8Dbwx5OQq9a1QGbdSS5NrQfmOe+lGmczZVs/KoP6G3R8l05inyu8SqTndkSs +09CgVXhznJxrQRiOiFzylIGG5teJHEaTyRYT+3HmIGBJh0dR8LpjCfXkPFF3Gupqnwjy0l2vSNDT +P0cdPyzi+q8Tadu1DlsZ+jLcS6dqvN/XOwchhZhBD43bA9PDLVFUB7SDojpFNilM2rxrr8lnF5FD +r+y3ZjvNNB58FDLaCHMhGj5UxKaIidgT0nG3tPn49dAuYUVBEJg/6V1VmHOCvcwIykY2ODir45NI +bZRfghHhI3x/JWNOqlXGtVKmCQKigFJlk0FBurCp8k0EVftnwaDedLNrsT/1VWwRBkrZ+BxGNaCa +GO5kTJiUup6Uuq3DK13hlbaX3bm/T9YWemzQi5l5QlGGpHcf5OdBbDKaCcbOEkiJCJ7Qcb+r8cXc +3HaQ/YP95a/WfpEu58k13QfXwc5Xt6kS9hYDJ158awA6GdKrJk298GY0sqPYv463lJwgVfdW3cdc +6c2pv4OJ8p3mmTUtwP6wd2qet/071339f6yd3ar1SnaeryD3sA6dHOyo/lTSYbIJweCQkJPERxvT +dsAQu43TMeTuU8/zlub69pqrvWloN276WxpT0tQsVY0a4/1JNdJ+GeVPoEpCGh7IKrWKwwnFYn64 +fOKML+BbuWKI6hR3WMEwZHYQdCtZobMDO5qSPsGDnCF9QmKu6wt7W22XhACWbVuMqLIX9DCGpY58 +V/FVt8hNd2wYtOMg5g1/G8XCt6Kmpqhzy0sbMZ8Iis2o8Vx1R8hCoe537QjKU0Qc9+eVyL2YanDS +JOrStv7QgCrlm0NwbD+3iYTS3NW2/q7vhADSR6SigU/lZlmRXxeiUE9haNj7B+R65TzixVHVc+t0 +K/tkc1uI5xqiDrvriL47xXe5w8xmQpcPO5t7MJ3bUwWbqmN7O9Roi19addwb1w6dDxSVmHzRsFW1 +JqjNgIiCyQqpRvB2YQf85D5ESb89UQovRoV3wYvI1u7evH82lp3OBIkf2QVWZFoBrIdEAuyB53XG +80LtiLXTqyWfCoRLgZNsUQVyry3qjH/CDKADfZLizrcmbdIt+LmAPYDuMvPaCzeZGWsavXqwyEp8 +ozV6SyedGxvgGDvfod7ssS934SRBx3xzp/AnYYEGbozsSH2sMkrIsZkemqKe/F3QK7qnaL6yxdN8 +Y2oIZH815WJoeu0UN0SNqTtO1nZjRHZczlzBChds8FECZq4YvDKEab6QGAuY92scKe4g+XdvpomV +9WJTug6ZNvw0rBWVSs35HRyUei9j7zx97J1CLuMVpNvYrD0I6XT7jkfcCj9ideCfJA== + + + HNoe0zy0PdqGBPRN1rOoC0T0OT/7mGsnGOrsbYsHDrqgcbAo0npNqQcwaKyMrsUebIkR/pmmJH9e +E0jUXcdp0wAw5IM9pXEgVLAreQ0SW8jsmgEnd2mbXIWsNaymy8TGd64X2I80ZIrFWCjzFnaxgshr +en9lnEQpL0NZTfHKuX0n13dfP97peaK1N5Szi1GbjeI7SLUVoBT6CqCrkADKhgS8mH70HiOz39y8 +CK8KG6Cho+FwEVmgd0h4Zta6VgSvYCJQhiq64eRCzwJtMxB2G962Y4b1rOhjjRk463+jJMOLkiZy +n1oWhKblDFfqOCI/ez8scVqmTGN08o7Yj6Ahi9LLoVAF4F4EGCue3uKN72DyKhtpMgwojJmiehSv +qF9RwaV+hahAqk/XwzXdinfX8VT0dZr0SqF/Dq0OXY4bolYr6BSSoj+S3ihr1dpM79O6zHrnjudR +oYxNa4b5Gr1zKIrRIsEzvWTqsFFcGFI9fTzlAlm5j5gxDLWC+FJs32nOgr6iOTsfPU52RQ7BS3dE +GSC+mFDvdBnYjkwkrMCiABDY+K0q9WcdBGIGhW+mLdGQn9g/zv14HVBnylu4cpNmxzEWJg+qnSTs +SDdG9/CqYono8yzoGkaEX/2sEhyMkDAy2ZH59JdtKpxFYOgSGkZTa4agLwmu0WH//uwiJvh9rnK/ +LpOFhO3K1TbH+9wc7xaMvPrPMEjr1gFI/hUBEgKEJCMAcu8LIcFKBNvvfaEenZ3KUJ7pRyq3RfPf +duax99RV88nbQZjUSqKXi0nuhMrqGeZyCbfZqXFfaCvq1hZ5kRRgRwqw89hPZqg3QtYT6n7OM1ws +YmIGNwTHV6kmYDNcPfT22iPsDDKwgOsiM2XnwTutOg/LCumHSgDnpowfYDeqTkaHXBZcBGAwnVWX +82f9M+nBZS0+nRQ2LvtdBXwnq7awE5DMJsuSgpWnhyId2M1OuDlFlZMJAFVOJkivJ5OK0Qbq4xYa +R4oW2tCdYUCr+bwS7BfHLIk7lL8tf+EWlcRonim2KmHTD+UKP9d05g3cacbm0kUhv1yBn681XjpS +w9EuXFF34g2RfHq4yNryIxVM8SiRzRZPcJb5z6W2xFlwtr0NMQMNudua4dyoZMSojpbzOl1xIHSf +rPXP6UKzWF8/BhotaXoDu3psIrPqpuhx5cJTfYkD0ZOSgH1H5hbrABKF+/xd8162AIdZ/7mbWaI3 +OP84dHVFIvSUlL52cu6q2+DNbiFT8N7Yp2EiGM82c6VPxw/gSGc/ySZ8X2qylImoyTLPqt6NEelB +r88xM+K10ZBkI+DepAlaXHeKi+6L29r8tP1WkLuClEF2my6oNGm2+mtHvkHUAInUEWfxUIrokgh1 +ZBFGornYS7+CvAd6N196gWNj0x+ZMttEV9pEAnjOO3XwAxTDmfO4laTbDmoZEDU4hAO44QiMTUo2 +X79s4jaMhjlEVZ+HFBtQNWf0hKD8BMEpC2RNFafulSz3Ev4HrmJ+JRC2WGd3cyk0KXS5L7A3+out +IcIHB+ppP/1I3buRB5fIpkd1klcqAY2mMtIWNXrl0huPpnVvAnQOKVhf/0AVUPyY2ioL29SMlJE2 +tTMLvh209hrul5ilI0JmrWymNVe6QzcYcrHp4h3qNAFof+ghV/AGa06bqtTwMKFRNWkrI4qeTGFr +NaOu6gyY14MUDZIv0oJDUdHtxdWT5Taw9fORc92cg3LsLdm5VVAbQAKZL9dWDdYf8PLHFkIPWKop +5rtpwbAzh9TAL1ovryuJ+lxXiiXnneri2spNioltbN+rA5rEGVLVOL5B5LEAKdJOoxPM+s97vIWm +sVLisfX7hxkG2R1f5dzYEuRxpBQeW1ATJxWx8M2pTEY+JT4Y+YznhyUgffNAf1Chq/kQSE1TwnRh +q1eY4Uvo+VtY445DHgyULnOEWToultF4W+P7eH4U5B6F969J4KyBtgf4JWvh9rd1JT8w2Oqx4Io/ +5WlJWcB+3j7MyMEzg7AWA3ZimbSv5MIKyhjhLXn+10aoTTaxYVJE/t6cJTR53hjgelJegPrytCle +u7zc0Uh8zm/xVEn7bXamLWUR0hFNe7eQsLgOix57slkRGIAbse9Ao6xEhLS70rVHyJ9siLYpjTPR +eERFVD8sHMS3+r5P3jUQMpSAjbiSz1qkKYjdvKR1R/bhBetETeDWiywhoke2+4AAqBhx2RC+SxZp +FHXZW5BvyrTgyT1kIOYX0HG1xoWiIEwMAY++EHgQYD3BkAWkBpWFzSp3oqWoe4tHgHRuO4epjUao +7TSpWFhVomCWQQJi/VG530L/kJfvmEIj+D5ZBFGW4M5WhEJUtDyg/Py8F0Fdc4lC084oBjNR69f7 +q38TbpsFOVpyl4cOTNOY+iL0iny4RP7trrsi2H7FzCGct4OCgi+QJgPrb+C9Nu/ocLOvQij4dtDW ++NmtNyiZAmmZkiGi5e6PfmycA3ulJoZ15fxPFQDDKJJCZA2p+lHJvsYe+vg7HuDwQq5wtudNveVL +lwh7H3nxohxZ1G28kKbbE1/ZHoHr/1Q8Rom1qg25Ju0W9Gd2uWSJXAkgJ3VIZfS3ukq2bCsWZZTv +pZegpKfKRT9sQ2bOEFZCwZtlMqPSFAsIhhaYpcQeQitg30ufGmCbNAD7Rfc9FwAnwhOpID2fXtdx +RESjbfE/3YoqHpjHuWERdECC+v7rvYeValiRvLfxdW9OhLZ48acTQQKwJl0UkImh4UfPbP3kp+6+ +54Mk4+HtHcyM+0jFD7o0nUoVPx3DpIF6S4/gnk3tIiuMpBUOI99rDRQXPWaIU/HnFkL1WPd3PAof +LHyXntw4DY04olJlYrutOFnfq73FQvovsRRtuEPGjUqWI3g33Fv4Ntsmjwb71nJdc7LlonWN89Ds +c00kRhU6qLsTigMg+VvOU9ILgxWo5ddvIvD+nHi/f/dHve7/xBP9hol8/lP8z3d27tL21osAI+8c +JGyktiAu1mS/tq7bzRDenvMSNUOBz1+iZOU5KV9xKyORmJsWOT1/w0XUA9kDgad99m7aXZXA7zES +i8hAEiflfAok9J6ZwZRIha9z07Etj0KR7BHXlaQBauElhrGimhXlTofmMqpG2p3MdHqeJpKaZv8d +UZVyRux3pCZ5bVcHznHkHGkRF2ah/rqSDQY8BvrcssKaTGACewaTLw4LdB1Y80BYgGQWDM5jqCEt +gSa8NUkitLkpMUDNxm57NBYUaFQ37iHeKrRNg/AOgm4Od9Nb/O0c4Rkc4G66u2CWATA35/Woad/Z +M4ri8Ab6Rigc6HHFHkl9JOr4dsO+WkyhBdFTl3JCEA5mQ3Zzn3MlKr+gCI8ieyWYCx3VBmWCqnB5 +RihbIh0KrwySTgo8w6Ed2+ksdh7rC5+PKyxUXnr1d5IBg5iG6SecFI9ujc1zQFuTmQmBCJJXIsYh ++g05d/1TmOPO1/lRzSDK3cEx9/2vUS7lnADUeO+0LuKi4IOdVAd6bkWM5Nx6GxP7w2ftpbUHz3Rt +UMtG0Tq1dfbNJE13lBbWBbCiKulZu+TgrrTWxi4yT7dLSKfXe4RJQ0luTv89yIWvp7HeiQNnC3iV +GZP8B/AF9JP3AHjW4EiwXt3IpbcganviAsj/VyLWUTXqIoDpcQ/b9zTzumrmbJAGC0R/Hcjdg0BB +8oeUjHng+ZSuN4DK0IEOejgMs/UzoTDJJ+0R3bHQFdizK30eQ0kQrDjaBRo+BUDDT1Xz6UEh/GwW +3ogIEGvwI04j2JuZ7wB7JiLg4QGF4PP+qejxmovO0si3CS+iOb6+x22jnAB2g4mo8pMA8BcjLr/a +2kdrPMmFoDVwoadj1xmglGdv9MXvc+OrQYWcFIU4T6qOWDpXs0WebevfHOBczpFUpTf27ZuouqXg +mQzWfqULFYcjeQI3DT5HqtPAP+FgDNy2FfWYBNqciLYjNtOlV42H3o51eFeURtctDIhvoHLsqaEV +SNb8HvHtUH2LquBftb9ZOxpkACCQ9qpy5I0KCFAQKodd++BLQNFpStsOD/y8XwGN78G61SShmTvX +9F540Zo7PnWB5pb+t8C1Xu/r3EACo5AAoLx9jC11tSUiTgrtRpy0vyiAK1Z+qn/PAdJgDqy7j0XN +8bxJmh4Vz3tWalfQb6e/xQHIy4/TUSJiYyDnBosyX6wtMBHiXDgQuXRS9baH+rTrjbDQretX6xsn +f0jO9JVhPPIyT616WNT1JQQRUBmjKaBciJvILPoakXJUKPhvB90OWqealieFfaYArkR/jzGFqgKU +2zY4JNSilbjUR2ZFb3a5/PRdN4SEj62oaucdJsuQYljl5ZA5qSiPXvsjnPCvZmD/at65WTB/Gnde +fIM1d/oKJf62QVoNsaxhm1CztIO+6aLsNbJTOe9J0TACwHY5KxS/ZOdyBI+Wtgb7COZr9hEUF3BS +SVbNW/MwEoHDK1nMlFzi0CKAfYDlUeS5h5wEcpOiuB4u5u/oQqtx2bcK81p9gU4Toe3GgND7wFmv +HnDNipKybdSRj6vshJDatlEW5spATYO7ByUJ3EenZyJ0IKp4Vj3wpjtSbPKUcBkhfaGdPLR3DrhI +UC+Po/QYAAXUhSBMjfRrrMHJTe7gGa2p08SFfRksTE8tfe3ljizGXU80HF+uiJHryNFwkRNBeG03 +xQ5DPJXiS/aVUnhn/FC3QxKtqBeHwq032aMKCrWmFxrDpii8XgJ113mmdmf1MTO7VI2VCNosJo8h +AxrhQ32KqVqXBwlcUrWim6yWO1FzS2VTE0S3u+4LNFZznCRE1oMwVg+5bDhd3dBHHmR5BPO3d+ia +DZPAAyEZ6QJm0279dPo6XOoC9Bvd/o/ffmF+/jO+pBJMlLLFd6cHnBOdyDXht+zJIAre0jzXPbaN +HSIlJqhHvpqa1yVPBdbHxiC1YJDE74O7VTqdhe+Iqm5gTKkHvjA+xbw+vMWglC6xTKcnFgXUxj5A +Y12KV9TmA7eiW1v3Rw+BHef10AqoYgf81dgjheOuYTc/EzhH6mCaT1ZkfKjG1N0Xst5Li6r2UFfX +dCFj7S0ilaa6u6LlEP31dhokpBTnQJ5xhPMbqFClZ0jJMrIZa2BTjWaDi9sMrTEpeald1tQSDvoN +NWpksdy6KF/Frcx54tja9ES4xB+2L3OlCPPw0lPlJYI3jojyKurWXTFEU7g98jiqzTRfBdsg7rBW +IoXssOfpivDQp42xGU6dNkqulk27KB6kce6X29XIrET3BiYhzYiskFDFIV9T21Ftq8cBADSQ6Lu1 +36SAQuVWq8eDnlPZ2JoWUAywqteaauHV7l7ZtTnAWdTm7EUhnI6wzaEmfPi7Eq4K69U3xwXGW0YF +6vI0dt6iNl2PoptQMpz81JATz9TUvwyqp6ixmMU7fRdQK/U94ne7L6IIzZo1u/JM7+fZSMwDVvqV +eyFdzAFKG+vA2YJ4lGdfD7tC+wJvURC5bTVcB2bYPno90PSFOYNoDPGaiXmaEqkqvA== + + + 9mb6ZcGKOO27sG18LjQjbwgv/rwTdZ1NDExnVTQiPbX1q/NjaH+qcLJvnRF5qhMwzRkNRXX3eJDt +s2AfPa1JKbmHAz4SNY99pTt6cLhhROBUtvi5sXBU1UHGhz5e1PVHF3GP57JH68nuMA0MCz5hmqXX +tRuI69HtmmuU76H16Uf8FrGJp9V16JkNvkZBoxMG1Kgb5NkPy+Q6n234hQMEQC0v7RqKtbz/PQN5 +O14Xns9Zv/k00AdLV4JnL/uG9sDeDgC7pZwMMPel9fcexZ46wCa9SJWj8aes6aCSI48ZiVdJPOVR +QqiPIOE8x8sGuIZ8hnSgbQM2GPmtt7w3mAumKJAZCna/jQZkWFIzY/mJpLVE+nKzi9hXYnuGqn5h +c7nhv8FYHWC2gw2Lddq5BaBv/u/ynbVAuIbU0Iwa0QDXWzle+wJgtlK4ZyXaU48KN7aw0zlVTQWT +b0t2FHQEb28nLxGtzhKYoDaL9Mf5qMxysATeKt2a02zrBqFYbKD9wwy3kgq/5qVIsQoDbAO9r5xe +1ugGYzynH1d02QuPmsbtHauZYUdp7rbZ2ku6vPiBohvE2lvnrgNMRvihP3eNdmOkxLoQOQTJauwZ +glReaz68B4HUCjjzDoo3/I1k6M+5PWKHo5jPykaqbcJ2BJhXTosDm4ZPSfeyWDAsU7fxSLWg63xt +/9oW/1pnQYRY7D7DiZkx/FXHtTcoSCn6Rp4YflfbqRe2wJd5LPvhqIw2VzoI2dta2Kr0ijgjCnMl +FeZKonnqtqchQnmdh2mIlFx7xP31Qq7apK8fMqkg494LIAvcqWrt568hPNC6fsUludphn6HXrAPK +rOe8JVCczpR/bneJKx2tSN1TcD+TDChfhuzF5bbn2rLtHYnaGFarBVUYCE+LCfJc0cWXB1Js4xdz +WMB424DbBjcV8f3iXuBKzRZqOnCuSGhwCdji3oY5UZ2PVKt9Ojd261dCW8YotejZE16h99ucpZOn +MDWd6J5FVv2P9PrKpkBf6VXbrSj6nbXPK0HuJKru+8m0Rcf73lRqfNKRSCt1L16i3+726JYpZMTf +08tfae94zl9/Cvp0JDVEFtri+Bq28uGxTrB4zXQ2Xc94Zd8DkLJKOgJA6SGnGjV31KybTUR18TgQ +uwxjivpLZ28qlRM4s21dswdZ4prT+ff0EvtWxcFo8/r8jHxONsK4OYjmhebGbrNuFbbzjLGWrjl1 +u+bc89MzUYsvstszFRoxtDFUCLHJRksDr1k9f4TU2Ei28MalOLAIA8b8GuDtv3kLvp0G/0p6Kp3W +MVMf/rGWRe4LY7Idce6I+7FBe+aKLwcFQktqoEZ/xatQ13EYxRa57GAxOtaeFlVE5cYVoRq0e56I +Y0c85RrFb4YuHqMKXQdbeiVKcOg8Huu84Pm1beAEa1TgP/AWUEa6UFU1zfEqPfwqSBuQGRuQc/8Q +2mk0WY6uJup7IXgmwc+0CejY7tm9RTwja+qisx7f/C6KPra8nEaCqCPfmd0ZfiTwXqTyx4kRf9/u +qxOm1Hoij2na2DA8+f53NhTaVVRAdJRxxrHf2yNs6Eqm4p+pp/PBkGh2u4DjEP9f3XbbtO1072ZU +HFuQ+1RuqISTvCLWdmUmgi0ZEQIV6bg6ls+hv61XCgr9RNr1s6+vs+DJDzSzo6l9A0O1jlUPIxAU +6n2MqlMphh48j/nCRn//KiIXmDEgW6ef5vBEzWtHyQa/w+8BAwQYiRtlz0juPUQ8v0fUAHPFyjwq +X+9R4KTa5ku0aErpWTZKi7vGtVOUNZS1bx8rJ1NuAn/pdr9HeCEoMzBfgUYqV/12nt62HyR52hVw +j9M83/khyf864qHvwqRCCydX+hJVbRHyldZboKLL2Gbp6sBZ3dwlHaR61KVEwo/0piF4oSXcl4jn +DY2fG+Jm9/3NeeYdIdsqdScrhpJlAAr7dxFuokrcaq5aPgurd9ibCN87o0RabK6NxPWUzccum2dr +o3InkO+LTjjGp+j/NDtq30Tk2fVgkXDQ1dLt7TyPhCd82trHzri0n1hLV4uKR+Ao66UamlWVmHwU +5LzHp52Le6a2zShJNUncOipHbR+ooPTXBnsInjpSl0EFFIPPGH+MGH8cr4XmiEldRwj4DCVPiFBR +ljDnESCH9kbf2MhsZchF73wD0/IuKDdXimvYyZz4CC72KBwjnO9vUcUbRltzinlYMwbYOd4h0uj1 +A1yKaWEUdKirel8ivIyoO+Kqr0RFuBYgJSBWb1FqNyS95EmdKnUrA1bWRFhNNd4iSkCpKA48KPz3 +qJ4Nd62pm3RyA7H8M0UiPGMR6+WbIAnON7ldMlEIORVeXdnZS2VzZF7noAZw1XZkxDIiigNMfqvq +dv3ZENjYchosNUQ8YoKKmMBRGI90ilGgPMhktrmKJfbCS68Mz3jyV+BVuZJ1XdQYU2/f9Q1/lGtH +WBJZiUF58gzZmew4IJhRzuh0Xg5//lsZjlKyQ6Aso9sQui4WnmlUluubiDGCJEROaz67n7cohUFH +hEHLLsNXeDaQ18/vXHlqF2n5nRePw5fnyO5aZXGCrMLwIp/RJ1K3E70YC48jm+4C+Kyk8Ql0I/qY +PuxLYtfPexrWxvAN3rj+0GDSgmRytz02bZJpvp6Bqt+xHme78x7wu6eLd1raB1k4vznNfT3sXIgd +I9tZakxsZ5kl3yO+XSO/RrGgxCxlgI6K7e5DL5XAUTfEPKZx1G0nvkC3SW28jNcYA0Xz825mpMWA +lDlLIZ1b6vCVGs7DpUdKDC5914x4fRVsWiv99RoX6GPIylLbMR6Nck/RvW7tB7N7am+8+zBZIZ9R +moFb1h8tyR+JRG8R/7IrSc7ebx9vZ8oqKD3cQdC790HUF0tk9K5vIKQ0xtkMSS3uTTeP2R97JaPa +jtpfL3zmFdX0NzyeqhkmrveOmDtCy5Bj0w6axj47glyusT99qm9kjWE9jdR4SlSdoDrL2dDOPOw5 +/aXdktT8nd4HNvaiaInQXBjLjfHp3ySEsyA5s90178d6sfggTkawB4aKCuuNlGeDsRE/+hpkcUjE +4hrJUSyur+f8j+43XcpnU6Tl34BSlbfHnBZ5/EPO2a5ar7FT1c4/d38P8vTZt+6bJVQU/7ZVcNNI +F/sJ2BgzljgTt5oVNTQOhZCKEdGKYLOzzxNu+2lyQy9Agl1XZvI5rzPzgabYGUsgpYYr2lM6jXwT +oboTiQGtWs8rzmAGrihxV7Ioq9VTyT1r3DqPq59txBmy6qSBGOitwQV8QTuetvRwH5MrW9CZSYa3 +3eeVpXWoaz8ck060STDplJ+6AuwpFJyazy3+aX3cctL9XcS6EXrH6K7OV6vmiJuDUQrS7QI0sqll +U+CivN5oe0SnK7hH1u0aRr+pKu64UygpwEIa5HeqFAGI73waWrkrDNVGpSSRgqMz07b/DjVTodKk +V2of0dwum2nCokRWRpmBnXnApuu+j8ezo5V0EssZdW6j0CYmaxAp3kqMnFcEoAojLMoSwapAnunN +nqxtOYPISOt4+zLH9gDgHpC6oYBmznekYlxQ/b5y9q3wjVZ0NcJBV07V742Iig3Q9fmI4deQsvFE +PlqE1+i8IIRVpW174ov3oV7ShBXwm8IMgafZI4psACDGM5Ajsk+d/15MrBWlvgrUMLPMuXF0B8pF +MSPsMuhllAR+pAALe5gJARg7xcty2HHq3c2tACNZEYoQPReykmKPquRKU9Lq7Y43V6LIzZXYxKrH +hqQVemxj34sVLrxozporBWerfFV5/TpyZNYjPpXZYcZjClxTb9dRk/HHsy1rHpD5MLZ3G6UAfSCI +CKcBufnq1k0dN8bVq337dh64rdYL6U3sn1vV9YKOXgtbfd67REnepsz1eP7uWUE/KnNSYKier8+g +SyQJQaeDa3O+gT2h7abW/dcIDFWKdTge48NT+Bo1ztSj8J4m/WYDnEIt7tNKM5atb4TBr2Va6EE7 +65K3tw487vIanzJkuHsVb94+rgNn1OdMnRwZrfxw4EpVqrFfPH8YQjN8GoXG1svswgKSYW4eJ7tg +Su6abG2kKU8SpFDKmscPjzl/UkWcLFWX5HI83aYwwSR5Xyk+6R5SZW/uj77o60ld/BuDb51uHruI +o8sRzW6zsHMjNymt2oonourxOKMRzYIiqR3g3DFet+sqU5kTBP2fm9KsmMy1yVXKCE2qrsEQeR7o +ijMyLlY8vh7I0/3K9X77OAY0oM/X4xqaLYP4Y5pCzH0e/ZsIf8eR33GURynma5SoeyaMiQPpvW90 +yzXqkdmeHGiL53Hgks+4JrsHU4PZhJCXNS9eoHm/RvmVyKRBVfU7P2HQSiXtDMyn7hFhaqYUhaln +f9SfxgZlrbVEPtTcdJZ2tOgrgqpiSV8XKNBq3wvfbxHjisUQZesHuZwotp1EzWhqgkax0i0ZBBGj +yOySiQaeZb1YNt188Ap2W68jLI7jkVRb3+gh8ZX4W6KxPo+nHqLK8Eq3rGauebp4GrSCdh3jihC9 +KHoaQwqMKz/aLaWsAf55/mvXbxrpIWSL0fLxSB+tIWAhHjSvIHymimtfGSQkrLnsDI+tbVxQYuuv +F8P2IurD1RV1KMrAoHFeqWR3M42WDf8+aCF+E3F0zX/zRn85KLuJ0t3QPGJubIuVYAvKRSsT5BF0 +g2nW0yIyMCGl9PeIrCLn1m6KYME350Hbh7oh2j5USxHLsy/5doCiJBnJGu5r3DxqCF+i3jS0afQf +sqSh9V7i/DcGnU3YuQ1S1NFZGygmh68RrylEGu+Fo9v5zXkgtNI3lXpaQqQTVIiK5ND8s2vgkKc9 +qk97/Wb7AuhDzRykyisnfyPVxNwopeV5S1QmVnJDnSXnNUuZ6o4Y0RA4Jv0pr6mppwtTdq+MKH04 +LfJeOU/AdisLBWpghCy+tSwcJfeiE0IR4Ru4qp2PYbX/sQi795Vop63FG3rdiOsXBOp6NPPNIgyw +vh9QyFBL+Atrz2eVGEmTjbrLbpqfaZozZm2DTqUNze94W0wiOlJN1wZ9JDeA3He9R2RMbVFHrEPK +7N+cB64oWEr8/5zMa9v6oIj9XQG7KfpRNzO1g6qYm1WKR0+Jf+Np1Qn10xkwLnCpbfEG5g5FpCMF +sNCE1g5Uf7qxG7W0l4TIUlig4trRQq6bXjq2nQmz8HVE6VtBGBpd9+77nrGkAgkTRv8BXoJSwdyG +U3gjE/EarGtxCPiL97q0b84ztySSL2vbGN9LhC2O2O8B5aG1sq9+foq3oCPyypgEio6ZW24K+vSc +m0/FqgimUBNLvtA95GkPYDc8qKqD1lwbgfFsqe+09NAHQqDPKDHJa++ue8nJ2AnS83DWlyjEjI2X +Zwso75yxE03pCqpSCGYI134aqYXlckVDCuX0UfLxSSIAXGZuppM1BfwGrnetBYlthzL7a/CUB+CJ +S7c+bQV7MPm+Sm6jujGD75xBkvrC6o7g4F7TmniItwDQVmqPKj70wpH+OmhsYwDw2g== + + + utZtsPhhqyG/b1wYdFwKunNHrIE9rveIPK6x8bKTOvj53XnaJh9S1NHeoQUgRSJQrKH0TTadyI7H +f2D/uPB9H7WLnjr1wRdDNogoSptE0V//q30/d2Z/89hOq+9KJQecgbWei3eavI7eQKd7WcZ7BGYc +U/b7TWngh5rRr6Iu9CxwmFhZ9zlj/5M9Kc4DzK5qFaRpLha5zLjnlPNzVxQqOvxLyBBKiG16Ki8s +VfiC1QmI4kHX4Kw7Qhkr8Nnn+9qazPRr1JqqtFzobDFUhiyx0avbS9SOAIlQV+2zWh5Oej/I7+t2 +LBhxLJiPauiWwFpfp2i6U0uwZfTSFFTDo1E/26ZsTjwQfUWpcUSnH90LTWKYVdXpV/1WxsUL4GHu +1yAizfixwdld3+k6hTjhTNMUiANd090E6gS9xhDNGjn5Jr8IczSUkKtmYoK+kLGBMA4MRLm09c6C +FFTSXdrR2ghMl6e2rizI6kDlvbxHPIimADkGZeHrm/NQ6pYvTUKs/jg1t/Z5APlBe9i3sKGc9znI +Gu/yfAaBiDSzawTisYIgUQFUbXGtWcH9oNNEx3AMPeLwh2mH0JJJpe/nDZ5T6wtVhJ0TK0u+3i2x +vR0vMXQ/6uMmNlWv/vht2N2fE+Qn9/6P8u//xJMdONaPHyn1/o+/Xf/j/PiLf/vxP//HH79Y+fj3 +//H3v//fH3/xH/7yv/3NH/7wd//8j7/85f/55b/8zd//4y8///6f/t8vv/9fv/ynv/37P/znf/79 +//2nX130fp35N+j//5X/BmDWBbY11eI/MIJCGhLuG9Pstf6y1krrIrzQa6X5ULYphm9VLOcHtNlB +/kJVYaDlxi4Je+TXn/3UsPLH7A4p8TvRgQm6psYzSmws9k+c8B9ykObE+0G12NTvb8G287ZivYzq +mfAJiAM7uWSze5e4UEXV1BbeB3J+pwJMexYGvsP++0ZkWtzssSsnpAmZb1HUFPDHCwS/VsHtNTVy +oN85oM5+3cQpP9F3yyQpFhewMLj+pL51baIMuLK6Uh6A9wePHODmzWZ25uxRI24wivMyUIVXcB6N +KIXFuop6Hwh5aHnyVWIKitS0QSecgTfx2k0xuhY97UIZJpW1eGVSFNuiMymm90Octuikkqmwknhv +hV7gLdpPKm14WVJbWVz5UPGv1r3ZuOzw3AonUaEogYQfaq+slOXZ3UzW0o0XTwFGYBWfOkVd0M6m +qyVrTz9caCPTAyEuUNV6iD8Y0c2cLtaLc9oVQPhzA9QETQAn0cGcunDNzfWHIM8mJipFFjzKJXXg +A2PVU9mlrvsflm7sePPPTL0ZovtPKv6rtDQ3Kvi+1j7h/jxQS0T3Aak/Y/rzYE8FmO3hYUrxk0gB +NkzQR9SCV7iODscY7wcCfFqfKt8cxO5Tj2/8e8gN4PpSEKvsgWbApjplq3f2fEUqA3VLZVsiuB3g +fqptNVTfLF1nuI6gpK3kfGidB5/vMZr7qW2p1o3i77w92PmphPakHPydFgsU8PN8k45ORgMpLUwU +K97YjU8bu6yzIS3An+Ku1MJ7/j6S/xdmyqcGtY/Rm0EtqlCA0oMIrdp4DKvuUPSI+Chwotr99nff +YdCLx3g7dohhtoRPXZenenw/JI7ADMtHOZ6Z6BGll1/MtuSnrbHangNdIT5eWbap/dpzkph9WsDr +RWeLcCWNQ2VipXEXw5fGt15rzqAP+mBgUTb8TCaec2uqjkKK+4Hv2lE2Co2BVvUOy4/DQQCNIgAo +RtNasv4EeGLsAyRhHMC2WCrgHadEDTDADLQtqSjc+Q5cIDxc20ggW38KjYj5HVmoSk9achA17/e/ +czZRcvWbg6dmO/EAYIpbS9DxuQTF0BAqY9YiTO/LXriAhbFwrR+ST62fZi91571tEJsr2vcL5JMG +hca9hstPEdJab+OmJ1F1WHk95ioupwUTKuSu0XaKfl17vC5hNs8154C9gOW1fkaV1XGWR9EJ3Iom +o+czBZZAWUgSz2Dp+yZZ4wG+FpR8CD+xU0xaMEQnlmorgkaiEbeSGnRi1U/cqobAsa6t21Jgal4H +rm9rLanBM2kZsKIuRjQRKxHhSqPLqSSCVi0RYNSIoPxNRO13ItaeU2iW2ti5EiRYnuIKRX2eTQRi +5Jh0+TIAhQRojzjvuQF1yhwDhnNPN5Cspdm2llR3qMyQl9NWQ3Ngv23sTiI9J6BL1eSbfR38bgQs +1tsnjkLxD+mua2KniHhqsRIriLaXA/5GvrCez7Sn8oAvChKdPR/CCnDAoZ8GbKxvX8ujx/FwWcch +tGVVZ0NTVY58XYRqIDEVxxVRtmRf+DAjpENERSJmQIEMotiuLgF06Aigd0cA8jK5ThDFHRrGvpD1 +clSWXY9RUREUfKBusp4wNbzQH6MnrDXH+o1/4x34+XljmmLiA6srGZHIe6krSbcFGZ5/2FGoXLD5 +QW4wImA09yjDg6LwPI5vHDKUGhuPINl6ls0AmNFcCOa9AScPdNDq2IsvUXQxdN4aCpysLzaUBV/r +2eyeZ30ASPQFlXJHaGK0hhlF/iZ93SvdQBO8Eq0ZrnTtTlPRdG5bxcD/oWtWnePR6OiIQcKB7KnS +6r4DSXLlNQWeEzjFlYbWMb6JcBUDcKnIypeDJxr+ijlc0Q/BdIj97BruldZqQYHTYvP6aR+PJdrA +dFQ4eNJAGQoX8SGrBPzdRYlFfv2OJ4L1DAT+TmeYv48NHIGoQOnDg3jEcxDHbWpMJKseoM+ERd96 +Z/g7NDRvjcWFN+wRBkbMkKrlyjjtxA3lWaNW4YszwDyvOfYUBD11lXp6uJN1ZmzrUA18LnSj68fE +x+KIaWl8lU7ERMYPB8ghrCZDrtinew7WDQGmaEItzKoKlWFsNiAw4jYGkY5FpbbyfsCvhoD5nO8H +cdi2xAZJ1w17B3VQPg9gfPw8oNffhupvPIf4LPUIseM9j5gKbGSFWTBg0ubqxIxin0Xt9BjIqhPf +T9uI/L3tD0XY+8TH6fqIRnS8tqqlbYruu7R9YuDXczDua8hmrVTppJgb+aN4pLGiXZ6tqeQlBVtX +WeBteW+dDoFw8o1mLADVDodUH8OouXuSeJmtqfp1QGos+++WicPTvQ7ekUbttjZ9QBd+oFSM0ic4 +ui5fU2fxbw74Kp4/KcPydpC9oGa/6B1o3AZtdHz+HS1LDW5hDG9I8edByDv0AtbLANGP7o/KJbKd +u0a8a21oHzdZaIkuVMO8p4Oa2WbY6sGdKVDvH2INhvWW3JgY1G9+IcVk7jjp5dHh0bGZtkX6KlZU +VfFov0Pq92uXhKFGQa628kod4FlSsk4BHi1j6qZVJ1ekm26MiLYZ8q1xcKU06JWqMgaYszsszqwb +621cO401VeC8eAB9n6B180sfNjWaJYV1cbhCaISi1DRtruSLAkh7XMuack5EVVSIjdL/sUPtYCFp +0DqgRq7Zem42Yd79Cg5iGDGPSW0ChlRPBCDZTtwmyxKFBvsNC+fcbEJt1brauM3zXLRtVgQmTEbE +tE6hu9wLafOb7F8uAC6ta0kKSt6XQtXXrpfbR9ErcU252O5CSDhYQ62t0169P357tX4yYY3TWEjX +bq/JooPnfGjNvKbg9VBk7KIOMnz5atbOe4vwjWNdkadNxtbo+K03ZpxZbmXJ4kl0+SUUt2WiKGhA +GSGpbYC5fCDrDSdDg87Wc+O6GRB0auOoliYYZbotZyJcgmD/l8xvJshEDJY83pBip5xJ4qkS16z+ +tHEwbNIskX3XEM5eciXsf5gDGN1EIPNCBO+/EeRgRAzU5M0xkJZeEbgB7CutJ3FJ+lxfoJ/p3IPC +BWgaGD4b2OGL1Y7t0oy9LC7NFwzMolAcUwjvoq0Sq1BrqNY2n+uoGUqle73k6Rqbia73GfGZtFXv +GX9LDa+/LpkWksVdTyT+m99w4jKDhmF7aCUUqqfu2kBB89OmrzB0sf5IKTt/v7Nukbn556KL9THt +UOAYrrGzxOnPsx9x3Z6Ckyj66IxOyquvIexX6u1rRENhdzUZuT4CTPkeh17Kx3AXjO7gMV9jDAV1 +7+oceb1MQREXmU6xOMc4naOJcIYGYfE3W8xvIqyrzdcP8euDSL0cUqccWAfsY1vTMwwupLHA2iLR +g3gW2HxeFfby4/omwmnioqLBYOvFbfb7eSZJXyT3hbM0NAFWMkh6tvZi5nPXFNz3BZnkxB2XGJSo +YxQocVX4HltwtrgImLl56chpxm9CEG6j18cmyeQVWeOqPuJ7RMoONKboYK+4ctT3KH7RI785VbMR +C2lyb6xajzq/ifiKKX1G16+j1FeJN+tU9wy5ptaqbg3i4SlCU9alusQ6culierDRoj33FuA3QlgI +T4AReOz7WVZ6fwDBGWCkrmv3z5VHbZP7eAugH6TXMoSJvXt4jxKc4fuEHxfZthdGao3BWLZ59XXE +vJpKAEkROkvYmpbxHvCMtpNt/hptEAu/Oc2lYD1Ypsbi4ap3q6lWkbO6Yw/KnDxwahnBiaTpz5ux +BRSNYhIi6jij9RDcQIuTsxGHMtcFCnhEFnTuxdeQXeSlSctJRD+2xgIwAiBLQCqfC60li31HTAaN +EkLeEKgdnqYOUcBYk6YRu6XZVipRc6H1FnCONXj2V0oa1aLtkit1INxE4bNbM6EUFkPcUdmgXyhV +sJdb/3/5pXFsUytzva0ZdTwj3/Y6345n0IF5Qeijs217D1I+HAQHfIM8l7oNYFH1OsZ3EUeMF0Fs +XPt1fQv6Aj0qGE0emXaTmFg740uidH9r6n3eX4/nUV1sg9nt8hLWt3Pgqwg1SoOb7Z3cXUPWiC/9 +24iZBkmvaE/sn+QtCq1NQVZrYN1n7va2vtMghkQ03xpDWxMPdaaCFmH1OWBw8h7wvKHuNN8+PZQc +nJhBTGu4dFO++TM7nyrlI0WVVN2+Rh3bVgVZ5GJh6dxjjj39dFFR/QPxs0uJRjS8gz0ETPoekedU +EFHoINpwDf7mPCQjh1JgJ6SPnZGNnZGJxRrZKwKYOJ4kAkvEM/v4WuNWnB2ymK04PZ8UvthT2dI8 +6v6FIvWavHeoUL9+3mOfgxqPiIy9uNieH+RfVPS3YmSm/Es8AwayOKWt4+whPW7RqqO3e8Qrmsze +M8hZQXPy6QNR/G/mYpmMGMH+EiRzB80V4AAlidhFvkIB5DwcNy0yIABbSey/Hkg60Xlq5j8w0r/7 ++Mg7Q58pNgH0ipjRqcNtk+xfRyR5aEkeHjr6e1SPwNzAOfdMRgfs0nxwrXHWbtxD0bZWMxlaoU7I +oHMiEKoDzsCC+iU6c+z8jN6jM/q5AbcV+f4nNT31u10TZSLUlcdq+VY8CG2X6IjexWkVk/n2uoDz +P1HD+XXuGhOKuPs8Y2pQHpCyttcUWVCnrdfzo/A01v1D3DCCUseKeCk+iTR2PzLi88rPH5dnNo5X +JmGmRTZPoDuyqlQXysrW55sI8CfUGdZyhyV2rvQeVWJaNwTpZROGTwmJp2XzBwplaQ== + + + QGby2d167b+/xu85Ql4Dd/YcFK/LfmJLdHJTbqiHJdNmee50+3NfiHj51VMmXFPZSsiTRd6qHQOr +xbH5duhZLKF9SmtC1wqcqXCtADrMvJrqIdAvsFiAF7hHsBW2Sb5G/O7p58BLpZZtq+TtPA1jn5Uy +Q9HReRD5LclWqGn27yK+W//egtQ04Ec5AKGuK0PaHKCB6HMzPfe5TTTxdmI67lqc1XWzA9surdx4 +zoiL0d3y2dEaT5l7bQNcRNbG/pZewxq1TkPvE27FCWaOzURHr5Lklv6JhXBaqxdwjKuYTuEyI7q2 +gEDaNRrq6WtonyDwkn0APCu2EfENLOruvA7YytT+6sR5Stz756egmU4k0m27hRvnBggQGzBMdtKa +GiDdvetE/M33zr8p/wB/+TTYyld75u0iWj4H+nOAwlQxBXxO16I3UWPF3otPgU/pJu6BEO0a8lUe +gHCndcURCwwV5Txd59pntBmk+eE4vLJcGKqpKKILevHvpkWcHpN5vNe9e66Q2HQGxMJnjVCcv/0w +KhkOjwutrosOaVwE9LLQymdlLp/V5gssrwcplq6DzHwgZqlS+fdTlyCdvzhwqj3cqA1PvSGvR//w +dDcfmJzahY3614d/PvLnKG7fJ3Lnnsy2Kx2WU1hdcmHr6gA0aHXgy+xelGLcerhsHxQLg25M37LN +8yAvWpNq00sUsQTWmobyY7CHLC5CBe8omDbVNycwJBwwo0lCCQndJxaXzwNXYM/yqDbt6XVwUnjC +VPFAZfFDtrDYnjPVdFydaLQUKihH0E4VsfSV3lwUyVJApVGH8C0qx7uj72kxNT3YPRwgP08oLZQN +AlFymmB65IdaE24mbADRyjDCdhcitSab80mJsaldswpR9naIii4RJtcU2w5qV9eh5fKp/uAuScKy +YdksKgjyIq8X55CKdsZJaEWgEve60qBpBk0a45LcT/Hjp754uJVd/tvVk8Bw38aWJaiQcneSitHr +mjdgE51zRlIgFPiO2AsP4IKm34BZTkuZ9OAo5VT2dnA36EgOgAPHxBHCiBu5jKqAwr6SHZOBpfys +ujsYxQZiANHonseqIBbZR43kgvTcqt3mWnUKvx93i0p92/dC673SmNpbrGKvahB0nZstn0Ez0A25 +c6HJWrcuZFnmDsfAe6TsQ/FLI1+J9kLMmpD25ycwgZrefAxe0be56ZEfoY+6Zauw7eYPB4C6q8S2 +Mrq5i4Kvg+OOS0XDSKvkF0UHhOt0+48DhCJUS/g8bAXpm9H/VqaE+/0a4f1S/K6kBKAKmMrezoNF +uKVKBNBreWd8vkecG2reGO8byv8ehQ2ceLs1jg/r4tTNio9IJfR6RUm5sA9mlTophaqr/yUivy2s +T2w1bt23vzmPQ4T3jGm1xYVcKAPrOMnfewDE3Raz5oc1+x5FC45ieRNbsO63Jj+mxWPNhs0cpWxh +YnQYLxKaKxxDZ81C3Xp+/iYX/YcrJAf13auuCStxo1YDPkxoB8J/urKXgIuapGiOd0YHwrvnvo6Y +Nc4wNpSGKBOAE/gqCw9348JDA588qDql4ieEhUYGKd1y7rcKMqlnCmVEyA1E7L5fsibHQ6EiyjIX +bTkaEFUtiUvr8tNmOKqUeqKQdrToGnbPszJSXt8iCxHqj7lbfY/Ib/M143k7DzQWOZKAXy16nlvF +C9UudoBvEY6Cvi27X2/616irx5VzjbtjjH3DMzd8b00K2dtoA1NQp40ECojWmLSorwG/2xAmuxQ4 +mzL1v58GpAuLMEgXzRpQDpTsuv6oCR76QrQOsMPUAuk7e0BAKEHMUIy5ArAHwi7IZQ4xLBK8LCRL +sW/YM74HKDXZttTkdgt5C6LBCYSlp9wOPpsUTSQPHR2Ake4H1vwwz9iTTxr9oKyP/vzgF+h9Wnm3 +0h1GKVMNSZ6NUNFPjCVo/fmKwrCQT9SCJ12qSNGdROChY0SkFht6gp9XyupKe+OOpvA9deZmTr49 +zwBPTYTQxqMFK7si3H54JTalsGUlxBNxSWbpNDf368LKRTq/ntQ54gAv1QMnSzcFLWVw4YkbGLSN +ZCu96m8i6hVKEzyq+nyltyhQvgp0mQhdTr3yQvTdVV3+iP7betOkvJai9OP7gd/tLKtSI2ArQVn8 +LerGRVTdsL4l1tjKrrn4dUDr9aclv/9UAm8EZAfWBuYl9Q3AvBuzyvv6QQYz+QknGT/MjS8Brymj +w1ID9TbeT4JIwhXzBjYpSDGwRRMgNCQj4tpy7YfX8/AeB12CqOkRREM8uj+oEaL7wzbICAqVs8QX +XTUXQKLsXzKCSxpvnEPi6orADYuIMp5nTRRT8dxtJ/WDJC0hS7xv+GQvP9ftikmXMTRUGJpWsDDw +ZKLAB3TGV/Sglckp+oMyLXvOn8fQCwilJe29S7M9v0YNy9qIh+l1BuN7HDzTtZmY5HNvEeCUfSyM +/P6sG1+jVKcE0Xkg/0bqfKdShHPSfT0qqVdUUsd6mrcd8uv9gCNKnNN8P3jBsbviVYA+NZ0y5D+b +AOBDx+ZR9+YSA5Vg/+eGRd861LI/jM4P3r+nLgCQeYGxoHITivIutGCdg5+MbHvcXZjSgDXQ3jlq +NhdjRp1gzWwAzKTWf/27m8IjCKOvxwad6hJVELVjSVjW1/z8+xl4bF1Z57kn7tdBEPEwEUHEU1IC +0dk35QDoZZmTt/rDbOcMhPypGUKy0PSCvwmQRx62+jXWZDi3SK78CDbX/r0oNtMffoQqJ8/Zpj8H +D5AcksY/jPxTjMvpgQjYM/sceVoPa91NN7aRT23upM8y83sc1W9IWVWg3Fm2xUZU1y/sXusPB1A6 +aQ/cLn/jF1x/E7UaCXxtTEDPHULHvvuz228kh2RGfDmIR0mPrI7YGvXNVw40S/a+3Hie6koZSfYd +USUIpreDf5VLrQU6U6ZdvkIraL0KVCdcCpBwUJ/1DFD580ALxETfpJ3dvw6OI8pcWqhdH9cVaPib +BCHLBpuBm+3zI0L2JlLIpgFZADYNYxznN+fpVwAlNC8OMdnUNRC7WF8XluF7xNflI9XHr1FYIIuW +RtS8mKd005G2ZQt1IOQdOqQ9CttJDpu6eHRotqIdIOmAAsDOovqEJkVTTAYLVoqia4yVbQog/Lmt +d8K2343kCRVXGD7uKPGZp0gKavBp9pvC4J+CjzJCZerOsZ+eYjpBzOAwgYefQkYlVPi1d5Xv9Ne7 +B0lOTpWYJq602QsXG1pv2AtSRl8bXuSS10bgSFobegC0dB0rD9JGLL3W5c75HpF6+JGtOEBqcRRv +59H9mB8DD3V3jGO7564Hd+m4/TUCBW86mbSaH0rvW1CPTFDkUS5lXrsq1mDZZkAFFw+hd2DcUVF1 +1l+3Sptj2y5jONiiZm9hqmyNGZRLNYW92TwiGMZqUEOSV0GMCgKtqt+Ebz1AL1mb7xzHAufwR3Jh +iRg7w3iNBNdVuqdDa+8TeMA/7ChhHSdM2C0HFOsq2w936tsAwtTkcGqc4bUVZCdHXrwmSq6urSDF +r7q1CvCueDJZHILEJqBkGi+aDUNea1w6A8i7aZvNYkeme9YIXbe8FdIPq9bcKbvgQVpV9pvHxsIZ +5dZlHFG4uXtmr7WHOfDjtieDshs9GYupbKP4MdhGoUWbBsk04mxU0e9tPOdG6/i8EjwNolrdWoRH +aEKzmDJP0KSiahAazPAvdKSpNrAXjHxDvoka6eOkCrHPT+3klsoEvEBrTTOdeT7d6jUR9u0mMtQv +Q1akCwtCx2TlT3JZ9nLWnPj7dt+0J4gyFT3B887SIdsZ9Y3zwdt1wYbnvI7o21MhwQtUAKOd3Pu2 +T6vumcm7HkZ0gbaYoKIC9VJUYAJf0Bw6qIKg1JC4OOPZIRaoYE++/edG8JJgYXUhOyG247r0MqQQ +VanM+q0qDFFWvE2g0C8KrMYD0vABitku7/hC5QDgf85bnmzHKFCkHXBkz9Xj2SMEJfdnVQT3u664 +DxFTKeH73IhPoVd0Fa8aHzWBolzpSWKEVGIfDaRy7mxb70ucgK55b2r6tMt+qPEHGekO2ggTR1Zu +GOooo8iYg+b0bCPVwmDjItNFqyh+0DSc6fDRKGbwxfftjNbHqVcC5h7AVcQislqJC/800EgXubHV +aBo4dZo3x8TXKPox4NN6E6elZIWNTEkXAn2QXYyksfYl66/zyaMA20u8QMxibsezOvRbXDupI79A +h/Qz6OxHeuYoj7mwkja0Vsa2g3314RvjfR1a311hhUvBLsCFFNL6eubAM42gfIlY/dzww4LJG3B3 +dAo9PWpJ9iiu9rqAhqpkZody3VcYvyzeR8uV2MUJBSjqjl5RCj8kMMwHLJlzRNQY7WGwsgLGr9eV +7gwvdmHT55Dpm0pKEKmWKizxKMLc8pVoIR56PN7JF6gCUUvBGzC0LBo+D8qWjmDZCkETYysAbLHs +PSFjwIaQRTt6tPPW9zzTdmo/sUtWD5W0QWc+Hc0uaiGPhPqZ1YrCN6YF6r1QHV+pKFg0r0QvmivJ +EW7ov6HagTfwPLYrMUsYECz627ANZ/+ECUeG6SlwXI9tH2R1MbNgJCDMXl3hcNYJ1UGOwNbp+Zp7 +n1ckfw7MEsueTW961oqe+DooN8PigJIMJR7b8IXKzlC269InUB0tnHspe9uLpflkCe/AOa0ZpW0R +wPyrB5sMcVcqFmp0RuAYRkQEsOzhgHwcTasonVSL4P5zPPUIuyKil5H2fe4HJYSOdu/YjC1sYmFs +dQOsHa+rH9dD6ZKODkOr5xQ2o0CVnU85QnfNU+mcvCv0uiSVwR+afLx27S0pJ8a0UXSd2HOxiuiP +MvmoH8UEdoOz3kAzHBEaaI4j9HN8nYDV4OtkrU1pInbz03zIrY4oWTKSYybJUToazjfALqQnH4OC +5Ddx0kyNhKbfTnxcH02NakoXupUUpo8rO45/PQl70rpvNTgKTM81yf5JpsYBD2IVBniQgQ34QIMd +mu3XTvwuZDy1tVxbWvC8bObITe7NBSF/An8mVwZBUrgymtocD4gdWeWtAlg2So6DwvEodaH77UEK +NQBWWGuJuA+x6QC1aiJMNwv3WxKhPOzKCrRmB6IKHL9Dzy3tdaX72mI4+rbDcp77Amx86h1aXZe+ +lvNelDCpa54jebm4EuhGW8fKlMYZjdZRDyskmHGATz3wOoSdAc7d1IxUL5xCRYH1DPdpY0JiXLNN +344VMg7WBuNCeTs7tTOtXHYo6uQ4wFBQhgsAoIakWMooP0AMui6r8uSid8iBcpbJbUUufiXLJJM8 +wiFeUXaDjWIZ5Svhxl00DcGABZH5EmpO0/kX3RPmAiLWBEoEtVACwlzQl+1J8mEuNPPOC+pttbEU ++bTYTKtadnnDYPCy8dEZvZIC7gvRvCN3vbaSm7JmdS2pG+vEJneArhkuEBlDYJmUwKRew8PFuwFs +XbWl1XoUL3DWpfj/2+/Jz3/Gd/ME5d6y18b+QZFSlpl/yMETWWYVTDVJVCl3WjjSAQ== + + + i0+B1ax0NtbuiERONS46m039VJwh+kPOs6LDQT23q3by1U8pcAJilCwBR3CUVKRQy+OvsWGDAPUA +yyg5uau9NvSpAgMIYxOOq/1v+jTgweqxpf41kF3ZVNs6LVfQNVGlJNNGlfK2qNl0ZyExudc90r9s +SQiPJIRxXfebYYCN7AUHKX9BHQVKyb9vq0vlMaKdtMk4IPue06qDd9mPf52tqlBXInq2Dh4IcxOs +Fao+GyU+G7jYE1hYujlwq812AlZ8GJYHguokOD4nPJuhtVnk1fe3xJuTlwNVZKGQJk3b4KuIyExB +uu6CXm8p3K4ZADLShzzrGXkCEuUCVpZ5Z01aCBeqzL4fsYns7r+c2e15Ku0L2+PVOJk5LaCnt7DG +ytDBoYfBjj1Vg3kNGNO9D3JXPV6NTo3Yws376Y6Vn5RMmkznpA30Oeisl0CcAhZhAsZtPb4ojxAW +BIcZPA1uD8BSoPNmS8csUJDZfr4S6lxDVEpz4Qd5RINHHAMwQeZyFn6+ITQuI1Q7xYeAPj8VKkbZ +mnzWtNGzw7yMgPr4dHiPnzCht3lV/VG4P41caKw3z2OnfioiOvcelIe3bpj6jRHcF5p+Z0kEmKpb +Qez+upBGv7PHR8rtItMF20Wxq0RQCiCi769EY9cbOIo3oJEQX5VVtWCN0J/zY/mIUzrSSy2ieza0 +MaXkF2ScCJHGtwoLJM0NuDBNJW+NGoKmOFekuwuipE+Pi4rHYf/0jKgfKV5Ti2LlplcQEXa6EV7l +DpAaAFUD/J9HDgd9t/aeBInTliOOlcLe4PGx32bMKsuASari7ezILXTc0Qq8790bqcfj84zd0W4j +nj9ts9UStzaKUes1593TC7pqa/1xkUjYpUEBxArJqBQUBBQCDlM6qT6CIqPD0L/b1qKpOwOyFr4u +fZ+7RF4eH/qVi/aHHkyJ4ty2tCQD6E2sV+cD7dtH70UpIErC6ApAxtDD5tpCmtVqTX8Qi1Xu8DWD +JMc/ExzVnc0SWIW1HqKiLYQZqZvjihvZaX8Nz8DxPC7B+IqJwabGoQmM4Lx3/Qno+MpbkMShd6bN +xd7LA0I+71hf1JCaqzwn/g0zkTLNLB4ofUuWKamsU9OmS1wPzhJRR4TxKH2s/T10/1vG4DW8tz+6 +3v45E2400O+SQpn1XrZkzPQs6p0CdIscZpRKYVCub74mdNPTA81rlCLWvIF6lm4t5+ZeT5H3oCa8 +Yw4iP5tKDgDlU5jDh2QUKaxlkyup3qzxwww15z6guCXcrU3fd+qp+6D3sA4Cr+cA3c6apow3ofio +BTLrEtvZG677sd8jpiBTcWq2Q/1CaLv3B2+/ZfPjFFPLbKMdjEQSq9sYXWWEoDKEvNSbHOfQhbbK +v7hoCPafutklb/8lf5V92Us3QyoF7WC/wEpFgS6vv5/HDAERIooHqPpwABs8Dyj1igrtI5zBLukK +EdUhzsF8SDSstyBXduKsXjygyCgHqhTZtew+Z4Ndxa949J1/X6BFK1294j4UwjD7TwjDkCJA1AP7 +K9SWWcXAD7zAVGhZUWGnsUNFi62wTY/1BLgZpE1aQMLrDZuR7kZdleoCa5zM/7UXB+RFI+d2RMyX +OMvxyAIUSgLB0HcrrSxHH8BTLunpZEfS4e7N4VpffaJeYoWUyZTFhGoK7sZAcBEeQtkhqPWacpje +KOdWjYeVp3I3u7ULUtKmEIrabgOeocvJyvUF2NGCpKIJwYfWC2bmL0AgXW+ajLcF4KPv/gvl4SM4 +WCwTgOaqEggnAoDsRQfXVlaLpsyaPMfzgOir2kBb4/5QvmNlRcyWVOEs7HP/a9wD2lSXFCc1gBh4 +pj7Uz9MNZ1M3NU4kazWj0ES9REccKnLInq8RQYIImqB3wVuwY2i1iML8VERU34SyxXpzb6wpqTkK +8QCzTqdrrU8I0qs30SCYgT1av9kul9Hac6pXNYctM12Z5mIzo+l6BAPDlpz6AbgIsOsMgQ3uv+6N +L7zIWc76dgwvSwHbUlDPEgrqPnBuh0ZX7XWgX3uHrgOmFYtjT6z0dxHAvCOB4267xjQBIyjuzdcr +bgdwjtAs2Uj3C83KI4UKa+64VVKeYvd0pcTJK3/Vra5C4syryCLPfXiSR9SDZym3F8WBle9cbC1K +EPsqfPOqMkRYXwVKg76XL0JlY3exJqjOGmi+07DF5fXaI15z1UjqqsqAfq7YEBxKirvcpxOvF0hJ +gQTPcl5KKv0fE/GWM2zbVE5Ara9f/oKg2KJAbBOBunvfxGHU+XWP1u67WDDu8h+PLXWGZ1jdYhiK +SuCweIq+krW/ZgHEdFhF1m2GXEtdon5uUWS9zqaGQW8pprXr1KiD68jFmTTnRSX2pGONttyan2CQ +HVdY8J12TkOIeb9mKHs7QPXJLjFzodaRjecQ5GjxEpcfECr9jtAlDllzC2j2l+5M3QophS5nJdh8 +VuUgRU3woFjbweF3H7sUD1GNIvaWsB5qU98exLsRSYcCr3koVBDNlzCiR5MXDgjUWgEiEDKY6cHv +Mj00imuLs+S1HTFfGVBgW1TGJaSt3070/ADAuc925PrXs+1ZE4bKmI4T19mmLeiHBbsjrpKTyeDK +Hh7pGWHDa82XyGZBDehoS+8kguzjgeX/JA+F0nxMBnBdFVrFEhTlIfGtHdLLXt+bPZriQoVSL6kL +Ze0PCFShNtY0jhHHVUPtwnNgRsvd3GmIfMjprq27iKAaP35HXp9WI8IFRz4VPwxE8ChUXKkBeMDF +ELr9+Zyt7/5/SqasOoOPwHHIRdTpWK8s/TEP7DZcPALGdT02XxcOC8EKaGdoSV3UCsXQHs4bEGy+ +lCracEXU1eibDI6m2mOMegQ8Rip2KKKOx0sesjD/lVIdQ7q0FFZec5qPvOZgJnYXhSe4fetjS0MW +6j2tfHQ6WWZhLW4jeIfZH1vmg39Ima9tIUC1ZacTqo5Sije4dU1azQywZcxTyG90/2o8qGJOtZbi +tllBHT1HfjB6EPDE4HqcgUxFv4n6FLMaFZi2nheNA6cLeLjsdRoIpfZJ1pmZs6rQ6Qoqh3oL41i+ +0CGKOph+wQZ1ms2xlZWSkR/0dmbR96P1CHCY9MC1P6SRrBmbxF++5q01E3pfwYOyVIIHnfzAs6YO +vr7eJZzb/XzPfl7F+TkCFmjWuvaW8owQL5umaJ9e4CYuiwYh/vXTKYrdcrljLgrg6F92zUC09roD +ptRwh2A81PV9YYvS3hePv17SfgS3HeXTAt2YL1L3V0UqYSsECyBcQ/UCN5AH8l2UJtq2u859nucA +VSuaZEAiHl7s+qj1mERorNXRtvi8AF2JFXVu3NalweehYH9OcwtFw/NjJgKxzWpvLXewIcJn15qT +iDP3yMrxutCJ6gH0YgquIDQoVRLFS1iUJAJDgDikjk2D3+ikxM4Ww4j1ovCNcDvNKWyQu6loZV+I +TBAhghs3lJj1mBfAG21m0EIwJW4o9SI45xbmZ1+ZHF4JGapecGNAN0uUxT6hPmszUeQGCi9p5T03 +SndtH5uZuKxLeBttXec2QhIpQiaF/H3tQc4zF7jmfJ1X7Rt1RZregIAjqMbNbDBsuSoBo7ff2RV5 +Ammq6OmlnGoiLCF2Z+vXBgZP1Rt8EFUCikqqdqLGdvOqYmBlg44t5NXeIZLskC73UG4rxpu0sr8D +SxaYvpVW4dMaLecSzlSmgjW1CuAvycphBDe29CdZ1BGXgHI+CteKAHelaC8xojXESblAI2KiciXg +S3bpA5SmW8xqC63Hc0asYE2RFyB1zF6HVfn1//cGLIMF7GBnVp7WrSMgasfMXnGDOb9DXWEuycq0 +nuiMdNB9IcrVcR5MBUaRM1o+x0sNpGxp1ydHxCCZKRxhLpI7AsRtgQk4ItCeAhRugM+F7BYjz8a+ +5dpLdgXx8OgoX8duQXWyyFzIFhT70aqSEf7yoJp6S8GFCP+sMRrGDmeuP3RNxgnl6ZmLO0RHZp1Q +zQn6GojkVliCdOdpXyk2wgbwdM6NhcQancV194rKxvoqA5FjqGfKODqYn4ozKBs5+2tqRuuSKNM9 +JhUY5EREvQiSRgLS7JE86nH1TgN3q/79RfegV0HiIcYBEDtJNxMpoyZtPmySeq47NDpe37BEckCV +DcZVyymeJbiIrRZ6tAYYyz7lRwoRQ8MSMa/VZBBnAAcj5umUf8mfYSSsfKXU7Vp9P4RBkrSTl6ig +zh1fDnadaxkjVfclVb/qpPcspu8ODgbBYmBQ0lcyPdHxK96apS/EHY7zmebKwzQisSHqeKqTOvN4 +JQE150Qhf0pxbOiDqK9Me1gtfXQQEQkjIQWK7sbbkb0fVR/BxJ1NS1hNXsIcbyizFvWhD6r5Jw4m +PGnw4kPgG6+sss7oiHLZUf2pW4AP6C3Nh1FL6s94Y07XSW5uEULWHzZEXEgEEJ0cer312j06+6ci +nmdwHitBv8+4ks9UXxvU5f2NasiQSFZI67zGdl6mmQneoz1QUp3Cd+EYqkuVlK7aAo6enOJSmG/2 +z6VCMkz1/Kcy/Fgk8xs3Zu4esYbLevQ2rV7vCSP2u7NK9lzH27V38Ea5opDTzk31OzfVjxeqU+gX +hLlexLnJgMm1wk0nQrAfMsdWdCK8Rip6Qsnco1mf2mLrCto66aeCJU1IKPDxHtmF81TH11GYhEoW +g6tKboXpYfikMRXWJe9FpW5bjHDtQoG+MeBNQmnKzmM/F1R3TssxscrIaYZYNt5JtrDocNwBeNOT +dQnBwe6hJd6Bb4+bp9ucE32lkTSzwU7qISP03GzBg+Yts43daz7KA9q+rQ/lZ5yRSWF7V9wOsA1n +LdYn+HbxPul5oZHAXCVBDFGhA3Jclam9U2xyUcmON2sXFjDw7Z8cargKge2ckTywq6mRyBnqm6qZ +a+5Yq+KZmo2ZOo9mU6Pd+MFusjZyqPH0uZpfKWpGr7cI92IxATSpkgL4f56EUuLI/cFTHHCHW15s +nRFpAL2WVKKA4RBVnYnb3mWYakY2sCIUijrwcSZC8B8aHkfLlZqrJSj9kSttYH0oaM+VgmPWmfpM +lCWUg6HUPkI6QBCO/auTDMaB1fOMLh6jBzS0IqYOz9jVqFS4nkV7OJxrbmJE23b2DTpHNGakw3Ol +C6OES9uwQXcETUY3uyD6aa+IWp7R7oTPuCKebeTaZR0/4JRMW+h+zjOGtkoCQ9kT4RLteord52Gd +FGUX8N1rD9kUpq0bnQyhmD9EgBl5RoQHN3ASP1GF2Q7Iqa6XEzuyygqqVSFoA+tpCusoX3FtvzfX +Yp4a+yEZGIBcwcE8YtyWB9CQ7Vvx5YaHZBcwOxTKBBZc0ayqI6dxF0krUPWtEgUbiTwsacBQ9NLB +bezlKIHkiABHBlf2w6baa7tX7g3sCtwaEkXNxhhJfa2+xtYRhch491OcQfjJGoKCqt1NarWplKBd +A3u48z5SVG1AO8rWKTUfF0Mwcx7aa02f5zy67v5bebMEaHpd8Av8AaerhiSz/MiFKg== + + + znUNJ40tb32wlrPvOo+4EVt1bTg7nRFWvRWoQmU6AQermx6W9SmblMCVOttKZAtoT0JdaMD+NV0c +mcpoTWHFyUyY16MBOegRaRqqs21bQTpdJLYNmOsj/HFtvO+o6IHG71kRs0a79IpqUzQXWaZ5mZHB +pOgH9sItoynrVMZpplD3xULpdSUhWBWz5RkHptOUa00pTD+2zUVyoh8xZDIMBal6tjdD6bYi10OF +W9pWwEZ/3gMuGOmbkvkZCqN+CVXSqSNbIN4a2QJdiFCjDCM6buk4M73hZjjOze6k0Aa7k5H9QHel +d0NVFESkBB+JC6lgjfipe0AgDAOIDfuxsKxzb7rb9ngiRQ3iwtnzQdq2qD9Z4JU/eW34iAji2x/X +Bb1jnNFirRFHJOYkxhUEZl+/lQNZvAD2KHyEWkZ7/JXurUi7FrPRN2bVVt9kUzssm0Y7GBmLGXej +mkamLhoo7cJVYaNqMgA3qO4cLHrA1YMaXxV72rvdKgdjwkCJy5GTDKuzluy4Tnrh9QLOY0fAmivm +OefrAuJoUC6Pl9Sll9SxmW8dxnLL3/WJpf3fSiSPD7oHfUbbhwitxc0gXiJp7MvFrq7fFoAKWiHN +LRRtxHujW3XHVJUvlF0RQRey++FizL5VuvsILKU+iHwsqJtF2XVfV54vTpmMCLzhnW7lDcEjqVLR +g3QBaO7WFY+fITGQ9NinDNJon//YstmiY3sYojRbMK02/aIrbAmMPhXv4zHtZ/PNXBhXWtvkojAd +UyxaR9BN3mQdonKMiY5ja9H4q38TGokKtNizndu+nsyRoKPaPW5bRG8ttAjrexoaEZUN3Exn4grj +ZAV7mzWizesHBKCy6QAt1YCOl9aM7oF4VDDJTf/5lnyiXeSWPaJPJzgzTc/ureTMsr/mj7JtNJWf +Jdeau15Awbp2W4KUSapZpnK4VLHVtuWNOYYAii7lprWsErzhJE0255VRVeA86mBF2a6VLb10d3ss +g5AXUnuybwtl+Jsgtii1ZJPcsZCJ0qhFzLaWkuuOnp47vnW0g1z8Xr2DQjUvHr03sTyQNMhjzyNU +jPXUKIKZeliG7XSJKE70KedMHwTF/TU52vXZTrdnsGXVhi99oeOwL3Q2EteGcBnVtB7LOQHLNjaC +BP3rvfOV+nM2pa5MtIJq1iinipoXNLDyGeGqYCnSAQFARcDYujhN/p+4hg3AqeejrEqv3byevpKC +uKrRUciCcAhzKPJOqBWmYBJTcKhFa/dww2I8NgobwiMo7GOnXayR1xXNZZuG7MzJ6mdLT1sxxEtt +Yyyh9NkQo4HYSXxy1sk2FPxExWGL4lYPFtVQ7fZdz/LCVgrVnLWV+qPIoz8nvOnf/VFz0D/xRL/h +zpn/FP/znU+mqBVKBDBnGq+kcHVWZPzay/YsgjnD3LOiLgrZb1E+LMHnFI2Ur1FpPwdc33mKqelk +FwRu79nG6QNyyDHEhNF9xcQYhVWB/bNOw6zWo7ll8BU3JWpWEaP02S2WrslQ6HTbgOuVFhwvBvrE +5l6VTLQCm1E1arlkptPztC6kZkLREqZxRlFxuLP2FNJpZ9b99vRSC7NJf13IJgNYj6qkeMlqqGub +TNUS5Azl67qFHoWoo17NvRFxZrN6ur8hQK8ATByeGsG1zZfQyru3TikDFo0iJo3hZpp9XKA3QpU7 +cmA0bjtFSXJhrDAfTmnNThEYvJftu7sOBrvHX6IlFYILd75bdEhhqIKVIFXe8XJna6YJ8rEvxPLP +M6OIEnHWc5vKDKoE0QB3ePa14Gvwh4F5j8H5OWeeychyZgGQNXYbqNOYuV4rURJ8cM5013UbPcN8 +k0RZcJiNRHSk4WdmA595iZpyu9iVHBhPqEHPpHW+LhCaeqEInwvkm0z48PvHbYAN4OGH6RMgx6Rc +0HMrWS17jLDmJrpPNZH3lhcHVDrHFaLbzApaA0FsygDUey8zQAD40ZAhVl21ZG1g8T33JvxXEV6g +m46jMLlSyfObqGrRc/pqjrl/NPti4B7Asn8T4TNEjxgB6H2lt6jjyqLdSftrtPTWUgU261R/TRBL +F31VzU9WDt2O+3UgXwDUBTXjC6ma64dPlYguYGiuzyfqxpa01g9lEalrX8VH45EnJfUxrOgtxPV2 +2SQJozUgEX6mmo8ri3CNcDcgwwoOQpSRsdlbNmcrYiKCJpNWMBCNj+PzG1jbw9u07tsYxb30BdhW +uJlt8jUg07RXJUOCA1DjqC9YruUCJLxc4GndMXVGeb5ujBJFSKVPd7mxWfeOAPQlwefrgfDUjvDU +NrLqm6i6VXQvVMJP/czpB7CeSJAYSIHBmsJGEWmgZl7SdkTbEePxf9Xq+O2YfYLbUoeGJebpNtIQ +kYqn69eIb4fkWxS016Y3wDgUj8OPjRYsfvdStW6FJxmSaC/w2gxfb5qfWw3AIhkbxXbitDKyFDhd +gsbedTZImMwUQl/bmULWmumuc4MFjILHjCCEiEeq0Jt9fdo/JIJZkXqdZXQ0l0mrMVe5hF/VVGMo +5z5vzNAH1/NmTUDlfwpaXJtgfn6rrPbggTe0RIgdZGagw4KN87UPSDnjDXyo5gP/cgqWgOcv15OA +kA/JU74Xcgyx/lFYgqVbJye6/zUPJGoAR4Xu/h6RWtAmveItXb49D1s8y1Lab2UuSeF77R+vEhhv +uyT4rid2R2fTbQ8JS31k9ogasmdpKyQhQk2EKMof28ComjJV62ikTGoE45r7kJb/1dTrX004/0QT ++U1gZdtruV1LoYgoBOi0FcxN9wBe0ECn4ABzxdqHew1Uvrh3XJ2C5sBAZST1lmJ00BnaewCLiPa2 +42CYdBpb8BehacY5YfKxI0r1AQNUHEXPoJzxPeU8/U5E8nXqRbS3uZIqrTAwj1xJwfIBB+/ZI5a5 +kTRrtR2W4s5UzMp2diGZ02n12lZwA/NaoSu8LCoOdpn5RmjegPDo00ktYh8FuDTxLHdJ13hAakbG +01LchaHCOQOLLxudhYRpjcyfzp+o23bt5LY6ijby89OWzuo5JaQTkFXR6IJS6so4rwjXqmdOu9oV +Q49rjetgaHZF+y7ZPWhMm7HVaE737S//oODdNq+oWUvq8rZBu0IREf9zueU8o8aJY7u/UMBPRCjD +OOXiO7Hechy9coGeZjkH5Yx11c78N/psuHWDIxPmCjUXoJ4zMRHB66zRVR4x5e2wtl7tI8Nb/1LH +q/trspox4hZ2ScLtCO7z6H/rzfj5z/k2gsqmmw/8nx4OGJton60pvu1dl5BuOPBrSOHrSRB5L0Fd +Zx3J25csgkEBLACjFoCR8ongSVXJhTZ/B+4TjBJaAP0TzFM0XUELoG4I0iVQie3L9DyRqJxuAnYE +86zklwgLu+E54eYd+xwH2l4rwXoA5nRoBXlRo738TjVuoOWkLUbrlKIbKIB2IKq1K7rAhs79U6GY +Kp0NRxMAOl8jsi8auwHa6tA1+GsU6UmXC4/JIjU3ah8wXNdEdsQycNPVC+6xsk/R5od9eoz2adIi +T5wojH2IWieBo7qGdIm1izND34LERLi8H+DCZq4UHYwLyc4IeSi5R0R5FXDHrgBSnKZUjNxHNB0a +ihZpdbihunDzunOeXhUEQfo1EYMFmg/WXAmyMBE0KT4bX2k3Ia0IU/FR9LidJ80MD7VreKHXk5vB +2JUqHZeZTScsGYt61o9oMJMeYXz1rKJ02Vk0hF0AoBOLtYbu1AMSRNSupK+5GAJgtyWw/yyC2xIo +xM2nJfAc3FwnpBYkzGBnJDqpoPSrclwQOuvXEwN5n0/zZL2U9jS+RPxu9zSUd9Cc5PomSp0DsZQ1 +2aH/Ds5Qpi1e2K/s6HWQUW1TIH6UeYZUntkmjdTTN89ybRg1zTkiYQt0iTwPOqS5Cq1k2i1PWVv5 +r65wdaLWRrA6aFtJVrT7XzSCQ6vULAK8oDiuYwO7QPiyC1ZjTDEqCOHts4COmC5R2LWG/DkSBX7X +8wjhUosX1CARZ6yjBbGJ4j0f3ij6rDjZ7nShulwokAX9OiboFmfC7ElbKs0+uGVo4fLMVSo+vLPv +IjbtrvJ0HkOhtyhISgJ3Gv6kefiDynSX7UCTbgYaU3m3mHupOPLzoR5A4/5rQKapbfk51k/EfPx+ +GrAM1pvgVdO3OSgW398cMG+jR8e7/ag7vkdJKSBDjvuaeg4YA1CNmj1vm+1PMt4xI44oPWQ8DOj6 +yHWtVf9lhTjCGV8X6lLYofjm11/j9drgCyYfYBVouLyND+rru+LV6JHHyL7aabqVJfZK0ExmnNjj +8n6AZQmuqwimAmK6pVajUHrfviEgqazurUEDZCnUYtfUC8e1fQHFC0/hO0ewv3Q7becEXmUFXIAY +NTAbPgUR5goYRkMU4amYMK1RY3dY1jGdyYqwzeb9GlX0/jzRazNKsmlN5RxOnwArbChVzZ6hudUa +4kbRiBl032AzVXKdosxuf1kwCWuihQesSYUkoihQUaW74y9gHe1k4WghSaf5xfAEv+gpeBxusU4j +elFGkK3g84VEKHGeAzX9KOiJiWMj4IM5Ny55UO49A5tWBJVXWIOh38iO/pwbo74lOJrGCGa/lgVC +NO4/5dh4BB3WwzivD4j7wzzp2r1k2AhreI5tj80Bu8sUQkpLmjUQkLn3QVczeK/r/K6uMyJ9Srpz +OnSjhhYDM7pLNZ+42q6ai86peTqMbc5i6zAgcKHenfeO6yorIGx8eIB39EWTUp3ZkkD9APkoq5+R +h8QPRHg6ZKM84hgtgimFgb17Nv2OX3fTJIn0EiTclAF2PBT+CyynKzjsqDtsxyaBdI2zQul47+TB +tFKS86B6xRArLvnKVyaxOwBBIFllH1Amj3olJShwTW0vgRp7ILEG7mjaF2/2GzkwNrSflI2VdW0p +uTfFQzQLsxPecEDLycjCBCqQbFHxPpg+KoOC1Mt8wDYnKNp1B8/f0XLJ8g8UctecPCgYGKQadbi1 +9R+4G1WKXNOS03rIU4jK9fzTPhly2vMVATbrkjMDsB/ADnDDdaM3vAUBaGhO1m0YcM+XZxMZP8UH +8aLRsZbBY1vhHFu5p5GVVFiXtWycza8OcEsvQ6SvB88jIt18TSBea6K88GbJgXMbwOQ12X8ie2oC +86ktrz0rPEx5BPZb+FXONX2cJ2zbiM08jRgP7JxBSQdAFxzsVw6KYAROEEMgntMjjs0HUZIr/ZsI +fGuqC6yp3muT/Osodc5ndM7XaKLnEm3xhlgNKyg95PGhZdJs7wf2rzudLL4eVFWiBZEDYI6f6wZW +AnKYSeS4Nz9nfc0NbRBUzPuEWDJ8qgpWa+UQV3tG+hFG6HqO6226AB/M/FV0Es95b6xgOql4XY7t +sISc23r1NEIkeyxHeB4cQGuO3h1DxtO5Xq+L1J0AiYhqeWsg819nCMXCEqgXVXHJTbr449PwqwP+ +yge+JYE7BaJnGtl5xjArvfba45Ck4656/XCgBrgpSGJX3T4PUvnkGR/rFWqqlWTCuA== + + + 9pJFy3K94xAzoI2/HfArIoDfvvmUJpUZ6XpGc8+M8OfvSjlwayiObXfmfQypkgpJCCD8XKPs2v6h +196547NCLo/+LUZ/bweesVuRlJvoil7ffJyylhKA26aUdm7XF2Wd9f24yXSJ5j2mlK/S2B2y3Yrp +0aePlMxc+aPlnfroDYEcvVRpVQMN3g1GNHhTqrP69YDPhG3jdwcjeHbvhbUfWVhXAnu2oAIAgyl1 +Dv/uUSVEKhFhghYAC8FTfhf/xmYXOACOEIjRg5GI2PmI2PmzGzoRgSr5lBCLovmvn+q5qbJTT8i5 +tzclR5wDsek4eem3BNaktj0iA+yzq4K7VB6brMtrmTeBWc9prYRrSbz2sPNA3Qe2Qf3Y1n9vB+m8 +mw9ABIWvu3YlF5uJzwMlEL6C2s+eBF8HO6I4iDSI76Au4B4c2gLqgmi6qoXd8RAgoaGqtztf3LCT +EQc1SFGg9uJTajxwAEF6DsD+8wCdKyV7qapiWDE2LdeDJN5WlBCP4l1ZT4wDZhfoONGzRjyKmp9P +zG9x7m0l6pN7WeJrm6ShUY+52voBGNEfXSJFV7WpWHxDDACS+3MAZyArYStTmDsZfB1UCG1ECI26 +qN0S5tevKvxDK69v5Pmf4YFKQg6qzcBQPwHNHGZm6ybcWBTAMfhjsKW/xlYI8/FcUlJ+ziwjs94f +O/JppVBFW9N13FHg3Vo34r1dPwXSqd7A1wO/e/oOp24bgH36exQ0v/AJMUljUSQfpzhOPo4G03vE +dzP3W1S1VcOMNABwYBy2ZcxXFK0w2HLnIVvu0tVHP5QS+Jgg97n5j5hg0/H/eRdnd8m0hTEHLJrT +sF2lLdFQfBAzjpg71MAxraRS0oc7ckLhLbKx9IhEjArwRHagxzYbJeFnokLWnr0nvomI4D7Uh7cD +/7J3yNnSX9fo5f7m42tqBGtzc1OoaagsSAKKsqBef8Ct4HKu3Tpb4/AgmeopsffHcsGotqPKE2Wd +4IIvtc8j5OYQOpyIuSO0Qm8bFU2EFY4S0T4isPHNlbbHM1ofTAbSMo/QMkGUG8CYGnQ0bgPipGi+ +WRMA2W0FVGZiI9ieMf+RIj/XUcOaWpVG0T3IO2Rm8yyPn4Zc77WPJ8Oi8oH+IlJ2SKjh3Lg1LqE+ +hqgDgf7aTod624w1OktKnNJkNe02Fd7luTViKurJmofTmqCuIfj/3iQsoIz1MbSDYK4cNT4AZ5T1 +aasRNaJQdP+EpKJ0FGVZPA8L5TrPYdPy3hgUFNxrbNDGVV8XuNSSWDmdah+agrJf4BdhxHwXoX4O +qyVNJS/AGscFHp8BeWwsEk/FCpPZDuflOAM/hSdZNcWYvmpMcUNzdll86G3oQY4+z2ZvX20P77Z2 +mYqXwfNBKBtYu/3IluIpMrGP1FqzDki7H8Wo94j1ROltocs0n3KzUXNHiWXY9bWGsMDm5wQbN2gk +VG1cA8tag1FaAK5tTD6UaAachY5+5gXM9bjG1vqX3ioTauZG+drjihu1mvuwbXS4YBJk7V5v6RAE +f0JXAsAHxl6CzdywtwqF7GHG9jQ8xiXiMlEoLbJGi0JFY16ne+6WInXdZSQi6M6SWLX9SXFaeLrv +ZPNsUVRY71FROM+bYLxUi9h+2mrXiqiMKCKiSYVuA68w52CIcQ4R45BGVcVY8zty/rnSCE8U3PEl ++qo9PsalyiQ9QQizFoEk60EunGjLrDlfhDjkTknLOCpZ36X7Jjh8ZTYvUsho295xnfcaT9RIFFQj +Irp0qZWbnDUGxypBoBQ1JYm2QA5OhL5AvaneAQKI9ef+vJI7ZdpqUuhuuHY9F1AEYF2g1XwVNWVW +BG0gI4YOdHz5koig/hSUKa+fR3Q+atqNvQBVUOa5Nb92ttBFKlDRW4QivggtLVtQz9cTU1NE8dFM +sqAettxRgwbzqH6/nQcSntUXKqz7Z+5XXEp5E4EHaRW+dk9CwfL3YJHbFlnAaeDur88gdSKQmQLt +HJt1CgADySMYem8RjH8SuCZZ7eF6fo0C60KVAetDclpKnvbUaMoUNZLK1lCBVS35Vumorq3R5AU1 +4kxE/cGbPSNFFs79zXkYA9AYGCkS9HpypDbkX30T8MVG9jWSfgxCia8oi6xeqi1YSiA3QrfzipOo +uz7YZhD2y4OG46EL3D/tdXz+IprQNjAH3YPqpZKYamfY24NTX5lvS4SwBJBtm6L1IO/4m7nMiocv +nIO0adfp5iHBveqg4E2AN6MhI3KDA+AXfJHvCFQpR9zA+zz2vL1lvTnbFKaH8ZkUzEpOc/k8hiR5 +FALO+K+GygunCtzCKLu8XhQreI/Ig99s1bePr9nIQjyV9ykBbabE1UgT6NG8RfjLjvyy4xFzfYsC +zO5MojDuvW+050bPrZGmESguERsDqGEw+c4LH1DGlmZB8LGe71HBgdyaQNp64kkHedHDLgKPIH0V +BiSwC1RD8QQPpOXaMBIgaCW1StFC7WhboUyvIQEgt0TFrwXL94hxxYqAQuQLl20U9QqixN0CLYML +d+h4FLWVKDvGe6juwiFba/waC9KAbmYKeqFhH2/JpvWFHqfksY2vSGSuEiU+TfHQUUeYhghEhIlg +c7K9snoOgPKlSXdcW1sPUDJsxPp5flfTM7xh9Vho2Rcq1TmJThX4mvQWhb5AhZlSrlwfDwAimgbY +7Ug7Dj+B65ktYAO50WnIot6R5O/p47ggAZQJPPWwB/A6cHQt+jKL5m+yLehhD7Wxp3yTbIealuFm +deYuQ614Jr1rE6CRiYai8jUiQ//efha4w9TxzXkQGCGBZ8mxEYVK46jfHKC2Rl6yhnY55sPU/hL1 +pqVK8/KQtrlerHkGerxRsmy8TvM8Gn0MiMEI/RrwmiX0Ij4g9PdvTrOWwyjfrIGsbR57XMBQ64YF +pgCRUYyatF7Ans9dZsBg5O8rQaY6jaK3nygKlPKGN9QG8JbEAgABqG4MVUfIMRhdR9Goj4iGkOZA +QeKZj4ii7b6irBoQpRuXRcsr5wnxCUExER9lU4WKMtZGCA7Fl/na92JBfFhFfoQA6r5SkY9r833E +JISu/Un+yAKJi+3mQf3qAIPVr476wn09K8OVtNko2heABaWKIp8wI75yx6bC3GL9bnKMbWTrHnGy +Fp3vERlTWxDu7eNXj9j3QAODKgZuT26t1r6YSr56tJL+q2CRuhlv9EvXre5NEG8OpDQUwjdUP4Ds +taFvM0CaWOKwPG4Oa3gLa/PZZ56j1ZCBcNQITN/iJK57rAU/b8yNSRJjZ2zNP4Uq6HFgY8XM0I5Y +fswzthVFqVGYxtD31xR7znMHzAQ8I1X1Y5EuvN1H+eY0ZSu2gCAeZW4g4iVAcKgz/BZRHgYd0ifX +gyF+izqiLoqTkPnlsQVxOpZFZ7xP5HPi3tTomfGV7jyqqr/G2oMe40GWaPAKRgvbjig7BzGJd/jI +x/Wv7loDbplC0ZvI8bcAjCj6G2GJCu5EWC/0LT7tVmImc+Ebv60RRZOuEZ/5p/6UwX+loIC49PVO +/pZ1cyjRvIbPg5ZHCjEF2jbEdR+PGjc6ADNwtBngW+TUlb52nEOdusp3ETQCTgUrD9TrHuDbl6ix +9aTHOC+f4YazUrxQ1xcoeI+wUPRVUFI14kbhcbxHpPRwJdODLK7Y0dcogc7KaECg3yoFAj9Y+ZUo +XFPMpsIdSbFEpea5kK/sN2ZuWE4gXomqV6IwJvmrfT93XD6nWzJ7flW7v9OEmarPmQdga6JDiC7j +dcCKi4xaxL3aD7UiDl5Q6ruKHxNPARQMgn5XEqdZWsCshEVYrCTaXKKSzs/tEXyj6N1tZhwrvOJG +Vw/ra8CX2J7VIa7j3e0P92UR9ZxvUYg8kIP0U6ttZWNE9ZwaitUAnMlrunKDXOneOfsab2eZW956 +RN56btXCY6vwgGS72LlxZVlZiG/QVJ8/pS9W7w2gpqSh8LMSXgo/K6Mp0PtpqaP4LccYTuC68YvU +Se1+MmBycK7Yzk6XQ+ou8j8I70CREWrC3gn53msLL4EZIW1u9/qpaEqtkaEU1NcDG46RWsGXY9Se +zfRYVC90k8jD7azsA6iW2fC8xUl4ttdBVl7MbGgowjds2NaiB6BdCAWadUdAHmAZnz0YzPUD2cOf +VN1+DuIGDkAQj4BUMfClEVEfq5IpmPbjj0Jz/pz4H5m4f5SN+yee7MAqdvxIsPV//C0Nmo+/+Lcf +//N//PGLlY9//x9///v//fEX/+Ev/9vf/OEPf/fP//jLX/6fX/7L3/z9P/7y8+//6f/98vv/9ct/ ++tu//8N//uff/99/ykW//8R//7t/+ru/+cPf/e0v6xK/urn7dQe/QRr+r/w3KBrIAuKGSQ4hjaEn +5wqMddAHG4xqBaNTsVgvmRovMZup4sI+AEkOLOWAA6zJ+vxgn3KB5Xv+7Kd0H0T4BXb7t1Tlzrp7 +2pwA0Ht/dLY8Ct6XyiWD2AK2tjIJhKku3p+3KCIoWxMxKLh3HcSquG/Ya0aMlREbgX9Md2O2kU6H +YCJ2Z912Rqc6cNNpAbS8VpYuKBVfh9vZdU0NCLFyGjSymi5FInP6qc8agGg9cXMBgCq4wpLiD4we +LqW3CGJD+GGAUkEHft3diLU9AajK+j0ScXS9mk4gYURswRxvYuRPSOui+gNlxbsjtdyw85qIExeo +AvQoEes7Ckxnfk7EyjeIoDqWCyC6hNAqzE4K4n33Ky/swJG0Wz803qOWmNrtFzhUwSG/Fzragcxj +e3jjIrjSgD7S2V/fDjXRTN8d3HIf4BmxquJKQ9j8BUsNFnozv10/yCHdYf1YFAELboonCwgUCPbt +6xZmZFcuJjFyNS6AD6a0PmiN6wRrXoteAfA6ieoNixWk+w4vgrB50Y+UzKlouT6ZwIEznqTL60p3 +FYNDTQuF1UyxE5XTifGlhkSJ4teZ7Dyqpzn339fW3E+DSvFASAmnDHYjAIEDYUC9/3V+yHtEKSRM +FHhmojqi+UYM3FzZVZbc59pLUsQOl4A7gMZ4aJWQCz3i3BMsHJUGIJ1rnu9sTwq3eSp0vz6NMBEM +LFrWvCWqkso/kDmAizMbm/13zzq67yEQBFaR12f6I94Ciok3WIQR9SS2EN9HIAfOz7t+vutZ1r4G +3cVy9vrGmGM1/VqDN3gG/I1UEK/6qFbu6Krn5/pyIPe/cpBev/kU5c7Tnj8bhtvHxaK3bq/q0HQe +22uNPfDJUzn1B13fEG/wvMpGgUAEiRwPmFPkFVE3P70RseiFK8PvMjLjrDHVDm/lCI5ova+IxCSC +SWpSixuvC0kRReCZYU8QfW6CYNN4mk77W8vpkoCVSBBAkmvAevxHpj4eChEXukgT667nQvBezv/P +2rvt2tKt51lXwD3Mw8CBqbavOoQlhCIZgTgBjqxoJUiRSBwFY4m7pz3P22rM9Y8+4oUly5L9e/Zv +VFWvXtXat3k34b0w8+sY43X0gRAXZSo7gaXQCkYfhkVp3zpmWsjmdNlAHxGP1dLiQQ== + + + bm9b/4coFoBdXdOWUoYZri8oXagluw7/NSgyEFNc2CUecARMjoehAT7qHxF5zBTQ3l+iDbKwH45j +gsXTNR2W7EvoGlh8ffDT0/t+tmBeiuJgU3hg2YDZ30m605td+z0PZKHRA1ctKi/uZw45NQMKKipn +xQN90rPpgO12ZRfMj9/QrbIzKTlrbVOyjw4oUFNxB0aV4Yc0Y6RuCE7ig6rJXNPSiwh0N4nAAzxQ +oQv+C+Am1toJn35I/+ChPzdzBZG4owq4daJ4U4hCX9DjBGzD6rmLZSMQUSDiKYerhOwf6MyaS8Gg +gQAkbs+727AsRp+fXkd2sb2AErVfJA2zeWcH7yiAxZLdvMMaLeAvl1gcDZvJfXFZ+ojwTLc4bpoO +4HZ+OE4HYTrgZ+1vvovSPtS8ME+5kqeU+2JNNU+5zHXqK1ljFOs4dxHGq/kOapvkOzyQRPBdBeih +6GvOxJJszjSTM/3Tudebkodn3A8a5kY9b7of0PVY9PwVDDNV46kmj1lKALHjXKoV6C8JhoZ/KIJA +9uYyn7xgtM5dPHZu5eKxS+lfA0334+fFZ50deAFRrH4GH3jfS3w/2ll6HPbsB2z/tkTsCq0QgT3n +WSbbWSZrjs8SREQpZ2DHcsvDSBQ9TKM4LmQWhrNn2R7LZRuXRCPqfRkxiwF7p2EVdIyXE+Fny4nm +gV6wMWVd10GF+6BIEcV28/XsoL+ZecHugE7GcoYQ7w38AawpmxD+9iQOMGC9tNslvEg/N6PSSHs2 +ZQcRzO4igRs3E3HurJKD68UZ6Mo2PgptIrpAbnbq2KGIeRfTKrAa+RZ0HZj77KyJ3akrvM23gADE +NvicDZMq1O8Lhp71RAgMd2WXxdjRmK41J/778Si/T6BeKIJbpMHoUpHYMxCY59oqwl1kGhrDEeET +pwBjroAfAujSRSPNEzEOAdbzmht2VBYl/42S/Nq+yQV0FVXD6a60qxx6mrTtHl8AEjAkdXyH/9ob +8qfzQu2syG1oXzDy7WGhqoN44Q92h7JPVL+oJGgguyHXTH6RisCsy+P4cF6gUg43lHkQ3FDgrkQA +k5IS2msooa9ENB+aUwAVlN4LQWEXRZJh8bwiArgBEbAgEyA7FV1Sbja9vcM4VYeH3fe1uWPogV0w +rCUzIOTTK2ntQ1N7L3qs/MlTZ4ilcBX3B7RZqCYU+HvqZ4QngPU2apfyOADzfhxHbmK9qCa8XnM7 +dDCY++tR+dDPXWq0XmXFbiEcGQwFD6DdqEuCQI8bKXAOWW57y7XR8ZzH+0Ef6RBzlL8t0LpJxh8o +PWF8K73EB28+kc7h5K81yjOoyTVaIbY+y7IFigJ890Royq72Y46P/igR6sKErF2kc99vMvYMV4xn +b8ulyo9uznR3EoXL1X629iINH4vN8pIftZfDwWuPsgGb5d5QlbltIJwOPqDjg1pgS5DJ8iFOCWCz +qJJ8LekCY4OEufgDyBHaCAqAF+4VP3wOKaFSPlVk1s8z9Rl1B6YNsxW00n4u9y9T4KLVeQEpZaFd +GqiqBu6+V5s7I6n7R0C+D+LQN1/2kgn6eRSmXkyzGZ4Xr0NgDQM11M0/A3au9jKrPj6rCqt5i3na +MVmD7nNRtfEY0zWDSEyC3lKikhRQopZzSLxeaQ8ghmjt90SQnaUBXXcjkFd6IO7zseraZo71nMP7 +BilrnSp4GXC/j0/XQwmptxtVxmaU9l3KaLD+S8Cf1O97j+BxJwJ3BKxOgcUQ0exJ3ChM50rFlVFv +j6OK1ZTHZQ4OTNl7xA+woEAvIJr7FyFJ5toeHsueO8ww/kJnf/4UcKzYNDp6U7WPqGcqYOo/IOnB +BUNw485IDvdW8VLwc8B3o/mBsgnTfU3XPyLSRGEUr2gOsIr+w3EAvtnjqahf0+sYUdmmVwsY6zPi +Porf5EFfreLPKMwGhkAfJlf7OKrFjzt10PBtpHPx4Ojd6CVVio9qkd9w7LnQyGr3afeuv4lTRIV5 +VPzz8xww6th3ABWlFnrTnOjCfjwpTajEhMX3qBRwt/Pz7Lr0KD12QZN7/aCstBS4R+Zml7AHm0jV +kmKYzHAQx15Xu2Qbd7zOyUipPlGp85taPePgUgNEJoqWBdrqUHs9TnbkxvKVoqRdKW4E1vI0xVSd +NPB0/iBvwS2v2vAgZOxXvhAmOr/NXEo+EXVhUU0UA0+ihn2Hyezx1phGnyUjXOP2g0+iBDb0Ov8O +Dv3Sruf5Oj6yqTI/QLZ7FSTjXAVgDyPYNm/TvWqEivrXhWJoroAix2PQFW52rgqSX+i2vt8EJi29 +UA248gIq5MreaiJJscRLfFddT90VFiMtRJPLnfzkn86E3iJkZ4p/AwboHgpskNLsdGw/lADISGtJ +mQYjLfZ7HmxAhbQElORT1BcSC9T8BzuwI5QhBZe2MndiUGiyRu49Xis4uzo+kwjAnZyUqEIpOinm +7ly0BgdGzeZxbNayh4D3MILdmjNBcBvW3vv9mNzilv6RtONLuOahuxCV9EpDiwsj7zVzfDLPiYPI +leukwiCiQdryGnsDUrvWk8xQ+SvMetvpNwx1US8uAoVDLrMF7n7Rbd0PzxBxRI+fr0b3FRl1etYX +ixKMJOxQWMWxdYOnhdX9PM7R3G76qvvPGbklQ1O6fGcZ8DU8QX2MYE+Z39OCAVSJbWlvlMwSG8Q7 +HGb2VV/zevnOVIN7oaOcRQCWKEd7V7PWNQDzNNq6TJsNeLLDLuwLjKDuJiJegxg1QSJoNkt/n+jK +ZiTx5gJ0eeUyx/6J/HNEetyuRq6g1Pt8EdSY7AbySMC6/foCKwMINIGuJ69SEnlA4ffjg4su5x0r +gG5Cou2GYB3q6O8RHfjLAVx+fojXse8Jri6VG7DvCA2JfdfB8fzqikvy09B72hnhwL7Sl2N1bdk+ +IjwTxmsVXc0HyMdPx7m0p++Qvjvt7v3ECiC76bbThhkoQ027aQy+udrh64NNA15rrtkcZx8E5X6U +9d1Q2CXYUAZbzkDO0dKQTGkxFRpi31nHmBrvr4RS0b1vy31JRP2I8Cs1Cnw8BNky+w+HAfuaX/9W +xHXvKzuRE88KDrD+EAGQDg7eo57Q+3D9IaZhQm8OvRfVzkPaoDExegaYypCWGZAdZdJDWw2YsYD0 +w7j5hwBPdEX7+2YUyDv8eRj4S51KsUV4l2GA/IRrINX/UwTwJvjHlxyHc+c+opgvgE5AhlA1BKZC +j8UL/PqddJFF0b4h3aPByw/jFvQt4n3YKPV42DqOOD8cBxgMdtDgWGs2O4agqFfe6CbuffVvGEjt +CLwrqwMmITW79qa7fc70nHXopodejBKeQzN/5zE5ji84zRBLwmOisSP2r3wb4ZQSPXgQ1kRUSCNX +4dbdX2dy2jnjZ5AoGBuXK6eHqTRnaMVKXiKgmYkAZciJzEfRrGrnKyVrQm28vl8JcVYe/r1IqWbC +kkIrkBrnsssGPZEnUuGFasTjNnOxNuZ527fqvO3mJN8iciYEKNpPf05yZnPt5hE3qdKeZqfoYOB+ +CDh2ixeqeO+G/BnVg+kDPykLVH1+mmAXCIysz8lE2t7d0K4AucDImG6WlP/vEZ4JA3V3TPTj2w+H +AcTGbqlrxswF6/F+HSn+z4joNfBExj8jJ/oW1QOFpuVrwuwFPxosPfatrKCHCJBBP6Olo1i5Lfu5 +bX19RrzvaPqD6GSMzyBbuJ1klHkw3XeMST7/2fIK4zwknuZ825zfo2BO+VYgMNCLK4mPIXYRQKPh +kSpGQhYLM2EAcXyCRF22ub5H5I4NZSjuqR98/+E4jYYaAo9Dn6eTlY2TlXHH2pPqde59DhQnSeZ1 +huB8CBKWD3fO2fOhNT918lj+OSIdO2Iu19XH38yAfXcNsErfAXE65RA21Nhzv/abR/oqUeVBNwFg +kBvBJI0dHgcFMSKu5QjtkEL2Sw9h/VeOcRsBX8qINd5vgrAACybowztsZn+UcjH3gjEOjHgnCBNd +RxnSvEA7+S/HDWL0riQerK4LnaePiOxptxMgEpv9bv14nOe8UfvMQOtQ7KMvohsnJcEPEfehy4vc +vr9y2T9GIRylPB2Q5nuZEqPTdjPVnj5op64CEA6Wlu+Ezes+OzoG1Qgdcgqj3TcH7G8iB2LqBKnh +BtprNA8z+Kl2RCcVbnqm54NOMo5OtpoG0jjur+Nmd6g6kTvdOx24oVa8xyWb5MzKKOJ3oNrxfplw +AfXavAkoQMnc7um+UOit10WdWZPVCRdZ8vODdd1RF4nOL+oo2wOMwtINrEEyFqhh84cAdBabcyNk +ul5Bgu9RoMtAwAOaXMlqC7j6STkP9sIJaLU8YsC6vwiaz+Xrg6/Hd2drPL4V/fKvv3KCRTGBgSQN +YbzpJJzrrorgQRXwQEMxx0X6x0brhaRt0GxDBiTvxwTfsnzi7LIUSA08tYVX/3IPnlgwMRFOs3X/ +lwPhlWtkjEcl9T3gz+9ITUDIWkOBlG9BtNeZRu/yeNejMyuKOrhU/DcT1Y+InzbIjyj6mxJdHjkw +gGgGdDxmIiQd+9QlBpuI+2LI4DCjikG5ixNMFOUEB+D9dexwwOKckUKFx7sPA7qVOWdX38URNYnn +jZW0PU98FmnJTx3pfnUdQh1TI9FdbeLLZ3/8t3MiJsAOgugOrzRoRTg5KwZVxGhw9a8P/tF20pUl +nD2RpujXX+khqQKu9pNuytRHz7F+s6EFYIUyDQ8pO/4gQNMPe7KHqaxlSnZrn7Lz0FiuJoKOGRF2 +nbOmJ2K+ET0RdmCNcOhQr2MqQxCangShSfCLPin27fRJBZYbwQ9JVjDN/R55skSwGySiDFtznc4+ +EUHDoP3XDxCrcnaKHKRMVo7THWeruMxxYDp4R9aVmynV3A8gsfABusD+gtdBI6TwfE7haS4BZ446 +6MJzrCND7VHBDtPtwivLBxG1Baae1xmz4R40naUPFQHvx9ndO5FgbjvyIQJv+8PqSAxrMKZqz31B +DE3EBN29lHsxwkWC5r99LMDqZkOI4B1xaKJsOiCaeN8BuCHVSNRil04Evw3jMwaEWsE7cgfRHxTA +dEoP5pZ7imIDCm/Yxz9vy/ACLbgf2kf6STdFs6R2vs9PSh0UVfsHIL5vL3vUDeobBUEQfM0BzU5U +HbdznzGThM7S2/t4XYqp0aJudMh4fVFvVRQW+0WAkPgTQWMHKs9xaZChBI/45+fnQyLFjfZlfeGE +34P0wm2Uabu6fYZPUPCcBa8N4BEtKAikL5jbddTzyFpdfmgioJhGI/GGRH28nXitM//D/fsOcCRn +appUdq1hKRAxJboCkHRhvNEFZH7dnmxR+xhAlTMTFbsJS/Z00ohyjLijur89s1VqAgQ/GWoQgf4F +ERDWEzEyfQU5YAR+G45GOtg1ziQK9YID8XydaTiS5dfv5VxP8c8tcfBKm9eZzdpof/IY+jRwd1cV +lH3T2bsO97DDMO/XUqCACokmMLQOGtWI1/EjPR4eXTQxLdUZKIrq+ATvm0OGSa3daA== + + + TRrg+nnrLHzO05H7ez9s1Q/Z+/jAjihCGXhFEkErnYjbPtG4go3ZEbL1vQKWtX0F5S02jWqYS+2o +Iua1nmenacKTM63iceoSjltlNnlt9MD2BzIX/KAIYi03CKn3FzBLBF3MarBfTTWlOooEXGdPEbsP +s5MzH9bzAUKafuddl1zX++icDzH/ojEOqFqQk0m+YrmyXPa7hdCePK2BNwSYIWF33/49zfkrIMbv +fzMVc+K1pF7gtSzz+fpnGMM7zWMt3AvJucDz2c4thTmDyGyixegHFpVaYAn7vbEovHWPBEKxb8xD +Wae29qifEfnByEX2fnRTEc7+03EiMudPimQ++ACRMPfesxHt+yECIS5OfYM+fn4/Gn+IatrNXr7+ +lXnEmEnubz2XHn+6blZyped/I4rPw80C1HxZGw/g77u+bwdRaB0QxISGH5x11sOIDVLgfiRAQBwY +GtYNQJf+6IK1TkRe3p3pvNPe+eYx+OismqthD9NCmN/iA36NK/zkpkKdLQng7u4AdvlfLABwNG6X +8uf+OpENPFAmTdh8O90BLPz4szGVDrsxE0FLyzyG45DHQG3lMc1EitK5fQZkWfiWtn0eBiE48Yd0 +9r13lG+2k0ZHO/gzwoegn4fgRXh9RFEomrNOREDGueB1LviMEJH6YYTonH4vjTt9JIfdD275IeLP +BwvnCGYhwUHm8XEcsFHCsdG5IEKzcx8qDTLEHDkeWVML5F9gXrAw1JeLF/pPB7skxkrn7SCe6rKl +Qz99ndY4qHpa42v8ENFrwGaqjLwoiI8oxFzGAVDVKYAKI0RRX2wJ4yDc98nusCFICflZsXie57ce +0kMnM11FPo26rAl2KkJyMtSMdurbZXxoMccPScrGdIIILHJumGYjC5sr2g0tefw+UzbLAaQuUQ/J +5C5SoVV6HA5LxGQwR30iyv1GCa8kwpqaa3GjIkKHgf1cvp4upB9CNIDnXW6y4/xyUNxnxsO299nL +HMHcccUFHVaXI+bvEU84kSAAkU39GvD+IYo5CO84c5BLTscIQM8OIQvrVGP4dglfpHf0n+F2fET8 ++SRN9aZg2LVQoa31cRzUnWksPkVbE9u0dKSBtk7JYh8RyLz3L3TCHz4DgCgMF21TYVvKK5Kzo7w4 +A8U/cG/GT3lR9upO+tf5u8+Ir0UF2grQTC/84zjoPsjWUfih5TolLivrt7LVDKlA+x0p97ndPbd7 +vFP3DttbPkCfZ8YF7OvGgsjqjgC6tQRQcQ7lMYoRw2eeE5ndIAFIGwnzXZLXHcGg6OtEWbbPEI4m +Lx1Eoq5yLpj1hgh0/u0CX+QAgHtKwHXLeRxwzifI0/27FSKeL6TVePeHKdqbhgaKpTCiWKD2rRsn +w91FeruGQF5JTosmMC/K9wie59wVGDpvofYRhc4Xg3Rcr2ja9N5SDcCdZuBBl8Hm5k12GfSz2AD7 +M2Ri3wLy2PUsMruaL0KGvx8FvulDqYImRwkMHxAAxVSFjIEeGGp+fT2HVMKL9BbMpR+E3l6wsBeA +wRL2AXDcU3IF873XJOH6dzjaoKUH0jUAieyxPJMnoUhfWYe5xJ+zFOKMu/ez257RHfARrTKU5OiE +UBBYmLLGDktgcgGSEP6p9s+IAKG6KxhjiP2YtM+opiKvGLdKpR1ML6deGg3/FIFEm2Dc5QTunOkj +6tFYF2StI2IwWOL7nwcYaA0BSlgxIupMlZkaPM57SD8TUb7wdft5IFlD8GPe58OArSeSEv55HgYE +Ow8zKpjgQR8iN+20CXgYRphE4XjtlefIABvlo4HSgRdaQlfbUbPNdK8g0klos35EkIPLsi1bcy0D +/DXVZJk5hi2LvXFdby/VbtAUqFqTD0EvBmvJ7EEzHFwm/NYPGN3b22oWuRCseH6MWH/zmpb88GG0 +Xprob4h7z7WqCPj9HFOpUO8Ov0E5Ebee0p8RuVc9meKzcgN/OM485D9pNMXrA2N1rxnBHTooh+g5 +TM2+o+h9UWKqY0NnmkN/j/rbczlwNOijHJJdJsNsDkXYu1ZZEqR2Qc4b/azM4PbaC7DnM4Jh1nSx +3ZvTfAuojyiMy8hVEC4zTUKPSNaHU43mqEp+JUqqNr2wLRjIpeCB+lPEW6rByKNPSmP3h+Pch0a6 +GMA646XjZDN5Isv0GfGxPSe5/R6F8o4kB2ygWpLEbnObUYcLVzksgp3/rpJOSkqHqwFDdcF9yktb +aEGb0LbDP4xFF5QatewNIRAYAyNEuslYmZqYyVvAcWnVTH0v7ddRpjgFaTVt6Af4525e3PvAVZPu +KRWKfxTaJzkNcpSIIDQkNzr+gkBb4OHunUKuPyPuJnsOvHzN5idyCtoCfhC1SJa7WYCkJSCjJyUI +QX1GE/1vxN798Z8zR+lpaeixwnvx/W+PyyWpxpAJzCBhpIuuCe5nBNAXZnLoOvR3tvURRWpw44HR +kyYPf5PhCt12AsWlyRocNPkBEQBaYUi0H+z99c9d1kp9J9V796OZFsQzA4G9Hy16xwN22Tq+sRiR +4N2OBuSFs5NX8Ffwfy9QUPL/JwW+QEn/A/eceQbA3wWpUTYNc3gqs/2e8+7+hxMlQgiR1SLfpGuS +dmN7bgrJcZrSZ5C5ixEhFA97X0bIU2DYFjvynqbo0lr7LI/POogXEjvuvZBy2JRIXjA9RpSGViSt +A6TvqDEoOXD3xUL7F09hUrBrhpyG8hJiuk372heMAQaXGOZnBrmq4UvGcLnU4JTp6jtjom5l0qN+ +ysppKqkObPt1zoMQcCrbvzgRvViihqhooqQXejdyHJy5iGi2X6ZmP34wGBvzAQBUvwjwDvC5zxdS +Bvwrufquh5BghB+prfSuphczqoFtQRAQcij9KTBo4aeoB2kWmiabaXOHGAw3/nQAMpR41D37708K +AAR3sX5ReukVux8imu9VztbODB0378wVxvWgowZzhH0NCRhLpUUacYHOPwNHnM/ZISYaK+0RFtXB +ed4HdbT/Mf8qrAwz+e4YthykAC0roRK7WL1YE7GlPew5oiRNTNamkfvuNFT9c/Bkl4AyP7A4wRiG +mmey+858AGbzxi/zzeOM4jB8SI96oa22E2YHzLcnpEf1nIjln1+I+xAhdo9kN6CmIIw9wZtdCcdN +cbafMu7mFTvVWyfEK0AIWzU7X2qthPanCwzdasFNFez+Er0oEZcE5a3amZdLnZ5q2Vfnw5Zpc2jg +KfjAWZadCiEiMzU5Qi9YdjHDDgTqKlNEQ8Op8zWWmcEcoN5Ij9hVvnNGhgcuoPCNpqyrJ8iNkmG2 +5CjKIhyjL4BDZ5o+Jzra79ZwmFJIZGMHz/eEVkx5i9VAbjXkuRmvN0GP+wtTAEs39CmzCEZHoAiL +ZGYG6nfh9PLiHu5sjJQZtAKJwqMyYqQO7e8DPkQcbCWAbrKNZgx9UNNXb3LXQ5okcaKJ0+uqmjF/ +YUZE8zKfpIIF2YP+wuS5F14NU/AC/qzW7FBrjUtb+6vXXAkKNR5i8pwgAAkSna7SF1S133kqUVno +JXBQ1/aJcCodFIpg+kdwj4UJ48bnV9oVNmBBfn3zh/3r935AfrIrpzId72NwB1DPW1p9T+/0C6Yk +fvY/Zpj8jhj08o7Wkj+ZWhDvfwCUz8+2Q7GOdfG5UUiefMuz5q4rmxotC+BWg5EDs4i5C4hLN6vz +q2HqQ0rtvRpT7DEmfz54kwkXatCmUWC0aWRo/7h+Q9Nt2M63DRXJYxYTuInD/jjCwzsdF2A9srS3 +HpbERCVLc4qhqNvtwtrT0RwaUvGWjaLksi86Ey/wTEybhi6o4JXhSrSAdxBMBB3zsBT8o8e5QpRW +y2QGgUN7HS3qy2XhyaavdP88Ea0J75n+4k+GZVPQUMl5/J77EOs1kqhPshOfMdefflb0fTWsEgQI +PJn6zRlgXx+7dy+NCDCUsPDwRiLC8R9KhfdpzgkBZsqHqQzeOiC18gqpVJobQ+rG/4XYect+ON/E +Kmiiy9mzJCat3HnLelPAShUEmGH5y7npoPSEr/fzlGgdOGzeJdpM501s9tppZLvS1+xq4YE/OURm +rMNJrOqr552kqJ+kyJh0qbq03aRVbK2kVY5OOIqCCehFXWHX/tMJ3JsS/igDBfCD9eSfZbYdJGsx +Y8Er5fDsQW0IMwoLpeAcDwSeSeyYpwcws7R3qzEGAj38Ljra8LseHsd+2BQkg/NdD8uBgja8mGo+ +pEGGTqDQfToTrN9I9ZWgqYuYmgdTsJmILqLwQm4yOGmyU7xfXz9to9wHGjze2yQ/I0k0gHOUoCMv +VCzDsJt0LqS25Dx3S3UAjkkOXb9fP5mJFD07Jx2hw3ySwgC6boVhoFwRTqPd+1NjSapPJfmavP9H +Kj0gYb8IVafz+3qE+Ej7eko2JufD+6ymG5nY3U8qLSech+sJl+qWD0nixBYC3jZmFeR2zydPK+DZ +fuQCKr9pgmhxEDRsmzZFiQi458iX5sWVzAVh1QhmH8iuIFhHRJg0Ts1fJD1MmpxAH0+NvWeER0yy +0VZqfm4xvz9H3sqjU4ByfqoKAnSs2wH6Qfz5VMHDlvEux688fhNR0geTi5FE2hYGsw0HjjjZWj6i +9n2SwH/yzfjTv+DLKNLo8fHdT7GT+72VA6G/tSdbvodNc4wpYqnhY0IUz4QAQeojW1sia6wiU9uD +GfY4Uu/QE3poimH5kdk+DFRn06+UqVG2kp7Y2nU1ugUSoMOwchzggByHbYUIsKdEXOUKCEslBS7F +hk9MDwERoHf+RbMOcGbh3nDbrRAcxaEUw6KkAkWBsiqYUyAMjubQ16ziffJkhNs/D7f/VUID3y76 +aqdR6N5T0ERTCjnJarfZPseDog8lJxmRqNq775Ug7xobFu/acEKBOU/yVvqL7y3bb+R+m4liCUkU +rT684IHfu2nIMgOUtQwQdLHXx6Upqi/19BDorhrh4GqSIZX1+0Q4x10CPHMi9DaJKjMc23OVSYIn +Rve5AKQP+UNs0hPxuEH3V3ocCu8uP0hvGUFnF/cHmYB0+31a+l3lb6osD+Nscx+mw5DuuYPpCna5 +O+36GmHVeRqeFc7H9E20K79ErAbOlxY02fvyjaenC5bD2+4ryv7/vrJLF9N37n6lxrVTdAeOP1Th +QB/NyXB751JhtnOcCGw0fJ8yVuxiIRYXVkLq2Qs7KQNV0dfkqk0bgqicZQK2bJwUfdaDMFKPns6Q +BK6S3AsB/vUEIqXLvBSjeipZBG4WYNIXAQSSgZcNJMM1UhQWkO6Q5ymvuTfpk2LA+5wIZ/UXHfMA +QuU5UVDffvDbhcwJqfRwH7ZTdisecumm7Z8LBIHMPE9ThZrcC31OQE2nA+t3/l1Hpvf4l8DBvWfx +LFodF3s2vdpBIuJhKih1p6fV2c95eX857zpfjFRgwWN8R27766MQCntHfMTc34XfiachIzHUHI1Y +TlUcO4ohA0zD9lhiGni7t73XjaLfY/lhy8SzP7ZbLoStW/A1IicQSFk2V0VesY5N5w== + + + AHgG3zade/l9WAmDij5nriEck3GREy/cHhCJYdhu8/WOoR4zMtbkwFYcgV0U793JAuYVTBbqqzKE +mn446/r7CuAgO6IBxxvky0gTHkrO84oZMSpBytu5HaK8V5Link4R/NBy0JXUsQgJ4GjnRTyvOBI9 +9O7YPDKQJLbsWPdJ9ZZuYxFpyiwB9xA117opJF8VqMYXTPgGYPFQ1x6NRBIgcNnNTjgFsTDcOpAw +E9phI/fG7eygypSfQZGZZFWkjy1lys/1fMF5qyz+V6NsdOkbjHOD66unnGTcL/VR12EWlLD2I3F1 +3fEAFKWBWSDfmnzk1VwzioE0QlgiPhDpPNPfbOLomIHHwznQviEwvf6qgfrv77QrYlfXEbtqkfwk +f8xDwD6MRDq4Sj64nT5j7xHhAhRkiYA5kOMObu4CTfeOm18cM7d5BAaFCr5kaABkupcKfNeQ6EBR +kpT808nNv2Rdg9BB0SxNQk7I5mnN3/RkTyqFesNAQKFX3W70JEQYHJS/IgVLWwGe/qHIcdM6gZVI +p4CjSFKKoiVDG/F1THVVYnjV4IjqXE+noZIohrxEySxR/ERVy44yCKTy+7CxlRWM5gi9g8duI1I4 +Kz0OI/orMbIeYUjPddCJRnnFHW3unInkmogaxcsV6XC+ZD5/8o2uqk23Khq32hKjnt4ATHJ6OvsO +Q/WszjZ2hoKkxt7DSerhmiNOv9do9KV2RBNJz5hEO7YL+xu/SI0VFW6U/fQEVJtb1FHVb3NYZXxd +WGU9GhAqfkJYvlVl0WlEjkEXRa2Bx1BEtQEB2z+tuI939uzkbkfVvhLVcx8ozSKjpGbFo7vLiSCz +ZCrcjtBSUteHDtyJQPCdiNmfrzMtsUcoopOhr7zLRoH0JEL1CpABpUX2FYaJV9xWeBNHTKnil5EI +rDRA4bffEjzSJp+QhVQmSOUG8ZTX/JpZ/fdbQTkc6QMUyy+B91Osu46ozDXA67OG/cZpr0O5eRiN +DV1Z5aSW66qkKqhfoZp2w+2m+dzktHBXGREKt0Mgtvtgvty9PvvRM0G2H2PF+ziLwbhpKxrFt5oa +jT3gsRqHgrpvyN6yS1ZgSwAkgUS/3nUiheSKjhcWzdUbEfUrnGrxMlqphrWsgdt+rZkzZVNHLAl1 +CoTNeWyR4OWxhb71BfMV5nAjuxIpiEz4JgZmLUj7AYKPp1u1sREAO61QhobrOipjVF4vypJhP9xi +DBuVRNoPB2k9ScIhJPsqUeDfXPW+e9PR5gpwCij4014QxOlRICuJTZZlk6sKiIIVUQUTu6V2oA9B +6OXYjTLVZgIBkRhUhjgKNlK5QF13sbM9lKNCFaUhT+SvR/8ezjWvycwEtlxqUwO279EWMEtpzBVC +VwGZBomEmd3X8bNbArUo2VUwIYDkM1PJrX1j6NHg7BlwiMg3UnAmVcKe6BTvzXamAzJfyhJPzTmR +ZlBg9fgx2/0ZxQ15LGHgbox6SPpqOylfkQirY/wMetpTZmd0uCi7/3zwTw/iJUQ9LV0K9iCiGqtQ +zpT+195QWAHYe6pfJe+y/cNcQkhFTLnO4sNP4HgCK++3ueS4CVKNlAS9w/kzxiBP1k+RvPuDqGeR +TwfSg5wiiCvK/Rz+FU3qMCCDL5H3/1jv5GFz/I5NZhMQMzQqAcmSR6llMEP9NeUczYxmn9Xf/YbE +Qow5VEU2cIIen2FkeymjrsPrR/qztJwHIRy0ueV6XPPwgCCFK59ecLv7jeN5Qtni8QgWYCzXl1VC +6WtUEbxn/Y5AgS81juvY+3C7FAnB/4gUCvk0PQXZD+dRdyBHta7EWDUaYPMoROXNEb/vAJMbrTkB +Utrq/VzOyQOfB0OIs2wVEjY5xVfxa68ZE3sX/wmuNjIgIdGhk8dLvV8n8/lHFalu0S454/EGPSbU +nQkpF/uFkrlmhi3PEURWFuumsitodEfjg2SP1Ttsx3q6/kyvlFi729Hhdhf8BRtsHe6+KjP3FVE0 ++bPYtaryKodo+dekqQAthI0pZKcoFeZtShjkDim/BQsVzts8Lux+SMlHE6YpZwCgj9djlxH5s/uo +pdOmQUkQVJcE/4aCfE4AsIGIFqmQdvQqRPO0rzMJfIdffNTAWK+48MvdAGDJiBrKo7q5X62erzZC +fd2bC4NbkLAlJ7pysc9bvJMNjB5NDMHuPJQ9KtQwPGj0KfLOxnFFmMmGCeJLOt3fQ64FEmTPemW7 +ix1nHb+foxCkLQ6/KoDFpn6YWgO1lqPAp/3TTh6hFbrdgUtGquZ6E2ZdKfce2r+kKGeGrGq1YDVK +coBhA1lrmWqx7S/W0cGb9B560uFq7cugZiU1V0Kf7kwNHEcxZfLM8e6FRKHLfGES0SNTOOTJtdbX +SfF3XqXII/qsRmhrhvrmpW5nPU00LGN92urJVtCXOl3HZLX3yWrVVqtnLtJwpx4ehyG7w4jyJCIy +UZigPieAtvpQtI/P6eXRQdlJwfMX5+F12eeZ15G1AYusMSMZWHS7ADoyAAvf2hEeX4sXDIbPIEdD +ooSne5WjWELD601jod2rD06GYXXUxFE1Hf7UvGtoraWY6T4FCEsWmfaAxlCzjOV1rJF53Dq345xg +2JcWaTUOHmuokISgtIJfiMSBw2KNNwG4D1+bxGFEaUtNOPwS0nJFa4vt5ErF/6f/Ki4DsAu0CGiQ +T6+YuANodclB1dUCEvNFAclXeg1YdD5+R1LrelLrQxrFBDVk1Ost/JbabXRoeoSjeqjNYAzvAw89 +uE4Ygc3CmGqIgREyg/ZhsipXmC7NztDpJCBE+FIdkxpKyVw5jEB75nLikRUKYbMAfdbSngoVb1yQ +NVylp2ostMnK6bpAJFK4b2/Zl5yrri4c3Tj3XUgAZDAA4MtKP9MxHOJL8n3szI20QkUyIS18nV4L +PQsghQ9uTjRMx6sHT4Nl5oTywtghbd/PqTExPh240YUFDyZpWfUtmrhhii46MrwH8JDAI0nZoo46 +VhpKuyNJdKVbkq+6f4pGc0hbDVFwFem9o974UxTbH1F0ihMxE9GvNwJOBxFfZ5Kzsr+7CFYiQFq6 +XvXfZyL/knwwo96MwoDPjlrD/QCxAHxcLSrXEfamkhqn0RO2CAtsAmYuFoO09zyz+VdkiiVo2TtH +KRKgkeZrwa6lOrrjhsGYGpNaI5wW3ZqVRFlBYA860syL/3TKpfiwAIJBkAEjiKoy+Wm7zwOBhwR4 +cyYR/EJmqaBTCaqjBnHjGc400Yagk4U0yRdzqUrbbTyC06iwNDSbfDyMggE4ny5HDD2qCeM5jgJ7 +YZBPpD3o+jquOd4NjarlrwLx8twyppSHbqZw+WMqawSVhAOjxk/2FJTHObzzAJzEX+FuXB/sWbPb +rrg+RCIc+y7eXpzSS6htTSTydzw4hfZtKY4MZvvBycKfhA0a+Otd9T6LpHwJyy3LAzsdN/4+xRzi +qUjHctWq+SNM9XbL0zzmFSs8tSKcJdujKim1A+kGeXaNCW8sHIQ865wnuadEp2c1DRJsKgynenvH +3ov0ATnP0JhpuzJ84Kdhs7AiuucnbnTQ++XhIwNTP4uuLinpo7pnmH5QpmT6vXqSZURJfp50XKYf +C/0Npq5HL0zwqXoLdJnd7ngKUHO/Iton8njUY8E0QnHNCbpTcD8sqr6y53b/ymIW89vx8vr8Z/UV +JvX8abFOJwlAxQ5252KcIKiw2vDde+sEGcdYFZUGZ+gq1Vf3V9ddcaA3sEnQPageizzZP4W8XoZd +Payxr8yTKOVpiNKSAHmaJooeK5DqcUTQLSRw0fQCNeUgmQLQH7xGVH3hCdpOBNK8RJDxv2e6Ithf +4swj+ir0gb2NnCGeqAOU5ClGuRYR46hg9ATQniYg2zHP9Hv8K6S4xe4rNX+vnSNmOrdbz371lcGe +40yZq96uh93FYrd0QdUZ46xEJJzI9ABUU51hZ7KPSwZ90hZwvIqOyJnFUGQGsYdO7SVb8z5rVa8l +JLRpU9d2Vn2bFqImWfN6JPRkCqbJz3uQM4U5Sv4oVZw0jBkT9BXfbSJUUVDPoCFsVSRGAxg53+gJ +CmwpQ3XLbEzfAX39liXEATIqpLSB2MFBUoMLlJ1MzUvLEUCzN5CJLXisW2WGcyKKIx9AxDl9APt5 +PykmWEvucYgOCy2/AAwcB4PQIzVgv6MJCPNvZVCxl5rjFwg143gm7Nxl5NWuUgzGvnLWjHVw8Ddq +MyrxTN28b+V+Riix2dsfBiPSs397EYy0dZeyJuFu55fFhXFGoegWMGZCFYq/7Lnb2fvPx49KwH7e +doL0dSI3lR203937kMRnSOJmp1APmK0urGPKoZEnGYuGCRFRHn0UUU6EQ699jHL0PHlAXF/vC52I +jCmR67qTZx0LN4BiKCqZW+Njo4POVM/HncVruYugE297CTNaVuE501HpJX/opAZ2ZEc6socosJIF +35IYqGI8SoOCMI4Jmqx0LTd9jy4VBnpFGuHsWC2AQZaae2apZM1R51PwT1NLxa8q4ZxlVaWbh0YV +rwr4/Rp+PznyuxMmAYKuxcNlj4O3BqSESh89uBQI01EF6lFhefBpnRGfOMn3YA+VzvmIVu96mXxl +VVp20IR2R4DKQOVGFeVP8EpIK1B9qo4k8TDIQyEXT32D0brTf40Ezq3+3u/NnecFm5t12qvuCHuD +qkLXMR2UvkRWp35jD8GJLgfWJgrl8istyngLlUvL7lsGwOG1GjWTs+c3h69weOGuyf1gloGcQGDi +g6ZGxvWShOZbGymqKyUD6GbLOU3Z3dHr4T+jlwpjqqyABiIvA3YHQxyth3NFSTPQLznkfzAdq0uU +Qtw81oc94uKs+reYA5oe4GCWfHZsXtWIamJ5Q7sQYIkTy+nGpeQE6PYKWwpntI22n03KL5q0repz +DR1SMXCWb0Rw6IsoaQZqW00hwfkz/IrBv9Q0HOcIcBKW9kF3019RdXzuJTH7+l5mrWqCsR7DRsk+ +DtTBoZ6RsOa+sg2D3bdCgjYmSgaS2Iu8rwe8frTOMjm6z+SI1LrNtMaBGM8nh0lhORAPHEFZg1Ag +bSkrQ2X53CKfj0MW9Idd1ANQ3U9jO6JCsx+ZE8UYX8oIE6YZQRAWRbtLa0VmcXa1rKeOVmhaQHSn +rf4iUNRiVIe98BMmyl64HsvIgiKJrYAlaqL30caA3e0opp17BxpjR+y3rCeiWNcONFl/swlUVabj +Spbd0Hi3Hzb0SAsAHkB3wXpzGaEeGiA6VEA90xNGwpTJzXDvUu5pPzvjpROM4BCYhytaxd2EfcWq +UKP+6SIGuXfYVT55OCYucIOVJxwqlB5dm1aS6NIfeJ4XbP6yEu5ToLVoqtJ5HNwJdZHVqISw0dLi +EGRPV2soEXzoxNOEpnwKxnydya/EXPMo+tNspJ8AtP3XqMdEy0nzEw4WfewPuB57EALG2psD4/nT +eeDC5NgvkRoYkM6V6EG6/RCoggnuaJKFNYomJxFsryqXu5zB50eyET4/T/RLJJDxiQ== + + + nE9TLqu/pNP9o4+QPtzI6YTpCkcZFl2OJaRFlkoPvaTY/bmf9EsWZnNfv8qKjMzkqR0BrAcUJrGh +++u6mU9BtTH0iselltJDMH/evw4dNfaBgYftx2N8PdLtSLXXqcm94HnRax21viLZIqr6uwiYh2Hv +v7eATBHKl3BHL9stZkVs8T2+4/4ZW/ckqRqpCvZYHseCcq93td7xhnS92RFLuYje3ivY2W0/EZYk +C0uj8nUmYXLogYDUM+oIqoOUmuA5RUohEkHlv2/EOAF34u3ZwOL/EruneVaSOruFLLr1PKxmjAqU +sey0CDCI7uOl8GlDr2ZcCvQqV8mNe4lJrC8t9pQSPZZUkyeML0DYPCVBlwW9BtnF9AWEhijsVXSq +z+H6MYnYqUD6QE2nckqja0oWW1GQwPNu2rNirki1sHcSCmy+UXZCqMm6jl5RtMLv8ihTJAhorUdZ +CZJ/ypO1H4O//a/Chas5ANY8/DuEJRe/qMVGMS1/rQDKHTCJJhFy5KQS8P4IhydrvQ7YBvaShT/y +Q8yjFRwtJvxCPX7tfDZZAymawiP7uv3VVlAQ1k4tZnjX83YEMKHqyRgj/I5Y7503AErZBKp3RDBc +9mk8CFIFcNzd/9jhk1JaMiFFeX8pzN9xHgS1h46yVtNVsUkFTgVwWvFeaZWQUdqf3JsHjkcmeqng +8Jtij/9Jw0k2e7pfqBEfwAx57NOTEeyXG5S/8zRarY+sJFZEnCTkwe5qy+kJsE7GHPuZKAd6Twd3 +cUN4trTiUIXjOiocR0hQJyQWVm0BhEwwQzkI8f/jlLTSEh1qMje752FOVGAt4eU4kgB243AFWtkI +g9+3nQzMQSCYw0DNLoi3p5jp8TbZb/4QUEAp++j+yVgr+lxd/b7BHB793yG0DsnTYrWxHxX3PziV +N5ADkmNMcBhhvCohbIFi+/erCujg8K3opy0F7q6z7T/o32PVM2owJnvpGyL/6Og8yn8gpx0DlWPA +F0PlPx0Iuv2j53Fyoc1oNWo/+uXMYKEIOyL1OOM+Y7K9vjwS5v8aTO9fEhT43/wX/Oz/2Qf6K670 ++Z/i//zkDy/Jrz7yNXjk7cKIyNBqq4duBcfPBWoWm6/fYmTwuTrP44RGSrHC/cvODwLJgdA8BRF8 ++5d+pZlWCUy/A/7F0YWmX7kjCxSj6ywNJkeP0+LD4o6y385xznheUgfdyC+O8I5q9pqrcphG8ToT +VbWvIQKw9Y7gCgLmmWJsVOdNBLMaj9FyDLXm6COUl5HP9TB52FHFqSmtcpdUxK2fIPcFabGtz/Yc +gEtRphikgxHSF3YE3aNEkJcTcb1bcDnejzNKRuAvQtNVt3vtPy0BpqzxZCWBK0uGFMY9+RGvOt1g +kTwjdrjJ6WZKyNlFXER/xi9L9wAiGX0UM6TCqfqngRVyEqqTYHCqVDgb/U5UGevi4pYz0QpGDI7d +Vkdj+iTMcbAXY9OA2esTCuSkj+DQlm52jAqvEG6HO98CMTF0QIhzCICBIyoq/5fMf5wMwagyw9eV +H773m3Fc12OhMrI0EGFGi3BB0z4enXjNWtpqB3BmlBIc0BBmTpCvso8qb50I8XlqmNyxahBMM6y+ +cy0CKvtZewY+zu9OzARwFyHjhpAb1GJWub3ZMbNH48N9itZVYAc45bIF1R45BkF8QgTJJ9pnhGc6 +4iE3gs7l+eEwdkPJwmGWBHASn69Wi8zX7wELfjbIkY6v4Xua70HDnZ+hMLimfZSeec2or+ciLIP9 +kyuVDsuqHt3784GHBSMMtmgwYmZReP9Kjx2kVPoLSUW7tdtRrvLT17GuHMepV/zP+8rxIdNOZmc6 +RJEWBGYDo+jOn1NdwOth1SAC4BYR0/ndWinahurTiQjeGDWjdxlZMeymh1bWuYxRwB7vXYmx+0DI +Rx+2zgwx1zJq8TgFNA8RdnNBfvcYqUCFIKC9o73BI8p0eC8kvQo4eQ6QDFKFhzkdyf3qwAwIAhuC +/ecH/UBTZDe93+R7FFq3C3eguZ9r6hix5STCGJi34Hg4Ak/GtF3F06dWKzkgqCMj2ok4AKEBy+z5 +4cMJXQs6Wkd5rAa+w+yNEmAf/ofPf3hWP6MesLIKX4O02D8JvNOOMdFV4ib8TFWLhybFe5MaeCQc +HbH6Tg7hn5DrD7Qt7qBInMhgQN8oD0AD07gZGNe1tENtfiEhfB/IgVFSgUlXRN+2A1Rb4qtzHHZt +IsYVbS2GbXwg7mdoQfek9fu+THosVY+718T4ahUxxOwqaEPYiB1EPMpbyev18mDZTAM0eOQDOduL +J+xs/vdR08BSV5PHq2Se9SgBkZdKUo984xYi504yBdqCyviFJoOdlVgrP58RaSKGtv/555SJNrAG +c4QwOdMcp/tj+XkdRQJEKA6KRDoSeUx/1Vo0gJf+D8TuYE34M4GidhGvIAEmoi/3yaQ0woGgQlPu +r+Vj/2QS2qTNPP88xr04CPvxrBbaDPUDyYI/25ID2s100H44phQfqV262KrjC+EEdCcp5Nyk6nLs +dqqekUdJ65uygqYDNi1uczuDuWp5YQ0lNkP0hDVIxdxlap4yLZuMEBMyHhnWGsSQzBdIxqByOFPg +RA+VtBHaepArXS/8dZQDwkFee8ZGZhwClUpRNK7hNfsBuFiAmyouAAxS1XZKK0wETkc7YvWzj4bZ +VA+zSbeY22kzGIZQn2qc05XLn7EZ0tV+X+Z+X4LRigP5op17nBE1T2tYwj9fLq422nmPoBOKItWE +DUmDK1rnMf3QT21aw8bBETjtFXnqW47fvp4uuPP5m5R4NrD6F+vCahw4/hwxpWJaStTV0v119+Uw +2Zme1zxtRo22hcgkexSgLRE7QNvggZVLTnQfjfKn9RhTPo7HVeKmWUjDHEyWHzB83n+uRJGQZKWW +qeF7rjH8lAL3+NXJP06l1MFSdQCbjIyqLeRZqh6vj46mLwQdl+fXX39l/vQv+JpKSFEgt2paJ0on +spMVIbmRF3SymtNdqPaujAKRRhRlvCO+y9emgpSqB63UglZqDkNBVV6eabinXS/gqQ7bhC8eqGjC +jsLzPHgmQWewatgjQAy1cT5g26493cd5JCGBfbj2EmHTBL3+r2lrOTgxXpMnHPmioieP1LRB1i4h +JWYcpxMM3oh+U4lspXTXHSTJ7SMiRdSTmekMsfUzSjEqdT34oVe6UcEUqR0R3ZyIbjRaRhGiGTa4 +6OS+eBGiELuYvMojNXPcvaBp9DijuVbMo39PhNv8dMB5GxFhH978FX0ipVCJ6H9pomax3uSgR16H +Ti/yOlcOY8mFrkg5ESxZRCzPLAk8Zjb7a+ZEQfmoRfSKmdSsTAzN1MGqrz4RKr3z6Oso3EVSLMu6 +H6TeLibULGqvvWSHANyCvpFYyjDs+r2x2pSd+JX16NAEx9XBv051TVTEmUzb3w4yA7S1zx3bwI8I +UPRdEWQai6cV8T1qheinJibMLm0DI0gHoe9WUlPgz4LrcR/dpMxl2GvWZ8Sfz9gkEja71gm24uM4 +B7k5+aYl1xKFsxm2th/MQCTD0b/Ry3576R9RMMCdROyfH22w9s6wtJ4pAUBK2V5lP1/VzEjNdQbT +Yi8hU2hRNX3hv9rsqiaChNDeB5oAqTsinqMlw8rUbUf0Izur89LCS1BNthdeBseQZhBsBVX8Jko0 +6+tMEeSiR70OgXwYNe96zhTPRlrKK6qpDO/5skHOofSuuNEd2hfc83GYN8NNx3u+k+RzR/hvPGTV +fqLNmQnjzslPL1adY+79o4fc94hDWb3tKH/Z9n1EXQcsVArAJL/JsHu+k9ByH4SGaBwlfeKEqXL/ +t3/Pyvb6bO/fU1rdx1+DjrChhRsaa/OCjvH88AEwXWyXgOl+KQd+RlFcB/6kA6qKNiuTMSesC1zv +sQqNE9qRUEAaOvKGuzCvx+gsSoTjKBHeUQLITx3xcGEZrFK0OiIH/v1hQMwlnbSLAtx3Xgr+wpP6 +zZ2eQ8VCWL4ctHCQWCY6gZAVp3TtCEsrbtl8Z9M2pJ1Z4iaRPZeh0gGtA+zKDgNI+6w8S5yxZBwn +pnrdoR2gvQSNHbHexy9M/OuTSEm1yFa/bgJ8VgKFvQRjwWOoxxoCkA2WDnVEj11CJhFtxfQhSvbF +OUKOX+Iu9+VmKETqzp+jmeDJBcTwAWAnQLgKUe7bBs8hf6F9R1uxr+gHx3zp3/aFRuzKsOIB9Cgz +1sx5qecENiMKyjznOWSAhauoqMS/lhL9S9ZJlDowq6FIN+eIzwqAb2+bWOsdBj+tXjg2gOXYaK/6 +Cr3I0T6muS2muX0dGRfH05Wfo/mI09Iq4p/SdPZ5ZfhyPA01I75NZvt1+sXNra7iaRg7Y2U3oA9H +T2YkH9a39U4E5ZERvR0JuppjIIj7dSKSNQuGuycbfI6r8j6QZse01V9UusDzwbvpNTI9Fcc+/GCu +9ZuIFlJTeXTdtN1QQz6U3YX1qAjZGvUzTCiLJcBQiYeaZVdzXVicalL716A/mMM3sW6UPgVELy94 +MYntSCKGEsjwm4FaHmSzhetkCyODObYjNbzqzEYg6nulfXhuUNM/i6iiKI30ydsoGKYZ8C21kTpK +X5lT92yx/HxnBFjCmnbiRbeLCcaOaC8u0Kin2ALfF57ryaIF1LJGlgxvduXVWkbzgcetAJT9Ss7b +5zvoLwxczz17MoKRFtZhZFy8uz6yUOgpbHSTdTVb7mZrPxvzh4h5shHzr9M+S9Q6Uc/LPbI0ZnOM +1N2gC0NPawk5A/HstNfc4RmmjOefXUCgrUuD3Q/+IkM6fyIH1L7CCJgIStyUdRbWUIt1l5Y8Vd4C +C95vW0YsxB5qxSeWXUHZ7m+soSbCI4rotzSQOH6E2BTKDNVcPsROLC6JI98jvPwP98LvUXpkDtYc +dCtY9zCotTcC4mK9ETMRkuN1Wnu1Hr5/CFo6/AduxRMassktcso9fAiQWisCLRExZ16Ep5V2Xe/Y +i4in/Nb1MS9DM6efwzAtN2gGznW8+UZRnU03iKJHw6WhwUfEXTOY2g/bX1ro/TFIh5F1HEben0Kv +Dh69Fbehyhqyd2zh6yZNPIlnjvc94H2wIpLRen9+CGKyLYPnoWtOxbtaarMbheZ1yP8SvPcTYqq6 +5mFVPWO0v2Cs51Z3LApTTcQDgwaRdo8rry0jAcU5nw5U0g9uJ+N7PZFz8w4NdsR6Xoh0uTO6fahi +9SxcMYNZKGe2oHih4FGErmvkTOHuPHDoEpGnGQSTX2W9UPW9Gr1WVuLd4hc0Wc4taOoLHZWLSKr2 +BJhyR0uKxCjyE9bBvMcHIP6HiPwoPS5n0M8iuTQC0iTqEe03QwZ6KlPdpN4OmPYdBDL/U8QT6K5Q +mtfF7iNKSkU7lIoRGqSKochRxbFjnAwFPGKNasWjSEXDg6R/RuSm0f7oirE1ZQA+j3NlQsOF+Cs/ +rvO8XCzDPwTUg56+5ttP+R7imJCHFRehOxerKztY32J783R09mZYnCag/KfI3s4AXQ== + + + O79HvO+nhnGILSil8XGcPiN+i85lbdkt4orZkGv/KYL6KTimfbP7787qE6Ln9Yize+oRJNuZwV3e +xvlI45weLgUFWl2YMGG5HmdVVK8fh2o/ROTmleCTHvLN+vxwnFcBFKvn/qZb/Uq6NY/KReApOwu6 +Q6DTNAQDqfvdg5+VeumJ2SX//yJrQ3EtrjWMewHx98JzHxFRzW1JJ21y3dG8xEjkLZqJ0gNvRy0B +pJzdeg77qpXjCJ5TC/nAJlPGdKBSBkRN4jm+SlCdJWXuB+YVXFG18I7+vr8E+N12fI2XGAgmT0G0 +kj3PBXBsih3gLQA78NjNaYH1EtBPEyhdXlBQBa/28hml0oN5ZUUHsqjwrWzYLgcfCtfPCMBnTPZn +HoJzpo8oC22ugH4JGGCwzLaz0hwiEVaZBVc9ZoKQmOkFIicy1Wyt7f5S5qxHjrIdWznG6voA1VdB +xx9KLd6+4tgYnaGq9LkBr/igiieMNla/v44fUS1UqY9LC/11Cu6DXalv4ooxVjQM6ejugIFKa36R +ml9kHJ3BNEIYH59ZgCMECw2oZ4rYMnZh69jfH9ymo1TTPg7OJA0FGFrOpC+l9x8iaj24wvvCjexQ +1z+i7jyyjN/a6cBHFBVvNI0LvhnzIDfB6/ujrY9kPZRjbrnxJ0qV2v3PQM0RM4JB88Ar9yGtKbcn +QLQeo22wG9HU9G4vaV9/OkuwNeEH2nH/Q6On+kDNuGIvkF7rMmU1m821lYZEyGfEn98pnqaboyMg ++cNx5nhpvPvdKylikRlA2AbJ/I+AH/fG70GobkAr2093l+o+azxzYaaK+3yB5+MgjLGhk1PSD9nY +ztAsf2E732M7v2qsaVXWZl+pL+MeLywZ91Ij9xfRA3av+c+IxfQ1ZGste3I6OspKrehcv32Zfgzu +0fWC0gEtjTWL2e9UEP0bxegj4h9P/8h1+/uHsFptpiwHT0cQ2JpnZ9ARaIWaWeQfLYog6cdgCFCm +eq19DGoJWuMNoo1DkIaJ622VTUzeT8RKxOjviVYiRMgaQSZNRHm+rJquK3SoKV1HNvR12NB3iE1X +/vo4VyNGvfLvlMb7L211GKF1cVm/SdLH3wIpCcVmYaa6M9/BxRKqntJk5F8cwSi5qYEiv/kCRziP +dzYKpUwwIBJ5gvJqhaNJ9RZDqPjqLn1eHVPZ/U7vX6X77Niq3s8OfZB2BnsTuMoMSzVtU/QB/6J3 +H3oIw9YrblGL9HpHTX1k4KpC/QCsGD4gxwn/nWaPEavH+mf8xXH14572L/wstoxQFsH3/RCgzdkN +Xf7O9esQjvKyKg3weUVcIijz9m7rE/fPKZsqTpOVgSB1D/ixyYvCD43lhEanMyRapwE9iV0t566v +POZTdcoZy0/0yW6RSNFdzhhBhGCEIFztMhjsP0XsK5G4vZPD553OGOWZ8I9r0Vil54zGajvEuIi1 +I9VclfMK/nHvo0o6gPxkJVlIuAspBV4oIFWkzHlSTw69ACG2YFq84AdAPy441/HvIQOBcwVsx1wD +0vHqh3oiPxOFLTs0XdAp1TiiJofFeGd6uKOGo2qirmHHqNhcfe4YRKN2BumGiHKnF1RjmrRsPLKQ +F2FtHEOE5E6q5njFENZxDuAyAKnvy5BJzz4gqRcoWckJIj8IcosElz/lsSMCACoRURaETvkqdaOv +nt7BfR3XRYjKKGU16UMeF6cvDNPuo/RHXrj2YtMiGeyWtdhTD2Fgb2ZE7O3g1X3cUUqwwIfSsdko +TQ0zs0FaAV791D7Lz5VoQR33WceUkUElEUdxsF/KrS22i/cszToLEYce3NOSx0oqKxFkpadNB9qq +VXkN2I/LgQXXSUNrkSXkMoO03QvlnL89ySTMLBxovWtPFGdQIwTzbGcbMbi117vQH+L/RklfI/px +aA3jllxXo/RmA+trWPtxFJiuSNbxCLfzIyvPDkdUO5COSu7pR+ohWWTl55/TwF9RP8EJMYT0/AmC +RZq0l5W+nAzwGo2APusPEbiuFLtuYLBeJc7vUbUdzDWqRTJhaibVDN+ksJBOKXzUdWWLSSJfzw9m +Pviyqwcl46NiirN++HP9O7u1YjSZWodk+RcfjHSgEEudf/HsrPBplnaK15Pd5L68Pyzj1LyRtbXC +jdsbQ4ajOA8A/usmF/8pjiP6Bt6n3eNYKYQw+d7OWmZMRpY0zhztxbDyockK/8bvwTNRT7dGN6TF +UkneVQPUtInq0J0IeTjQOo/NvJDIB7XhVr4u171lX1ZRF5AtSUG+vaCtw24SHyFM5QoeiBUcQA9y +YzZBHDh9/yBvzPek7OPPcak5MvhLjj8AP1Ym1IzQLvuM8Fcc+RVfmMtHkJB71olu3Xuuc6SLyqZF +lzBJTxT1/OAWg7mry/e4GFP0GFygJvAZ5TcydU7LLCWAyKQ7rD2KozDD2e+6FDfUQA8YrB4E1r6O +qUbXgXPfLqsHQqW3u7Sb/kOP+yOijpgQPegDvIqzRpGsP0heRHBTv1da2l0BredI8DaBfwGVKcfG +w3y9sASHqrOEwrFeobWxn4Lz3N7HHnNnwHtFOAYqaCHQ+4CARAQ/ExH9SQCgb/+dJJLceZTT7UCT +Xw3I/vv496t4Sj6418iiCsf9KiItxT8C3oV8hw4OatmeIA4ZKE62aKsOfX5tBny9F6ozLxSe3UOr +8gw8NG40N3KRTNf4qmK9heisHyJW0Tc4x/3+IcQmoCmuOf2FsKTpry5X0/gE4REc1zRtr0dwYL/p +DH2+B2QHaactXEWhf0Yp80OPEJkfB5FDvcUfPqABaQ5y1/obT/At5pvENtP8SwsdumFXyAAHcA4I +sxwrFRV1sCVYnxFfC4hcXvry4Ik/jgOtFfToQuyohUYX/OAdSBfwMhsp3mwmtg8SBm+mhWTUyocF +IDtKUgeUJvCR4sPjIoXBGBRatB4BHNfMZCwtfYmg9CXiS4+LoOo03IkYMbRutMbRokZhTVVEGP3l +PNL3mErW4+ospnq/TYVc1AhEny9b+qedC/HQEy1WmyKt7vixwnJA54A9rwn3qz98ALHUOzC/uCUJ +Urdk7+plnan4zFRcFKLDTurEUYV7V5MHmmqjXQfWoXFUQQ+3fUakWIjMo74i7Xl+OA4s0UdJq4uu +tlPrCIbCCitBtFG40xEMMWW/8PSMLBJw8ilxeVw2mBBDXcHcrikd68w4sX/zcVn3YQR1RDVvITz2 +RKaDoZCbnMfh8XQfX3qOExI3fuUtKqCqwjDM0hoI05NjTkVHjylwnf2Q+y9hTw3q7YmIUH3dj8AX +lC/ll4Kg9w/H6UckaZd0RRl7Ub23nY3FSOyHiJfc2nBgPL/KRxTo/qmM/bQl0o8AFVRqpaZXrHyh +lUzFAvhKLPoTO6QV2lDVcIv1+BXQAqGvVVGn2XeihCEL3PUwXBvITq5OpVLx0EzwZ86juRUBbPfS +k0IrQ6WifJ1HPzl+OGHZulznzyG58udMJGNKMOWtIVA/PoUXZLYpQjzQMn9PgMu3+FL0lGZYvxpD +dFrBK5T6IEdne+9ppHH3aqam2WcE4CqVSfez3t4zfY/iMTNqPxMX4NcXIj6dL0TSOHYN7bqYlAGz +OxEoDrTPiJypHogsRptHR/jbca7DQBw7B1Pu9xIShcdDazZQyiGdDrTJi/clP3DHqfWVvyiBqRHV +NH7YUfU+UXuN+ttzPU94YiS0bASrpd2C2od9nsIbToKH8AnGzqdd9McA1NIYlF/ots2/aBf9Iaqj +brEPUxRtue2KBznLDs1Cq3JBdWcWfrx3Zm122pcm4x2mHystKBE+oI2TghW2uPtLCeWSkV3ErcZR +zFIoqXzusuklf4/a61aMGfa+KcJz3DHdu+M96iSgCI4aQVfCwloxu9m3cx1Pg3E8DV4L+n5EsZjt +NRl1t0gy98QRdRaViiCEX4prT1kLaN/vVWtGzR8ZDE0vuAnK+SuOu9/RNb9AHSaB++Lv8sTF7cHd +ArSTUD4cbGiiMK2l9qIU1EYaOjuUV7n59eh0kAU/ABAYdkl3QwQOAEI5Imrso5NNEXiWdKOlWKGU +9kcvu/2uhTD1LeJFMQW7AQ2PquZ7FFQRnbUrqTEP0l53LoWwzwdIEgZ9tV/cA9X4+pANn736xhBg +Ku8cr5bhEhBpQCUYWb1qrFL2k8IVteNv9yj2zHzgps/3p4OV06Gc3l2UOruAFF6uJ9YTo4uheF7v +sbF3yx4nkn8aZvcvCeqTgf9fZOH/Mw92/YLY9ZfEev/j3+7/mL/+1X/963//3/7LJyu//tv//u// +/v/69a/+u3/9v/ybf/iHf/ef/+Pf/ev/++/+p3/z7//j3/3p7//T//t3f/9//t3/8G///T/8j//5 +7/+f/5ST/vwX/+u/+0//7t/8w7/7t3+3T/GHi3u+ruCviAX8z/xvwGe2ivEBRukK7MDeSHZig3wP +qwiyFhUe/n4uwjNX+QN1bWQl4C3+UtboYjl7agGA/gvMIDI0X//sXw3EqQC5rms/JD9JFOy9N/r3 +DTqYxeoV/KzOUrsC+w8nStAjvdX6zM+oqrYb6rP4kQm3ugKI358OPOqIoCQ3AgarxldHQr1SRNN8 +ERzeo74Y/VQnguNXRTlwRhT4sSTamxYF/s6ghJTtjesS+8bc485wZK1TNVR0PC99sc10MsWitL/J +vfcqbER/jOj17bOR498StEYixJruY/RyxjDPOf6Rfd3/pPT2vRO3sgstPrjtNextVOlpInyr0Re7 +EwEjYEdQoc9EiNEooTV7AkYC+2fcSckKbggpKwXQanmo7Cs6Iztk30JERJ5PSawKcwuLP7207+jJ +CraQtj8yp6pMV9DNVW2fEhfaPB0UeCicutIoRH9/p4hDTc8AkH9VUeUPqkvPCCTuPspLiCuchLsC +y6HlvB/7vbz2o9542yjcv8b+Kqoaqt7Uli6gVlRgogaV+P4t6AYPVPlvVFaeoNyFdg01UXPT6Co3 +Zy4aJSSqRmwWjg8B2Bvy76oL0N0gIeIDVNn2Xza9GIgIN2MwdLq/ju9yjEiZYoDU+npU0qwYuU5s +dIjYtV4PkoaqZWlolStgD9wBl5pOJCXzHP6OdUYPRFckrR0hfhcMvSomtWyofd+24PqwaP5VMP/E +rWFXc7PM9v47Ry12+GFaVpUFv/5GE4W9Aw0hjekdBT+98/T5cwTGWvy8wNPLOfz3IAv2y4IaYZ59 +GBQldNzZD+oT1V3M5ClJJwKBBa5BnZ8feALuoKOb73/1JH3YX3pnFi3+hNCNAB4DvNmLU+wOgfcq +zL/fpNfR1Q/xbEC4zGEWUF5bMktdtPw546hBA/KOynZ6wQikeAWBfj26vs+ohgl3RYf7Gl8naqjr +QHkdR1rs8CZw5BgehryUiP23aYWqQ802sb+mEQMG2kDFrP8g+J0zDXF0WOb2CL+tjCWQvMO1qTyZ +w6BDSNMmdBKam1As4B1/RojCoQ0x9q1u72/yEXVH+msxJBncvCqO/kFNTTUHGPSqhQ== + + + 7R0Fk8Rydx3HHjI+VRi+R3gmZPiwptivD7/1D8fRBIMChMY4yzSOTk1v9o5R5Q8RPz3HH0FATPcN +WfG4fAA/k9vB7ImLwYWowC/eL1DevF+XXdp1nQD8Ie8sgoV2Rs8uE+4GqIC92haKRz2N+1B3kFwf +UU/2fjCL/+hdOKyU+eJSauzu/IBNYP9118yI5pqSvIC0Li7vSvFDl5DXB5hiOXJkfnjrVj6C2pgt +kwwmhPhFE6FU+17flraPREgYZoZYDID2TUAExWZcbMScjKPUWcTJE1XPPG++ZO5dkAKjLOK4AAbq +FjGzryM7dsdRd0c8DlUeJcrb+oxwES0xt37QGp0/HacijQ0OvNuDjEAXLyYZy5WMpc3XqfOO6Wal ++vjzSY1oQxlUbe7j3j6N2s9o9zB0KohoGu8pZfCc5Gkmefqnk7A3N4+oQCtT1M4u6RGFTG9wMU5a +N0OvMGawUONBtdMKMpgiMXathT7Ar1aPKBd1DAK9vEv0Bxo4qgc1xof+TrByLy3jYKz4bFSk2EvI +/+LoMNozAqBdATwNggYo3sN1XDb0jHhuKuednt5Xjq8MJ+If5eDEG/xh3GC8ty14vJD14bbQxS6P +Fm9EDJrNRsgGRCOiGAD1nwA4QJ6nTxGDyrl7HhqAQLAKvDNknChyUdBfpflOthrK+37HpKMFocng +mZrQpkOdsr9llAkgZ48RkI4n/UhF3pgLYvkNtEivB7p4j9DnpXcqFfngeoXDuzUP5Z+pNKni2vEJ +Kqzfyrjff/OaQvrhhDhArqRu9sEJrYg15M/llN0vCh2FveEHPLTYoxSdjsncpFfRCy6/T4DrLFHN +vIle2EyHAQMEj0ODkYiAcYnwoWOI2HIJJVTW68mVHLR7pVY+v8gKlavQ6ClJXwJZv+U87PtN/xk6 +K5rmEiRrlLExIaGv/ddekT+dN6ohXMjGtF/pQs8DZbpH+cGdkSEb9R9OFG7C2Jg/NCQBVuv9uh/j +SvtS/UNI6nvVv7DWg6gTKb0GUdeIqklTTcYXZ5mDv8WtEwHu/efdzt6OiuAKEB06tQxoSBnB4vGL +J6Kr3rYv/94Rwz4bx9dmkjr/NDyq9okkt7uwAPGj7RGZ4/6ivKa/qjoyMRKd9FcuqOP7rasw79hS +GCDEfutbROqTIlJxv5eDlvQPx2lNUSW9FR0sAFl05o4lx0VE2a/zZLbNmJOnaUlRg4W+XgcxorQZ +pYUA+IAovCUfAYsUai3+KHAlivqKyy2UgMq7uLO1GC3yARsdH5wEg89srCND1ZhbEESuhWEFnH8i +Ur/s5YBJWctIlQBa1wnYX5mAArnY74GRWzHtzXnQ70SFhvY3FUzrzTF0hR8B33Xn+UX339F8FREG +1eO+Quem7OtxStd67UU07OVcMeXH09NZgrLwOIDbCfnOvPb7GdvfZmrfMiXQjGzv1e2Hz83MljMk +mspn3/uICjxeJz1axtX+I8rA9057erxMEZrQu29nn257pMsNrREc2r4F5PvEnZXduepa/P0ouNkz +oNvPVdHm7Tbd4joGBM3PgBR9Ofr3z6rait5ifdqKngfowRRL6OEsByrHcKqFAZq+rb28z2fMCgjp +jqUeDRqIUL/RgJZjcFekjT1+DrM65+C+gf5/euYJ1alSl/X2dRobhv1ySGxUnBF7ZbzqceCdPFi7 +gJgxYg0N+XZK241okoouWhFxng62rePL9v4C9TyQxSQwN2Wt2DZOEiU0LrRiRZmJcRC3GL1FtF/2 +mvpDwHOsMNlw3lTtI+qZ0Td+VLt6vGB0kvjSlRSGdi8zP9q90CnsgmgpuRfjItbie0RWqxYucNsp +ukCEj+PQPLHZg8+gFtFD9X3eIeCOP0SgW8t+Sh40D13ghyi4eQz/9o++8+ZflbEvgNPW8Tw6Jtxd +k+5BLbWzyL9JBxcWtmaEXXzWn87x4ShA7rLfzZ+fxwCY5k4uJ8YmjRSKpv5PD4pSUujDtTBf7qPH +JMf3nAc8N/hulGGkFtzvRI9Nbn8NpKzp9FXadU8mlJnI0ZfbC9F+4FM57S8ElPoYqD9XDNRrANlE +2bqoaNWXM+NyP24sX/tM+LVeGB4OZTmCenHKybiGFfm65AvSaCz44zBxzVe+0BY8TI7rkjnz4IGU +6W5VHOqi+To9CpLQfD6eN8IVjgnVbUA8min7nX3vXealh16XhDr+2gEal4CEr21IHm4C2DH3is1T +Z8Slth6ehz0XYIHDIe5ZP2VAs7UDUO2caGdLLS8f02idrpBZrE8Ev8mwMshe5CZqcGoT8uuvJ0Fv +AaLJok4h+yls+o7C2xlaTO7tIdkS+kB6IRb6E7cYhkhxLoyNJKOjDoXkpUU754vE5b4lNAqdSDbH +/dQgtxGXDyVqeG9CuqNierrLlDFy3ZdbGVHuStexxEQAVThFFWrlmWbP+mwxQsRdkqBVgQpO6F43 +0edNriindVPtChtfyj1zBY90L1DxU2HjfX908g4ihgjoAUncrmYEufX5JvsGEIJ66nUMV8Hgg4pp +4eA0XXJ4Dzopr4bu9CivlU6bq64nmLZ1dSSZ13uCeUg+qHb2JGjFPFR1zuNrG7fHmAN+ywucILEv +7du5C6DhNwMUzJz/mi+TjBHV4h+jnmtUpNCaxW5mWE6SaQnkp0bLjABspBJB3U2Efuw7XbsVj7Zr ++vs8x6kWppCKbf3KZQ5X2y4NN9vVyAUAbM0XkWoWj4BIjX4x4a4jBgCjfuZ1SiK/C8vsXVNbOx5e +fCXCfZpuZu4gnxGCoOv6+iH++CHKTpdMSWyzA726JabrY1pF+IqOt1EPRAVSjm8HpFMBx98iPFO/ +JRbu9ABWdPvhOL0oY0SxW58VMOdUXpKGbU32CwqZ5PYR3fkdqmhhq4HUvh4USfD+lbM+HAnrObLP +tE5hWFFQK1rRVKEY+5eg1ZRyAPMftNDaDxGZsDKiLmIAWlMN+/tx0FDw90fzbMUWB10ZcM0PRIzP +iD9iy9/H6w8x+jc/8W/GtyaGy1pTI111RV2QebzWxlUo4PE6hsaCANpHRIrqR8OAfYcrmcsPx9mV +EyQF0MSI/R80jQrJu7woP0UwFy6yLJX4O2f6HiVoi32AxZBFpznRisM9hIxHG3a15fXALo7P2mfE ++7xNGym0Ww4194/HGXGw2BGU/xHocLzBGn3xro+gJSkhdoYXaEOgPwWczGtQXLMUUWhUcaPXQQ/R +smHHJ+JStPJRSEOlVSb++68W6zSzL54IetKC9FBVGax2Jdjq90QOPgvrYIs6Sxgkrp0eRlOYvdEV +jAcNiCCjIsRGmJFSkpbzjZI5lWg55URF+gZgkl0D9ywqRdvxSD/ivYzrPW9UuVSnwMbRB5/VMc+b +LtNFh9X2GZFfKfjvH/686yihIecsSdLjDY0rS/spYGnICpd3Jyrv8T+ivkEQGy60tsFYnO6s0MlH +0E4g/YDk1CcWZzvZv+tnRO7ZEGTGdKmPI+T87ThPJiB6HrRccXcrqVpY/xABMP3i17nMUM6ZvkWp +tquBMr+8vteXLHSE8TsdQTAwNHBQVlnqE6FGWr0v6JLUz4j3HU2LEMXgo9Dyx+NgJ4aidxEfWMLA ++fxnSyzpujhQzbfX+T1qxXtJkXTkmLmAPIiaRzX3mkds0XPwkUDsH5f2NW11fY/ILbsVUwHzqkfl +53FIUy41xndc7Sc1Gyc1e5KnWsFqrP7Clr8Mt6tMJS3Tuzji5xT+1MojPvGq5qHCp335fPzVjFCm +lURYXvOABXiOYVMNxNa756yQbYlCWdEVOnvBJJ+Nvztuo4Cx8E0xIv3Byd2N1zxkZo8xxtGiPRIS +/HdvIt/g2j3uhf4qLCqNpgd4oQJ4EZ0Y0m6aK1QBRUONFFNi0y6dmOdnRJKPIgnVVErk2MdxEClK +Inqg9DR6wK4WW5/lp4hbTYLkGeP+Smj/GIXsbxNshv/MSvr4RIHYsqoghzCDsASGzldZftkRzyzk +f8e7jPF9k8QxzjhBQPOhfTzjbWvNk76uqAgHBrwXgSeNtYc8GexDe4Ui/ND8Vd/eNvrbfRtII+Sw +q6h9W7xjO8IeUUGb/To/hV+dn4JNgwgaLzviS/hNJoKVCYzTOz86XTv8gUhxXKGjtcUedZ3NBngl +m4275/cAQGnNkRFDy/N0fUTtXR53S3yt8ZhtDuNUGugja0AAknYKGLbugqNpunA++HpoJ+/zzOzx +668YOVpp3DWtYMyMqKzBD1sw4xZhSbRms2mxv3p6rDvtRIbYpBKXTxD2MCFtB/c7DZb9nE1rTwxt +KH8wtOl67dTTaEWsreub4zXunRa7zO+f//kdpoFEZFJgufH9INfIYBpIKJQvFgnlrin3LRE+In7c +GL9HRdrkVrOLX2If55YNuCPKpfJu6cdvl14V70qJD+LOjRgIjXg+NmaJjWnjmTNd650mNORNJFe1 +R+Yd2dg+znWk0yoMW45zoVtLN56ui/OGmt4grlPONXGgkrLGsPp4mVTV3/bigBFQH3lmkSWpzon3 +UfdHqP1/ffCPNpNalm4WtPb7swrvfAFtgbhMBWozSHMSUKHLZhaoSJpZV+hAt6p56YXVbF1++Lwf +Kg1Tgfznz+2WocZkxzkreSLmG9FPxHMcA6iGiJjz60SqpTBU7HdE8y9Yk9re1jTd/CUhpPdjnRO+ +bpR/E1GGbbkWnZYnto3PkaXMmXaSxku7f4qC/I1yLxVBqf1arIvjFLVOLdpa1PnRKuHfG78wILFy +x0HsOuiDnRFnSL/fIJ1Cpc/qkoLEwaSPOk8fdakT7QOSRxFzG6c1Z8LWFVQMFlcBz2ftH3e+44gp +9csPZZQtbE+Gf76ACPf9jhQNE0ZI/Pw5MGg7/6wSPXKcBCyToIVM5fw6vu2GLmgyUeqpspuxNyei +VCO4Y0RoC4CZKT4inogXmRGDxHxmbVM0cHL4DDyKDKnHHUaH3ppqGpQC9t6V+ge4/H4qdj5TY4mr +WDtTzJ0FgOJrZdGbXEBypNCryLzTHkQoz6/TlB98JIgf51cVmQXW7YcSMOQMnRXdmBG1JU18G7fs +p4ARz7ynxgQ6bfDvUZ0mG6NnlBSe4VMUWCfjJJWpWjAQ+rTwGNBGImFFUppSDIAmYpeQEvme5zle +Gf7BZHxmYCM5E6a4zz4RIHhknyvDvuAkXRzRPKepuu9Idqn9no3ow7YD4dwv+wvbIaqKpixyplcw +W8ToosznSHPsz2mRzkQMRVkZH+Y8HWujHYHRVM4jFPVKw+Y9jwg+oFxaVHo1xT+fuR8UrE0WtV12 +/oLnkL9QHK0egRaYcUeDr2KF3S8uf+9ad9AqRwwEJNI+ylCv5MF1NLCY6vQTFQ6eucqcG0FHrZJm +JGNcP/ednq/ldnXONc+H+nbRwXv8c7uhZGSS2WbUjIi4hUbeLaiYCgCzJ0J4x76C8laZRjVG/Fqv +RoosD04roj49E0Q2zjRUyAnvymuj/YUXUITza+w6FRo5jlPVHnbhcSgS80eEveqcBw== + + + n5/iFQLQpC/49QGUH7/ygyr+eWzeD+vUoQdvlYH3QDWzBz+CZx5XWXA10r5kYH5YGY72+vHvac0f +Kcxvn7G3yjr/I7v9/ecWEo3m4C9R6f0Ml0uxuMxcC2P7JRHqkcS0ohIQZ4epDeWO2FvIYhhCn1dh +zm8R+b2mMmsPItSFCvfjOP7u+83hd29A12gkKIm84vb7QwTKBC3e9K8swGcU805XDLTYmN+/UmCR +IoxJMy+e95N2/65EBg0mKdLt2Dvff3nX7x1S2d/0gbmdz+hYgfgCEcKCZCPVEyEYTre7YYQavjXF +lAFRMqnP/U56n5PGKGvbD69bHRoMq5hNE3HbgrqlR+u7MeO7wRcwgOZf1e4t7PT9tksNny9VlCgb +d/SnZBqpkUNTYD/6+9+9ZUitKWU11al4LPRp9oFW8znNPOoGstQ/I/LjfEvbPo8DTw88WUOLc3gp +ar44lgRT/T3Ah6Cfh+Bguz6CKA5B2d5seUxXvdx1Lhey0ixRp7jR7aX9deEEwL0F56Aq0reIPx8U +nNMXbWJ+CBIS1URBPVSNqqBK54dSTzMUyTR2eVBKR8Xiw/4UxJKd+nr4OOCglkgvZof1NMTVDUGf +afwQoV5uUy93PQf98BnFrHb/dSkZItTiIheoF6ALEMdUM5V6+Y5MOXKJ8LfqfH/lETrSDhK0aRS1 +ClLljTz7jk0iMmpNwgcRviFgpOedCMDpOyKSFvM5arFYDIzfZ3KbxDZawQr01EkjZUb3zI3z4mns +Fn3yyB4UoImJsJyOPVxI/aAEiPhSla1PWLb7DUBORcEwqWuOLWaGwnb09y55OXdhn4lRNtYz/YeI +Z0jRREYHZd+vwe4fopBFitIgIkNsCXvFja7TinQl0CA4/HVFtpY1RLmDj4g/n1xJCfJmHVJ/OM7E +JXkJKgDqF1VIFSN3RV3d7L5HIAPevyAJf/gswpY1wpZCtaCcdz049g3uQegf0DcAzv16LiBOVC8A +/Vgnvkd8rSaQVqBRNzXfvh8HjZib7Yvlb0Ts/NK8r7IsLuFnY7Bu8eM+7dzuntv9eooT1aFx8lOX +V/UMFVYKNAs7ImjQEsGwUjUrrBAXgMd6zmRi80y8NY3QBnCRsN2/z5QV+4zeVE+Dz7CjrnKuGN1/ +NptHSU5JkyQA1DslkLoVSMuYzwri9ILGvhgJvAir+90bIPD4GyIyhbAp81meA3gSMBIQnj2YeuAF +TOIQn/0I4IHOXenBBOc834LU4x09erwAxtY8RQD+As+xqlemkLyyCiARFLAfHmbaHwEpNo7wJ+zR +W72/b0cZ4RwD7d3fd4q4nwCimB0iTA+AZVyx6A6lBCbMWypjLAUsrwHKfaJNEg4CGNyamlagN2oQ +fR7/dF1hJrTJIXrI9kqTnhTJiPXylnocQdiZ7q5myUVGzmyMJlnDNvSoVVOSYkRtuxLko5qUIDkv +jSa+RQT9tA60rAre/OE4tVkxPAALIolzR48b2ClP/WcE75fw26U14DnTR9QTD8W9eDgXBokFqH9f +y863SCdA44skHoNEye+kpD4KgOqoPIw3XmxaU7yBL3z3cT4Ub8xcpk//3B5bZ4JdypEsl+FFAyI3 +7fQHqK9DIwrBay88R67IIJ4MgkY/4hzkx9Be0VHxUsgSYLMpmrwjYjNCW7DmUvDR8deB0GIErQr0 +IN4mKphSNB6ffsi1KKHezBlo5oP4tN+HvhGIAu5oHDMmU8kfI5Cxer/Gx4ddDZoq3BtXAijmLe+m +cwg0tYZX30/EBTOtf0bkBCvpYYOisn48zs65AQjvOh+dFq8PUBXDz53CLtmDh+G5kpE95f1Rd559 +nR7cjgre7TlCbt+j/vZcj5PFfrFkZmNgDszGUAC62zeqiruU5ZqD7o/a3R332P4ZMcRrsW7tjWm+ +FMCPqLKi6kjuidDNfpwPywNta7UrvmnYVjHsF5K+C8z/zyq3VGiF7g9G06v8cByat2KRqv30FeHH +9JBPH/x7xMfWnI7196i9joXWsNcJR7lIBZsFOg2YIRJQzUEkcD5+zVMwQCZwLZlSipLNzsBL6OnC +aVLlCIojKkdQAQEtMC8EtHAbcIWogKkMsrzMeHUB2WvCZM+zPm9oZfaD9AM0YgaJZsFFDkF3jMcG +DBh+Hpzl0WWaiTyvZr/VVwGg3XadoGwA4wV8XEQCtCtKDTRV0KcZZ/wywA4UFNt4R+iqSgFqtFF+ +7ecBesv3f86UZqWPgW3U/CEI5KjT2gcR0BY9sLiwC9+eP0Rg+zBUr9+Xdpb/z6grinOR2rqtjucV +kQakArkyaIPMGOqc0d9mV+QfrnH0bXUu0U1mVz3lTO9ift2AB8ZI1yL9eVQriNiK+pOD2rr/+quY +vxccKOv/k/te4KL/Jem8HQcPskIYNZGMuyjIOpzjY/lTDiCIKHUxntfwcJDljExD2ptdmsn2wyQe +NryMkJZQ0VWoOYZ9UMaf5ZVtwFROeAvj5BZfMybR2pdBGmOQhAsbgySay5YXEF/QI+5iafphmJdd +urYnBWtV53CnIC+OgKAjWOtiRleA+TFzO/DI+48vPT4oUxnrIEqqerkzNGh+4CUlu8WpNIXsXxyf +ritRXfQzUbIHlZHOcXCJJQJhHq/EL4i+cpVwxoAilw+BaV8+G9k5/lQYhbfaUSfkxwfHnV0ZL8h0 +zJMPyuG4e9HUa+gRKlIFnsxGm1uojgIPfco8rHQBKqBkkOaHOgzUdrFmHYRA1TmIQXeJ4uzjOJkH +qWTEj08uo3lo1imNtLpDjf1I0KpFU33Ed1ZUYtF0oIKBODb1oPx3sWP7CFiBx61ULAAFNoZuKGGh +iIIv/Zd3kRBc4KwsSZQSpQYqbPIIaKwq++UHyviDMiTRuaqMKz9g2o/CVn0zN6Ou86GebrRPavBe +Npr2T7gLt34iln9+aboEIkx5OYXoT4QWQcBJ302Mio2si7kOYMcYxd3HKO4aR8pkCbuI1BPcQHXz +6DyA594HoxONsJa826l/7YuliDqD6knZS8M8g1jyXEcJxcHVBQN5HpfQGakorJ9iZQXO6YLNo5sf +PIb3GzzR/9+JUe8qRGF+NqI/NlW/qQjrqHHkvFrmE0yaXQgOqvJ6OzBH/v5+HR+hlUiD2r+arjWq +XbPO7+dk4tDpHdairOrAqoj9PaNh5nfVJd4vD/0DdzGmMown8O5t9QU1F7dBosA1GrV0RVjUYEFD +CSxEewy3GyNoGdtNvsuhaLjKA+VtORMWA3Op//8bDSJWd78Q9S5GqbMw19EJJAJhAvR30M0gQruJ +HTFEpoi/VToKO1UDYIsQcH8hUXfQE23DwSjVW+NS7iy2hS1go+ii0c7Dc51vtAuIoIRnsgVWDeDP +2MvKnURpu70wbSbJQOZ3RgeKMDJ0NK70I+P53RnVRBP64WFFDKvmTyhFl3ZEwO752WCpNX/H5xhj +7v3yqGUzu49tz03Zj5zVnXnDVF2jeyJ/tYeeOk8k+qIYWniUGkziBH17+dtjoQ5MApwZA8Uv3LkN +2evtNo3XB/aSd8j4DSI1XeXKUdhKWNB3TiMHAgVeZN95SdCUu11Q++lbzqn9AXBa+zjIlNH6ZEbt +PAk0R5FKuJMNvieW2RXMCiVviUo/QZKgL5Hwwygtwif9H623qzs8hIKKPocR8qF3PdgPo/ISWc98 +buZEftF9iPWyKpw13fIul5RlLwcfI2Aqz2FXtsOu5EGipKdzP+uo16E2TH5VcIp6siiYeN4IPZpZ +Wm5H/oqy5b2hNpu5Hxqx0NDV+ZdbfL6A4EDQa7wZEShkZUML84UtjRjwPIAuY3gzdPjWHJCtqKl5 +h+gaEhFKiLcgrtfOvshvSWrw0SWpuVpJWydEvK6t5VeVsFffpD59xX45bajuuCHpE7up6ZOV7zg2 +WMhrsZv/1UTtTf1+1HkC1cFC8v9T5+mQ28WnCuxllLI0B4lxmxii5IajaPALkLgJFqf487E/JKP9 +A7Ymlnlowy1v65G+elgSFJSvGePqB9/JKIAvzof0wB6gk8M/Eq/LIxyY7zqK0Q8KlTMRXZDg/l2v +A6JWZpiZTft9omx/Y79NK8Z8GThiEpejBPFY8Wzyc10aHzkrOU+0dKcdFLlx/cgoCXBcXQhkuwOv +DjMB4NwKVFM5IsSIao1uJ3Ipj6IPJGgILwHSRKxiHknePjOde5izpHZrGZLvO6tcrc9WgzyFfPRJ +mKV5I6sGeItCRJojeVINuTfqA4yXrv5JwEpqvo4IQN+HLXFa5BE1agg7mxEditlKyF5NQ/kL3dkT +gcseBhhz5lpCkHEi/qLjIcjkMkaJOicAAf/dnNqKO1dgzb4DGC96eEanXMDVjk6okpkXBfabOiPH +gOCf6JCjsdxvbZ/6OFBMWxWl7XqXUvMqURPi6Gim/NVX40//gm8jvScg7yiIcUkW31AZlMOmn/of +ThR2H3SobEEqmo10BRSDYQcOzQH4sLto6PQKOA62orfi8gbE4aaQ1JwRdouGN+zvLxZqWkbKoHWj +CvfvpjlqEw7mVfdSFgwNtcBJMnbEzgdKLgWuUMfxjOJdleWHY+z/v7581+egYhAELPFrE/rEsR5J +pnsBBiSB+PaYgUA4fQOhqJ/jqiL8AIUMvXuhkp3uKLB1oVXD7udRVibVpzFd7Sjb0Ni79YKrYDKk +Ei0mPEzIEaTgJeiUUJpx3TFQwin5lTQiqqCO1bFKa0ls7entKCCzctDBT2pIYcp+v+7qiDUVI9gz +jFAT93Y2RUAfZf0+D2UbQfQYiHKkjUgks0L+6np9pUp8pXrLBSj9vP+SeXMiWC+JeOdVmIuDCUPn +eaj8e6Bok5yn36dt39K2Nwe9Y029j9IHwIHRjinYsbik+fc1pRrPaWz2veINrbXtuy/RqIHq2WXW +pZN0+2r2bitocam7TMmqviXnh+TnO71XAEbcnZ3YXk0jvOt1Lh4DAYP68t3aPlgkvcsRzWgyOexA +Ipv0UBY/WrEMF3Zd8K7ynmnfzQk8wj0pIy7nR6IUkaKhRqNr36g/6zp2WhHCuYCaCV9CegMsT3lO +5SrP9tpp2DurUL5yCFPyRdLBbJGBoLDaHm+N3dCmO/iJUBhcHcyAPeEuRUraD5Cab79noM+jnLvI +EaPw5gbZWZ2BrqA8dup89VNgc8v2ZT7nY93ZSCtVlukK/71Hv4RiUcNowFaztFELY0hmBFTmHYE7 +nJd/9XNWfirO2s/XIg9YIOrftYpRuII1I9CHiTkKkEaYfbAAEF4bdoCXUxOnilwRU8WJ7DBKp7hY +KN7/XrcM8+LMneXTsz92Vy4cW1ugM4Ii5r43PqrzgKrYxRnyLIB9cUns5fdxpQFWUpkRy2ahlgyE +QOPxiKr80nglrgzX4kO4op0LgsohV6uT5d4BAhNBBgj1VbSD1Bou+ohpF7NHsiMabU2Zx/0y0mvf +L+NY5qSXaRqQ1eVoDvn+lYlzT3MI3mc50Mlb6fX955jeRNDsiB61gQgu0+/oPPZ2HQ== + + + o5lMO/dlTnCG82zD1KV0CPmqZJB8Vf2yXgjwTVrWeP/0c+tRxkW9s4CXQlxejC2PwAjkUZ03Ev/F +jAOWE0mlKkNwK8fRrHZ6vJ4vrG6Vnf8Kjo0uIeP/Y+1fdm1ZsvQ88An4DrspqRFyu7s3VQGhIICC +hOqU2EoQSQoQUKkkVCwC9fay7/vN1z5nzZUMJBA8QDL2sjHd5/SL2bAx/gtWb8HszbOP3DnGlM9I +dry3+TfCtUOtgp3TqIEOvOOKDyjmZchrjldbzSiKNQ2KMxBFcsHT3zV32QN7lYzFlFU97QLo5ylE +Fuupt6klDYBHhntRIulJ/piHgFSygb/LpyrYPqBXzN91HoXYZtWy57j4P2Fp9RrYcGHyLpIrk6Ag +yIyi7c7k9wqiAImEGewjhdOPmt/zN1Obv+e2puJsQqK7r9gNGt+triX4vRdma24iVWgKIM4DEpeK +4HyVyNl3kiftdcm9gZfzCXuJHej+jRfETHUzAUrqZnDp/7gODakHnPWP50x7B0qjj0pKooDaWpOj +4VnLkRbq9FPUFrkPyVr5wMcIGTkIkUdd/T5S1yiHvsohTr7qeO7bJvP2Pt94R62WM5lc8xOt7fFd +1CrvbBKqEzOAkAnSaR51jFvNCCT2z3maXrOYt88oSyCh0pWbp173iwi6NkpT1DvmFcLkyxHt2IdT +mTqcs3E4Zy8kBxE5sKqIejL5fCh7o9qDhf2Dx/JUWf/aj0lXjKjrjFRCM2UmVY60hzbzdpeV9eol +/QAQF7kKbMwijaQWBUx9dgIE3CHRP+1oJ82gtJn9QnKOvHyXXP91nqXTL2SCQ8bnRTZKDCeS7sM0 +O25Jft/HW8/WZSUiAkmWpBKhfwcZ0m9dHTn3/bpVa6BOlW0bVFLe8fakrkTxalq570cGXUT9FMNO +q6DRwwCITxPhN/76CplGfwf4lzMkU5TMSVPQsyI9Rxu3W3zV+/KxRtVtaNMKqjFJfZl4wGmjUfKK +s8PkAU+CjSVtN3Bmt1IZewPdJepOKaX2zy7eHmvxw76fG6HnRtf3AOHRKqGgyg4u1BEygIDGIiZy +HX842qLzoGERQEL3C7owBXLePJh1V39zfWriQ0jfXv57Lni6eBPFzRb8PH0U9sYI8MPCcv81ulhw +ntgIh5FKr3czdIctvN8olSH33r2b0pNvhYTsewRw+nYXwSalxdJVmVfem1clrJ76BGI1wEgQdM+U +AmiAhwsWI6sA3U4OQ5X3Nq940D4VxCM1eD+LO/lvgqu7JJ/9IJdjl6xcstJSe3VbOsYPu6agkGRR +s/YotSg4i77rBEbfxQOo3gW8TSXrC0aspV4Srfl1gqyV8lVDzCnA0vYjNt3FDUwWoMKzmerZ8Att +IwPvQB/BNYHzB9eUCsh82Ug8OOdMnVSU9GjFe/sjikvyuIFR6n0d3v20OCXL1wjzdTQ7S4pTJmfU +t67jtlGP7bdRK4+mBqX49DgLeaJ8umu2h8UY0/j+jnmZcc0p69hAwRaK0cE5/p2mRKPYfEpLNpew +7gaQVdnTEy+B6xg/qsfVn6MlxuS2wmYamDY+WLH3dyf3iiHtOzPvmIdL5ufWkfXyFZo64zvVKFKB +8EeBc+RTTVrEHaXV22UTzfRhn9W/VpsOehyC8q1pikGPDzHivGyiEDa7I4auYhbnQd7mJr1emfws +deEE0kG37B1fL38A6/gdH2rpqRHu59gZBk1XxNJVOVAQ+HHKuJV3gxmzchkV/thXa9r1veNaaPNq +zley786mcr/zJbpe8+g+ARE0UztKnnt652WLtbU6Phf16CL7x3xyf/+mc8QNKfb3zlenuXKlrLy/ +jA5pHDfsuMq9iQGguTy5HPt+NuyhXQykSuKQ1mmHPnvoS3QQTxVfoLg16qqnG15Bf3s/lxZOmrBs +a/30fBo6buV0k3ZOsFifcCpdh4OPQLmJpSlv99W+1Wu9A2czo4MgRQnUJQqQk/pS+IRxB2quS9pa +CPQ0kaVnFiyhOXbBc4naqRd9uGJ6boQGAZ3JPNo8ka9oiMLnBFKKcWLNqtCO7oQwnfZ1JqHsO6pb +dATbiTDv1WKixxUSYgOqqkZtS8wQ7RxeEQJujMgw8lnHTQY9X070fO3X9ywK/t1HMWLrFTxesUyO +gi9Yq5Hl4opWtzWSvYWJJzpb0Klo1XzWK8ndU2R2+7bSno/1Dk+PqtJT73VWj8uWGq7aajdBHNk5 +cnnu0KHsCaxI3F3eEVaPN/+6TkMVYVUNXyyloBTQoeYgCE/5mqwH1sqT42hvcKmTvx8K6L3Id8Gv +U0PrPnXNC+W195G9zjqKCEM9ioMwDx67NLV4HK8vJZui9kU9DmoNE4FqRKpmdwk4hAiTFJSi3jIj +kAba0TsKiGui7ISwC1REfyh7DSkYlHy+i4JPGGg9J4C0dE+f8r/pzcd1ClWz5/eJaGdzon6cljDI +Jvteft/LTsij4N0KfmjYsON3zRlpdcTRkFZH8JXsJdIjFLnO+oGydrS/td1pJvEAlBDTViaQQrBy +tqgy6oOI/YWq1CPqCOS6CAwz19F9hPN+vb4/6M53Udk77WmBWh2zRKruj78EN8JHCL+r/n3o18yR +vE/MdcCA2D1hQW+3gEfmippTskBV/+my3e2C+sVyFgdUILL7MFc5e8YnvGrm0GO8kzYhh6g+2GSd +QEP3ux531b2AzZfhWa7MLJ0SG4Bmup5N8XvKEAF+HsAm3Zlg7DT8ZePodxnznYtROKd40N7iwUPO +/ZuPpyPpk9oo7yo4PsXvAfOAGAbAK66spSTlcStk3CvkmamoCvf3eEyRTZtagDO8pVB1Jd7ANrjY +AuzvFhTYvDe/gY232yZrapFykHs9YCU0gq+XYd2iN7gfAkr6VhEi105NRQuPddjq6JjorztjeXxj +jLav4X85NT+ZOuhoDJBVKxJ68DuLjGdARxaEmHmPO4ba7ADPKMevsyUKwuoRtRlcNkJpb4nrxyhW +PeFh6MOuIzNtxHojMEsm4utMElEo+t0nQttY5of++0wkXcw0umneQCVI1OnAsIyug7aibHGsJKLQ +Tedi5KscBkgfKkYTMfNlcU16z0P/mZLQuEdAY9edwxTpzKjsuWuiq9AN4KaBKqNKZIAq74hfSx9m +KitKoSAack50T51V2CTB8YrHA3kZHg8W2p8Da4fSN+OqjZM5cMGK9CrbP/XQWJ5hCkJYAbtN7YqO +6RcZyZcTZ6UL4XGcSCRegCKjXPoc+n8NGsQINRDQ5GKzUb1KsaB+2WwMmthVjGFKPhUQl+eWBKXM +836e4qHQA+dAFokEkwhTJmhS7T28HYB9n14TzKpRqysUe+7gkCP0jSsFLy9GrSIDfMTmJ86b7fXt +BpwESJTyN48KbwnrM1BjpEfqa5nBFH4d4m1tinzyd2GvFy2cPbuyvbtjEFtOfVxBe+XF9ux9ae76 +hDhPvRz8Anw6eXMFO1y2f6Sihcoi2Rb99dajtCNcnux1LCs7e/VATTSzEshkK22ogCEJBOvdpeJu +qV584kEHzunw2o4xApJ4XJ5HnbYROx6EO/dFwjb6EH9FDaGBfXJwojQDuUHN9ch+CSqFze+0jBT7 +Fc09TYlGPV5KqGCfKiCDGqYxWIaDJAt+yn0rPiiiS4jwzxh88Gc4A/kzIgn7g+vdG6mdohzantiQ +vu5qdOHG1AOKs1uuUJbEnOZ8Gyu0/aNNH9AtFmeBCtQhGqOQrFn0m3ESpcoMZbWpSGIsKDWEsYAK +4En5vb3owwDXss2OMbs97/WIKvqOoK2QCNR1iSDTf890RXO/gR4wiKK/gBxqIDwy4gsAAQB65asI +AbdtmQDkoYq+ODlPexmq8k+4sBBbFFCYfyHzBoWPJTgZQKNAhRFTusl16F6AdI0KOZV0GxotMgsv +TZGuKTMZvbwrNiSPcwUlUdqaT48k417g5xJ0PAPKA9gJYFMiYyapfuUpn9Zv4T+xlfrijx3KaSTw +OnWN1PMv9/mcKSzQkWoAFPedy1IbWytvNRFFm6jZDuV7WpZBh+mVHCo1sF2UYjUjp7hqmUHuztRZ +wl5x4ZECAwA/Bpi0AH4x448eqcwsU24S9hwAsG41Fl6dtCtwtaKwjmlTXk2U6plIyvFmImcVGdVP +Ex8DMxkQpYsz69SB0pWQMHHuznNI8KRVLa9hlTZArYjK7PVi26t6v+m56CK+9u3RUOB2VecYlK9l +Wv82FLiPunB5fMt6OfcWr/AZraFbeFhh+xKyvmQ4GBqsbD8eP4T//czRXnhPlAVFk5d2+N4zfG+1 +Ii96ctUIypUGJA2LFAkBQpMxsn3Oibodrn2I8ipyXj2iO5XHWaWDpu7WnQwLPeazr65aUT4+iDG/ +mQrzuKjkq2CyCModcUaQAveQJHjOdJR2aztKI2MmMUX098kvUjaumvwMrdZyGGXVhm8m3pv7zQRj +1KW/0PHk4tKBOE/ZDLmkAPEiQ92zJc+kSp0CfUhDyEPABo0YOy+n0UodGU4L6ylEb/7Q29c6qOLX +3j6u2HZS3aDQBiyCfgjgI0ocIJpNmuUHR3MC+IAqHCfv5hBV3vsjFr3rSPKVUUk/oOyMD2HXug0h +mgEkKnOIWtA70V4N5D8lNfP3fataxDDcp1Ku1TQLFqtaNrf6eb+XduYOvGpU2CNFsUgPgRBYFhaC +vmENBG6L+g77COobKh6jdgupvWCRR3NY00IfeRgC78JYYjQIgs2bDu+6RizXomE/0GTBZDPHdc5i +IMyf+W6LVMaVb7F/vexagm6lJCZIBj8dxVP23DnvchyYDsJQvpgZSIqxv9A4VH7UNrHyZSdgQaeD +gopIOE3lW2XKS0AfezXSATQg1Xpq+meHVcF7Y6+GqaC+m00N6V8kck+6AusEy1ZUiVDEv9nVo16m +5Q2tOZp9iiHUWFeJllixtQ55gjYXD61WBwFJ9nGquBQZJ4AZ5LhZyFktF+ByxPRuTc3BE6kvznZL +USIh/ghF16Del1sjmGBAuW/sDV7hwADUrU64tR4wMe267xe9pTxhHfwCyTBzmOwoByKAR8gXMAIS +vapjgXrTjZHq3DG5osGyhuBqwNrTnalgYvVKxlHflA6ypwo861n2mBMtK60VkcTZlaNmAxeBkDa0 +NsYo+/mibUhJv5rm8EZZ+KaxcvWjwq3+5P6pPQGN4rCdl3au3VCuXyvfRBSoQ/sH9je/kw/QjVI7 +iygQoGpc9aPUat0HPoDUQHCeYNlQMJ13BNFtV4CYYWnvcoJgogJKHS9R5A7m4KJKV/NgL/hUzAk1 +3W+nsGvPNPWJoEmqNVCX9bgZmYQRRdCZqyTVpS7wPK+06yEeFBrcXuAoosIHGTYmkfVSSpgqua/w +HSQ9yO6hxO8hByNSNCQJfrPe/DqTCNALwscTC89pviVQ3iam1nzXk1keetVQUrFkYxPzrin9jK0H +6hZMCAfMPw5ZY19LlBFkkEOqvmXQhR0V+O8ci8oZEfTxiWBxjUv3OhT/G63mC+bcbw== + + + tgAcTqaWW2iM6rFMeRcqLRHxdtNXmOJLqPpHZGPdwnVH1DIA2DxWfe4ndZJ9k3au+uL8rygYitGt +gbgH/yV7oXtzXcovHLd6PLliV9npEw37mXn9Zn4bRoDBgnX8A8+Z1jxi6/urLin/4wDV9lIya/y5 +o4tP1nLo8jWW6NptycMSSjSSBYBMH18ytTM1VOXuj1VjPFHFdcQ03b3kpYToTMSlOVRfltyxVc83 +0DgrEdJ5IUG8Cv9rBhFH60x0K1FHEJ16JPwRebZ8T/rmC5jsCSBzw8Kj61kGyGZ9TZdaDSIQ1ZY4 +qVsunjh6Laf3j9VW8z5APl4KnjZKgmwwUNc1FebCvdyjfXdY/vsdcwpuf1fAkB05kBCQPQGSBakG +o8UdK1Wc2wvIIvUi39fxeVjwrWYY7vpC8gDos3MpB8GzX7TdpIMIDHO/cFMcQz/LICoTfrUrwlQ4 +WB6ViQTRZgH/KlX0OoRSHqy9L/63/yYsNytzNOZux5AhceqL5iuIN/n81xEzuWUKxeUh7LeLyoIv +EPYDOgZfB1ijlqM+bkOouyI3gypMuZIrjEC5lOnjbsWBoGfHxG3MG/oqxN4xo7zuo9eO1G66IJo9 +XmyGQ7Jwsn+ssRxoRo/gwqPP7HX2SehI3q8uPMIeWgbu/zdGYOt0DHYU4CZrJdnpkiRyItCclCMR +Uy41wq3ZtTWQTPe/oMJE7ZktAh4m5BeSvfDgqMs8YCfaZTmhwphfimPL+3C3JrN1/97iRAjWUgeU +fahysPXw6hcXhN7YfPtd12W/aykoes14GFUIY1coGMJlrgMB/3dnIyvlsKKDX8NuCzuigl4J80Zy +AeAaeykU9RyoR92slCYVH1hh0GTQMl+t2RVbkj1JtPtot9Ottxw1ZwS2euT39nF6qiUNRo22vEsR +IJc9bBZ0hSQhpkkDpeNV+mDlIync36LXckTkaWeVBrMwtt8BJ+BjqWIv7S8Ue8F7aUH1qOBBDebx +5xzfPHh8ubHgxC0a7XNMREwRZK9GqTx7+qFk1PRDPY7rDD0x+ugUIf4mDO/vCfr77/4FP/p/9YH+ +hqt8/iv+95O/u6in+ijGjJCfpRcxF/slZ1fzTycokycuIOrh/TnIS+WcvC9VS/1G8TT+vp5zCVlC +UHV1CwRt/t276YFV3FasDq+OjE496xJhnwIbvWdiMCOiBA/1FalqO3KI0ZnHPoexgZ7zF+d3R+17 +qjwWe2yjaFoQVTWdIaLr9DeqGuDAdaYgmjJTl7yP0wPHuHIMleIoHZSXYC/LszLDDKT3Ig/sfGqZ +pHgcgVgg7BCLCYSlKDGMJZoRaqvRiNexhghycSKud93tx7GRBuZN8+VK8hTNbRSkkYNjuhlupnnR +YwUo2+CCStLdBD9CdZiOjmpzUxSOSwxg8fLYwhRgGg32dixUSiXhrtDa82k9JYcqtam943FKpQGG +jxIIhXqI9uQEIAmvIpclrmC3+xlrboFO+ICCa6/hkS896AYzRS7gOP5n8fgI8exr6SLH59o5wWhF +P8O+neiqP9qcZ0Cvk5H5wKtO7srSeR0G31i6quws+ADJjMIZnntzn6zH7z/AdacDDBCcgG7Zeb1e +V8NNdr7KyS8y32B6/CXOvvfvtA2BLZYDpM3Mtpe38gTuxcrEjuXyIaB17ZpTJV1l2b75Clon3J8R +5gwlqTlteAEMH4ex5gmlsQXBChRET66GI/r6DFhcQV/MxqYwp/kIOugANgi4QILXw8MPUEqHD9OE +CXUhepRk2ZE+QyGSDOTbA0ORkYc2evn9KTTTQdXv+aqvI8/fNfzS18qUyF7RE09dqfHnJXOMZuYe +G4oYwKwPigY6zp1P73nTT+vCBzt/LDn8NOHSmZ/OeHtPOBMRBDEqRGfiEANFArff86vnRBAZlAIo +I3Ivis3tgP3bYkq1lykPI+eHiNufNvdP48XgRIP8GsW007pjCkV/mCm02mZiByY6DJaEx0nVUUzb +PH4Ld+s/DfSDPJGv9DLfv0fZ+YbcDy7d7A1JAMAME8Bpc03nCKzpymGA6qS/qPPkPe8T0U7Ewf/0 +Gjei72N2Dx5LILgmF1N7Wmsk+hz9c/ynB/UjCjo+uq1XAUfRFANuKv9VSqLh3Fo3LEOpOV6lKXWT +buhpDVo86wLoKGFnhRA+SsuSxhn1NyoF1N/W8QGwvoXe733wBEYhtBCZqseooND2PrVfp443NYW5 +qpwc/ASeDNiFRF0VGonF3fdFYpA+Jgy4qrB714ZXJXO9MC21in27DgiyH7Aol4LtZ23ZMDLQFJbj +AbvPk77sfYPHffQCu0raVo9iDnmnwOrzLi99e1jUn2BnwVz4S6yfPFLs+2dEilGh4n8Muhm0SrVY +7GdumPVvuu8tzxSlMj0qeJdMXOblJDr7K7dClPXKm+ZrovSN52XvbR2XPhWZq9wcEqel1PAsGsr+ +rfzrv5p0HhrMv45AL8rBijtdhRLpl8CtYMO25Hzgc7RSpWR7nTJBNipd3NSxcBDcwfyfl5TKtKk5 +drHuIZit2UNIBRhnL1L2Jqm+9FBOr3oxHytxahHADkgF5pYRWoSjCktGhJdL171rQqfMmUQDIAdf +ciY9OCimXS+i9e5B2OwouYpGXYHkK/CEltqxVBbpCihz9KPiHfnn2nR9JgJ1zh2xen3F5R/V2ECz +9Bi73HaUKb1Xxd9HzM25GqXHB2jJaUfK+jA54xNOYvLMUy8V0wgz7/lyW7WUvpOkKytx1yVt76ja +FVVyzTka1nKWd8cxWQQey74K+onsqz0FV6WNHr0I2PFSD/9iUbjxJlPpLaZRNEOJQgjLAJG60MSE +qj6vvRmaNcUIWUk7YoyZCDGZtLswrsyJSnrotJP1ACNKYmGJ0uQeuOo5QbvV2ZnNDSQQ4+53DKCO +AOkmhe3eiz47hqJ7Kkz2DowENh+VcXfs1k5XFJhUB6hUVIj4W6/LX/+Or6gEE+Vs94uD/Sj4myhF +CjkaeTmF+JMQQ5M6+CGgZkSNR6AS9a5bogqkj4NDasEhcYWJKKqoK+YRad1gmXa+W9dvpA9W40RF +lwWkkmgyWDKjehzVjK9XfQ1zlhHp+WCu6NXW81HEhTjB9dVM7QcBtu/ftcJ2LwpwAginT06hDnAA +OlVkdM9pClHqBfHXENW2vH5fEtY+IlJlqqcjyiu7fjjMRMqc2Rx9xhHWr5nbUgYi2laRzxjR8IFp +PqxkUal98SBEUUi46DYg4bKjFBukjPkcf13nievo1BPhCj9BjT0xZY86D6CIPhPBzDq14viDxdkV +ezIk/KNEpOjMjrquHCf7K0nG50ywVXbEEockofvReGxv6KJmBJCH30T163dTLI0oTO2h0L8yQyQ6 +MyTBS9Et5JSAnpV+MHgX2JA0xbR/ZBWlaz9QxJQk2rQs/FpTKbs+NvdKJGWC0eoAW6caJcrbXM/J +wSkR0zxd9C/rjxEkNV3JYqiF54H4HrVC2lPF8iqpIgl1ukQ1NUUwhfbsFKuIvZ7tbbyAXamfEf94 ++iKq0VxImivw+3GcA8lEdQAJ7y4w8j4DpKbIiLVgH8O3xyfuFR/7jOKVsNUwi85X8zSpuPhY2wlt +lH699lpIiXEefWHcpdUxXsl40OMuLyKBIK3Alig5o25ydmQ3R0tudZpqe9dIyqMxqiLKi7XTiFzV +hTHbjJqiEnxzUdT+OhM4pkfhAV5qqODDqLnXpJzJot+O6HoaEDHzoAmJw1Cp3PWwyJHy3unLeEUd +XXK85GwP08Gw5IPJq1JONL/SQdyXzlp+jQw+1/7R6+17xKGf3taOX1O9z6jrYIH2XFTPtR/WyckF +yLEprgq2keYRp0puyve/50E+XtiF6yMA+funwT5YvBJGe9s4NHP4GDDtg7xzk3u/xq0fUTAMaMqs +WJSqTeOtfNJCXQJ2o/MqlaccQQSEnCNNuKe1+hqSgbyOD1sbInxg9edmQ4ItwWZwzcFmRL37++NA +8zxls/KkgXP49DD8+smcwMXonVTYXh4gcISlSXTuQMSKzah2hKCVpgSI8qRGuJ8poStqB7jooiJ+ +eqyqslq5Zzk6U88SQkxu9QhQVVSlIsjGtpqKjijuY+wltNVZApIshdMYXGW5rGm3rS7jmrF+1eBh +g8baG2mFZ4mAtUaEVqZXPbrzO3kdPT1cMm4iftsOAoG6I9G+x4Yn961iwJ5ST+MMBTSNFf0EjNc2 +9jqZ7w1EmYhR1otoA7p0R/CTDtByT3BrNRfMcmtVlYPnwPz38yfJ72/nRH/PTRJUJeV99lta7RRq +oQNHuFd5j6Hjl53WAoidHRV/F7Oj2iJb4ldFugOllD4wNDqaLDagkcFRi11N173jq8jYjyucJ8Zx +NT0MrRazB43OZhRHm4tdxX6weRwL0ztiRh1mxCgE7Rf9JuoxqyFCnZ2Xboim3DhVeKNI1yi6zZJ8 +kHKBJ0AiuFPXOpdfYXBA47ycfknEAcWoDwfmWr85ZoJxgEc/81hNoLIA0lLZe2ruM/mAWmYLGRuo +TuU+8u0ANtajNI7SUPt77N3EobDMgNngqTdIBnoOimPb+d0Vlp8Nbmri5729QZeaL8hhm1mRADZe +LYujmG5yu1e0VQqze7sKbrUlyqkjRLWQnJdCR/6ItKJ7FtnS3wjqCtKg7zSr7VfsiPbi/oyC4UlU +Pd+HWYuogU2NEXulJ4KpNYsXOSbLOahvfxMdAM07bearC3NOUNNxuZMesqDdwvYRQKJhg4/CqMln +bPku9BgkMH2PmCchMQV7ZdWNWidKMGZXATK8IgQJSJ2pwXR2qABkK7BmtbPMH+SK88vy93QT+5HH +AXhz//4MADW3w3g7iOqF5zBt9wN6RHwm1lboA1c9dJj0fnsoYjKHHduaKdIESbt/M3w0lUQUvwex +WT18ZNWuu9GNhTYs24FVWJembwF++w+jwY/D1JWuSqd7zAzdUxpx8ZXnbMQ8Ec9rivbqeX0fXKxY +0hueK93UJ27k8IpvnQoe0Vi3MlDwGMfpD+1JYOit9ba5xI+V3zo9Jmdo4NDWNQqUQoxPltv+46O3 +RCLo31C0VaB+8BmA3Vs18bj+6Hb3pxgdQdZxBFFWZhxvjSbd0cyqWse38KFcUOz+Ttfue8D7WC0N +dYD3/RBU1cvhNaXYrTdfc3uGblth0yqZP5aMmAt335sQpvaVbn/gn3uBpPw/2U/EtIL6kL6M8Tzu +7qbAsNCNqRnQ2JKugnyaFeFDItj5frXbbdQ2G+TNKP0NIRwOVYdKqMk7Yu9XViLk5ezjsN0jIs8y +H/CnrJMhQdB8PUKEtAHdJPcBs8GWpoaZHao/jlRmGSOGWeth+3r0JABYmi60+zMiJ1jxI0M62ySe +qHUniuSbeyvTBxSQZplow1ykdVANmCU/I55AcwXLvIZzH1Ea3LQRg5sRhqMwEEggsdkYJ0UBcVhv +tUgeVScwm27PZ4RngjoDBRZwZJ8/HUe7bViCJGp34D1M9LxaTMM/RQQfjc7Bq1LyEQ== + + + QxmaHhf9++fO99U5XT04STynrLPXwwIKmFmRbhuaMWzfPiPeN7R6ZXDPeJ4fjoMXj5w6rNpK1guV +y9AvnT9GsIkKaolC6u/a6hMaJxr4TigRGBuRvYBgeTTnbpWdMaQtbOf28leQRcCpGxWgfR2o931G +5Nr1gJEw1AU/83mcV88TXm3t4yRc/UrChZdUuw4cZSfOypg8d6w+dpbB7vGsB1f2TM9xpmzAHyCI +o3TUzkCFo9gLT35MYuBY9aI24LH/GLH/qF/rzBXHuh0ldMGzu6frlL5ynO4vKEskrGJv7mTg8VQD +zMk5RJ85UQzE0Fx/RYl6lI5R0PdOgCttkc+iNaXQJnMCxSIz6Ik9q6oCIy9Cx+nMwlULeJeIfq2v +LEW4FhAlSoEfUeo3JLcEgjwV61YIbOdNzzDN+B5RTltfL9y3cP8ZpZcT38CqSScxQCETzoCJIZxq +5lN00+ku71/yWBIsMRS6mYHuL6XNcfQl27GCo6kuLGm8sjiIcQwjqAQQgRtyIqgEEvEqCgKtJgIz +lK8TRCeLNAYNTKumuI5hZdrOmZK9PkM5cZQJn67avxILuSn13JT7RFgQ0T7jLJZcP7cbndSqevs7 +6/G+CmCpfrE1crdLUQbLIbQKC6VnchhUPD8j8FCkMjxRGni3Pp9Rd4CdrLF0DqqtxK5tapk/OfOg +wf/87Mfj44sYTGfeHCdI1dn9V3YF/TrqnejFKKJas+eeQM9IK9sSuRGVTC/2ktv11zMJV70YbicU +iwLr+Jg1lMxBMrHVRgg8Fddlzmo++8SGnJrIZ8A/vm28aXF/tqIM/ffD8N6HpetGJzvZFR3kQenh +M+LHBfIjir4nynuI8iIVVZ/xRTGFwHELE7r7MZiDt0czSBbZoRNbIZrlDy7xPS7xvLVw4gAewbG/ +7e89T2ys9lVlKpOUsfRs7U2GRbOLLClLfUe5jpp035BnxlueWceP3p3vY1YxmLdo/+qS851I9BHx +X04Zybn74+N7caCmsndvUa5Z7ex7LiROqijJhz4AjXG0fmQYdx48CFKv9dGV7Mqguk4QxRyCaFb0 +662YIdj/nIiVCOFQRqwTUd8I0P5ElOfLZOm6wnkalnckPF+H8HyHvXSFCH2MptelhBN/Z+fLRKjf +ORFIW0IxeXnQ/XhV7AVsX80eBqo40BIcLGKdqmhRAlVWoQT6TE2Q1vuOiE2iVteIjrIYQBfKCV79 +b9qU74YIQRPNoFuaAeazyLCIQx+nZI0OWVdH0f4e9Gkk63G2SfWU7eQfSvjxn1iBhxG1pxIoHG2K +l9oRmJAQsffk6xzniVd6FQwwnS4YGH84rtPyhabYjC1Qj1sxeUD59WOEDmU368GdX6CGzYXz3bEP +ClkUyZi3iDtrTDv3Jn02eU2wkKv2V0spCCbxFbqUnhvobEuWLUjNJLmrB+k8rvOcU8MKixWQLizW +R37q/oPtBAsf82h/VtP8GjWzz4h9SWVoo8b51aW54uhgFJlqPbVn2MLt8N8iwC70fF+g0g7oca+k +AhNwySVLxSV3iSNFkVpMlnCZgw4/gjjwygueg5QZ+cYP2H1wSu2Y8EBfw5wW7I7pxqNGKyjpkhWp +4D8G6Q0SNeC8S4PaF49a0kekhR1o0Y66QGpdocYRoaMziKYiSijlWCJq4eaQY/pt99MHrk22NrDI +iwXtwLxJMTUD4FugdwNec+XTVosLwt93jh9ZQbBbvN58tLjl79RKjIhgIKTJ6xXFr+Fl446MsYfM +g8WEcluNEVrfWfqBFcgSps2MY+6zFhq8v+BSRzkACOMM4ojck+tev3hY9YrKShEaeoKGQTSVKhAv +KPSySYI9UoQFaeUH9u+OENIDaVS/C0V2bJ0yS/4+jTUU21Ml55G7+qwYFnom4FCcye2rGhrAwGgc +OW5hq0gNyHkCsd2z5Zy/LcVkxyCPO6W9PpGVQWdQQwQZePQ8OhLLRWCkrqYRM3M8ZIZ9bKpSNSJu +HvOrcftxFDitrG60Xdu50ZoOFQT0WpjqPFBg8OzcKHI93r97VFCPqpwUqKnz6zPIEkk+aBFHDdm7 +RhHAntpHBO8CyeHDJP6yYj+iQJQJQEabiNXhGmlbY1fJ9AvhI/JGXVO1eByWdQZmBl6TefjXPi58 ++/uuP3ycB2FFei7KS5SQmG6+BkaKUch0zT88PSssmqUbIsyfA2JYh77J3hewpRoAwZdyHQuVdBXq +rj9c5PwpTiL7Lg5/2PW2mHhUZqjd+lM/MQ+p0DbO0V4oK4NmLPxNOGpBRKT6KakUdLhNvmrwmqrk +AX4yguWVCNX86hP9fqfKVr6+rutLZS4Q699SCgAttsiN2NsoObGvQFshmTKNA1SCEGrvzebT94Fc +3O+Z2cfH91yjHsK+XAO0g1pQlDfRLHo0a/8e4V0cuYsH8/IZBDXEmaK7AT7fc4iIRbuKHhapDz2s +Z7WQ2AXC7X/NLyzNXQ/UhZ0QRaLvUcKpABQCp0ILgisdmFJJC8OJdUSRmolARWq+Y2Bh46CxrlZE +uvZQWG4BF/eBU7GWi7iozw+17o+IOmIvhKjQC1dOFJtNkRvrIDIfkROdioECRtHXJQENLutSc42H +mcQGYVaNWZ47HGScLCOnNoSi5LGKveWDToVkiBX3XWxRcAMhYBUPg1DQOIaYPQPLqRwDm3ZERwGu +sob338fPEgm1hHnoARnz+HENpwoKtSNfD+Q9EQNxJU8AALI8QmqimkpPGtOf6/79GttPrJDaXUir +Sgw8NC41lbRuHZM+Md+oUKrB8T1iFX1/80J/H4TRRLnOOYcTwCJzS8TuuJjPka1AGdEnvlG8UFoA +Rifpy/eILCEzxlUlMgU/HAdVH2qFqPpc4h6HksmfAxQiTUTuWn+DC77FfNPOprN/SYyGyHsHdRHY +OVbExfxuDvVzHgWMPiK+5g/aqKg/La2Svh9nL3nWlundy81hoyuW8A6+C6gZ2UWu9dAG4P4i1WFo +KH71tqqrq/A8ADUxkDxNHheeDmiAi8oS3BKOa3LCVhl6Ie4ACDlErP3r+HZdymmNEUT9hiCNZ4gQ +zUjuqVerrrpdAGrgk7XHAKGI6g1EVW+Uy+r+ueXlOWfC0agFfnL8VGFMV6T1eMLmzpDhtHwMrHIu +wfwimCRIkySE+QKkVJP7oiQFWMS+51LTsMSTsZo+IPUw2nVAHskKYPPdnxF5pI6aI0TFsvoPxxkl +Thl7RrvkUeL+qDAohDByfXp+Mza64afUYI+z+xkxMC+ATFcUWsNx2JPClIm1juPdntzm4cqGGNQR +z7y9pJZG6CgJjKWWYM4w9mR9TOU5TkjbTIxX1L2VgKGz9UQ/Ek8O9CPr7IfDr4cK5YF17KbmSgTQ +mRfQF7QXL3VpPxxnHSEkW1ztIHtvcbXrKj8FvEzWhpXii7L6FgT9ZipMP50M1xGZgi+91iFQUUe8 +FE8u+T2PZsK05OM/XLXPYhZ+9YygrNHDA5ky5okSiDy0IdWT+Am683LCp58kJJoe/syJ5lIPYFqr +kpoUQtl+TN9ZhKiZjw9x2QM7qXwcRqukuXWYTaT2mgwI0fmuriCVDaXJy2LRS9PHm1uZ9b3/jwR/ +fB7oP7OlhDYf9OhdzyWN6q09zvlDAJ0Rpf4vyiRf2NE/BfFcGbT3ANeRexchfu0MT9sy6BQ9+69L +wi/yz4m4wXx9RuSCjWR9CDHI5v48Tjt0Qwo5R6eliqDDa8TKST/80p1Qmk+L585FEaziu0LULTjx +JqFOVL1P1M7R/+35Pk8mf3JYJv+o3aPWABJ/NZgg/n66L+4WT53ozwGUXZqAyQaW7Xed6E9RHfkK +ljepRLdyIdmHwgdtURTUZxYJ6+4Gfd2SWt55H90queewyi7rEFZW450D+MI1pYRfuac07PhOBLCp +PRzvw28La5LS71EIq5hQu1ZOFZo00KvHQlQyAQQPOtS2YdDBNbFni9bqMSkYx6TguMaDwQ+y4yqq +5UL+bDIh3UrLKFeJqIl5KzE/VDUc/XXEaKnlPcqA77xLXfHnlb3dL+iaX4AOEz8A1Y/i/nRnsS0e +07xDOxqKJw08rtzCOy7QYCcguP67fxMBdJQ4aEGLTKfRJdENjTfgB/1opO131guBjnuYRks1Qunr +j6CqfV8Bx3xEvBCmADeGleAfjkN1W4q03hEQURYbkt8DiA4GezXaemEa7yBrPCRFDdynus0uEZ1O +KZJa+nWJg78qGwdsTwY/vbMDnPYFervkJd2U9/56kHKKe3XlWQI6ZrOC3j0Vko6HGFJBz+siNnQg ++PW3MXZ/T0SfXPt/kW//rzzYhVn9+COF3v/xH/b/mL/+m//21//2//6XT1Z+/ff/j3/+5//Pr//m +f/if/td//5//83/8v/7Pf/if/r//8D//+//j//yHv/7zf/r//8M//+//8D/+h//jP/8//69//v/9 +p5z050/8v/7jf/qP//4//8f/8A/7FH/6cs/XN/gbsgD/C/8X4Jn1YXgt+3b8QqnkYhlGNgdz+V+o +V1T6VL75+878UuGjKFuKpON+mS5Ui0hzKDzgVb3/spcGNrTvn/0UUMdCP1kxnJ/ECBZupOKrrmBm +cZuHtf1PGURt7HNwIclLCZpClkpTBRJM+6W6kSqQ119ec0V2yE+JQ1U0TxfZ9PilvrzuWZmvEWrF +IPQXHhTiaWecyUnT1zop/3P/JVBAIOfsxvcgoo+/GOhPBtg5MAAowoGrn35KdoicQSmX/ScVsO+d +YaGW8mjGmtjuu1eQznFAd1gHevcTko053A3XlHI68lFqjsFI238gT9AR5bv6FAyqZfNOoAM6TNwi +3nGaGn7bEfqJ9DcsJyH5Yr8WrO8vAdwCl+6jXoRWwUligb2sFSw0CiFCqkXajXPD9wShr/ie7or1 +6UUhowQtLkAKH8GvDIl190DJa8RYl7s+JGyGf5eTv1A6Zh1ZUEqWA6E0jFG+eEF7UIlrZOU0Z8Qb +Qt75X9IRA2lCC2/ZAPI0MP74+1lEu7udCBgV8ZQTdw0ot/upUpDJJhp2llyU88/M0echzZ/wu1EB +9e4HLIyzwZ8GbkX5byU0c0G+xlipFfPHnXMflFUt8A06Ii4OVQMs1FDqGJ8DAUTtT5UfBrUH9TtQ +7UVsEnwJnnkg5gNC1UsbEOqXyyjVg3q0tNNiQrnr9lMoh6nozIu172GjlgSokzTVgUtjPdVrz9Gg +X6oVHWw/YoPkDrQMgrtS/ZhJDOlNfLfCd/mmLp3kB8paOCoWxVVXI8e2CxA6wzVsVndLVOfvPCvw +YuC8PG+l6h271ZECbUPf6Bf9KvacQ9lQsCN1oX7+q4Dxw7vy+4BvMcDGa3wOXgKcLfQv9Of3Fbx+ +fCqugBDLr3KduWi9yvXo9LMKwwgM3DF/x9P5zjtbpLKfSUkwP9Zpe7Igl7qFAKjdyCoAco2uuGZs +yts1K3vgA/QwYyAzTzuCq6Bz9nyFMRv5oQA1HjUAauXITjEo1PGQrBgEJcOnNFNwAA== + + + OI1tovJLzMsTJ0XVZvff73HUFgvb7Sfq/JDv9mC9NNQAmzNOaxrJqDt+pzshpzD++XeOJn6u/jA4 +qY2t2AQg+ET///cidLls7fQzv1BwQDlLF3LdLF177uBT+86cxU5SP4vddLH7eYl8E6ZwvAu7jp1x +ooZRD3GJkv7eIoNw/CcnDbDFoHUvVp8p5+ZYYRY2ZnvKAZZhukv2XXwW2bAVBLs0IW3vDFii4UU2 +OQXZC2SiEUiGh4GZEXtzYASCrIKhHl46JviZwz6KbdCnvR8jeCOJKOWgdUskojCF24tFDdQppgLI +fU7OVPHN4kx7YSiBTIWVtSP27yCAEvmju/eTgAUJlhPN05ovQ2FKs33YiQAB5R+t0vIm0GYHgI/a +/zxAOwWQyc256TuvhIW7H/bnxjA3M6SwYOT3xzivGlK6kaRjawNhCXxAYT80cNHZD7EIC0VBENcl +0+9EaMASp4hjreffAPzuq7N8uw8sA5QwDUwD8AlkJWbTsgMOAhjS0jAAesUOqFcNQemS2oLGTfl9 +GpA3BFUsWUTfSjl8on1GRMVfecCNDNI4rsX0bFq+SFFhFEegO1/1II0rO5VzIqlgi1P1LJ0BC2tx +Mfc1ptgXYiS7ER0d9urxN16Bv77vC5pwOL3ODtOpqVn1KOx2N5/CfzpR/VJ8Zd0RdqjHOfNuuDv/ +8jg+3myjpHTWV6iswY00AqEqzlRMSyYshWrE/QpzE0WrQ2Muy4KTFjuin6AinsfjKI42QUbXeiK6 +yA4e2B2BHNrjmdIy5Exa992Kc54zVVgNlnFo4yKoCEVmz9ba5qASCTmyp5qLNsYFf7ftCNhP+xY5 +V4/xQ4RLWAclVj4HJxL/FsrHX9LZvCq66b8mSY8oqiUTiNVkvSZME5WRO41vrPhoafO08KnUE8jY +Jg2fDlp/D6h3MjIwVPda9ayvquLNtNn3jhm/AYxKJx8yWXXgUfALnxuPtuCn+eVQoypIlJyjsdGm +ioal7H7HgJSrxjearw5yiUxXv+C+qnHBy3EavYt1Zhxr0cd+xHNBsl64zl4xNY3vEpasv/+MKEVd +1s/veXRxfw8GGkxxhc76L6svFJAR1Fox/gOhslqyre9/92dhLbnWxxhILMtwMHdpNqByjiXk7wHk +JM+1+fpbVRSOSyAEDKElBNOvfYf3YzdtqdypK2slubeLOYJy6qk4Ix3PyN6EDj6y2vlIUx6xM33n +WP5YaNTWvoVsjPdwI4Kez3Fl6/tW7HWCVKdFEUnvNKA2dS87QOIi7vUcjE1nUj7XaJxbzc/B8vaC +3LNXfnlRWkl1O5bsIludf/j7c+z0oIKfvOJr8JkRS30U1Xn4DjeWdV0WJ8JhmETvTy0dx38Y8BXE +9RRezPfBB+ETEUxDkW4eONBSvwfuY3zL8j0PzPj3IGwemgVNz65fj2469djvdu15B3fmIfcskYra +t4xqexfA8dccTgpj8zd4I8AH118Ptfv6wx16SGh1IjsCLXumB/nrMgq20+ewAtmN6Ekq/EzDe4ou +4Ol5kS6ALqlop0LfLnnNO5ciVYbBxLt2pK/ojWmQXIPOJGovDTt9AOJqOdv1ovHS7tOAjrCNtMDv +5kZf9jwAFFysBNKHcO1EvGnZfMnvvCbouDM/q/BEFLnLMEpXyAuJ2v0kFU0whAzVveqURPjSX7al +CFga3aGdrBktb7uNsH3uwxsjClm7B1KOranXbk2DmvvxODcYSRQsZknXSTO7C5RUz1chWf7QAcwJ +wKp1XUprq5keaPsjsjKLV4TldEzElbS0pDth8X0ga57F87++TL8JMMRH7GmhaWKXmL7OZQNJ0Vfp +u0iGDIpejXZ0OplR5dv3VOqp3S78E6ceZpwvandcCDgS7EKaTm7ogQ0jLp9JTHbKy05tGBwapbOk +Uc7lRMHfdQ8E3k3N+ZkIFh7ONDWjrMmLiRhCTavFARb8Z7xejkSx6NNYowQVwKcaViDoZ85Ul9/l +9ukGKztVOO1Nf9Nii5yeM9ifk1pgzXdROr5fcie1ZimgUxpeVK6WXf0WYD5K2kP7zHYd72YKY5cA +wyJyf05Ju7yLAeGWLggX/OE5D5ClRSG8j9NULuZLKvc9nmbnINbNIxP354XSMrOttYXif7OxBFwQ +feVrvjQTytiUPClMpkF1HbGk5p4rde78+cl6tfCO8e9gZDqUxno08m+7NNaKfh8ecV+idKag0qNZ +elsNdU0jaApTR7fVxFIy8gWAu+WHXLhC7q/oM4IO4fv92d2wxsNc0RDi7ifzxAhdN3bcZGAEdRQS +puu50hBXcU34jIge9Pq6D38ehBGOkiQacbITL+jIOj0szZ3BhoMGspa4f1Ghvc7LMtQU+CHCeUJJ +Q9o0+/a6u/44DqoEV0T4p5JzVLt2ZJGyyVZ2xgT3A7bkzE21Em39gZzQk1259DrdL/ZNLrQe3bR0 +jHBjQVHtz+4FcrGKQGlYWgGhz/58RqTaAILigjK5U2BNDL5FcU+v3HW2rUM7DPQmwDg+ALM/I/6M +NH2frj/FNOVWut4XGFbEYnXvUTRvYGeuOcWt8/d+uveukcuOwyL7K/p3nxH+oqVbBz00lNd+iCoT +9ydNV64hhtIWu4qp4Gl+iqBlpL8ZdfuvHd/3KOEbrAZMifi6UrGmaTl8IMtxtAaqzaaFGgApBepL +A+G18RnwPm+TN2Q/b7X0+4fD3IrY4wuqB5wL36PU2oXKVY9zKNPygP4+giQJMIAk43qtSUdmIqIu +F+LrYAuKVs05Dq/4joAUbkQsfffax4akJCObROhE99CJYrIrWnl8nYgKBUEzaLjrQMudOj0KKkkE +oCaZgCi2wcbPeQDoPZIIzy9KHlWi9pITARjnNWBhZ3pkTkG9ij0CKje4ru7Ji++730l/M41k34Cw +/vK+j7zvdX0G5LkDa4n0B2DHn6K414gtc6+XVwZhFt1hMWhoPwUsTRkfxHzKW9H4jPqGTyoYUV6Z +fZOdsEMnEVOAb7/WYlbm8xmRSwYEiMcNqZOn/nAcGhRwp7S/qfmi3RUFOXcqqR8RT7dDgkAwBZEz ++3yLUolT61RxB8Vv/FjjQXXiiaQ+ZQYk9Wmw7x+LEoCXA/eTz4D3VbV09fHpgfIFZYzL/xs8/uef +3QRVhfZZvd7K2/eoFc8VNZMRaOW8efpW3MrGUhgEnNuNP2kBa/swh0AkAMzzPSLXiSItUfg9ykn5 +fpyHwo8yYbOq/md2Nk52hs6LPsoHXfHa6mKMXCAA3wAdYxmUjTKb0RE3aN11ulpIRwEsiLllw4II +DASJqG4ShG9Q5gG+8fSvM92DXAyfrqMomfmf3UmNizOpLxF3FPTvU7qaXNM4SodSu48hrcUN9/tT +UCuWj3PmJSxcuBflArdftb6mbo3T8G36Iv18QcgBGbs0PZZk8n0g2YXwl6YcbPwqPz4+8t50hOUk +j9ExgjmEqQVUzc+IW04yD7sM7Ddv/XOUYgjU0NmtAY8Wpr9Tyw5AkbsyzoaqwIvGFqFg7qVhMuyV +SIjikEPRZbQ36b9OuranQ9Z6g4DmFvpnaCMicbvTWFRu96SZiPVkAESKA/AjGXjIjGnJtpc6bhR0 +vB01eDbgtqfOtLMZxBE4AcppO+JSLHtHWG0p+rG8N4Wrsb++6oZEUPbYEV9yUCTqw93JiB8st18v +6EJhG949kBSXjiYWRA8HUVelUG7/IQCsSrNtQQH/Nb3/HtVuLe1A/UJwqjZwllmostkvboqNT5G3 +PN0qvn//enrnCLtNiNoZ1BmevYXW24/fyb01iEI0QDCGn26FaFayJd0/PIXCnXJyJUwo3bizAJai +ODIPnmUTtI54XVhNr6wgYCiixZbyIfpNpLQtXxF4RQBifw74x7efA2eVYna86r4dZV8tAL68Dk21 +MjzUl4DICQzqh4gfF8HvUYpG2+Xbz9K+Eb8KlM4BbghnFT1l+jHZBNu1l7XSdT/DWGFgkK3Pmybo +je7WaXrQGk+de+8HXELQ25aBQwJGbxA1JZYF2HYtEujTejH4eyvhtFb3TgpQAVmVBjRSV+hXHjcD +6jEuFBO0XtIQQGrFNiKQyqIiz9eArcxrZganKPyWQP2Up0Dreu8P3HM+3c3Qo4X9nusf1gNx/rf6 +WVa6ELm/379NzR6A+RpsCezJtJ2BeQb6OwDrC+uZ+R6NU8WCAkKU7pXVulkbV1wwwsLDb3YvTgyw +Y9bW4oo9hlpzHg6dL/a9rHX7QtwIrACQR4gt1D90MG/+LbZMkt/pE6vm+4QsqUwwNA2WZEt31iWf +83gghU6R377MI8hNgb394pR5GFRCZMFwMCjNY89NdE9A1xYRFSOs2kdm6mRg9hZk3TL7oN51pBF9 +CWoAdcoasqCwKubtyICC3HtAwzoOZ+cVGfspBC9pscV1TDBpFevPI8NU7s4vNhKz5l1ARdmUFrHL +W5O8R06qWqf7NUfdLddOVS+ffBVOweXvjSlYpL1a3HLP4nTZKIv94e8jnlJI69YX9vMOwpsukDrh +HT+DuxZ8FJLVdKDxfKLbUkgKr0CeUIPD+vVBhyrVVDRMCk6OnWfdpnqOiy3kfvnwBHlm0aZTkAmZ +BzMFssAkGgWZOWZsVE8vOun0u0VJ7e3GF3hFWbxFHafb3+k2vwfChV0jUSKAYD4q5KpqlPqkEWgq +FsUFeZUb1aM7ZxLedYGMeb7OxCNIlIWXfJ/ix6eueQAYbv/t4kngZeuyHtUCqCJHnapckvn44ku1 +Ownqocg/MPv3JYXF3/BeWSJdaMPBD7ox5WIGkibTsLmK9wVFTa3dmpLDOY/GHAPb+UU+fqI01KGI +9XgcC4ToT8ArVGMHMfQdcdNq3A8RMIRqxdS5lK/C7GBf+t1qEdWQbsCB8JDp88jAJ+s9Z1qsdRd7 +vHL0x5YDVoAohWnzKw9fkFlBJvvrDpg90UjTa3RE+4b56rrCMdV79EZ2Zt+irwGMdfzNgIxPgfBr +UN4IVeBKcWl6A5GS4jydFiTcWQAzSoXcNDDZ6xWuKflG+wjw24JQAiw0QSdp5fHtKNZ0NHm4U6/6 +xgn9DGhBpOuj+yL+P6N6Dy8Q9Bca5xTQpRXCyMfXj1o5zf0Cs8i+Jb7BCLp9j8h9hRjKDPxYD/vh +OD4ft9O+oHTwxPFyRrd4zyI/REDtbfFxfnm1n1E4uDq5PNga7+NEUud6QnMr0kR5Q73aReVvOFK3 +t9wp844cwu97ctOJ2KljEw5629HgwWBu9TgBdyBHAzCBCLFFj9rmRnSeDkR55zlTjR7A3i6fpiNR +ZgATCCsrD99HPQfUosmEiBCJAkj2PKTUpokgdzeANYwA9ikwVvf8QCsSOtj9dSLLXTboVoiz2UxT +jqD9Unmde9QKWAighXaO88AppHAgWdFlu5oafETk7nzLeD6Pg9W2VMoKZOX2uyCdcNu4W/WHCJ+D +fp6DF6TzEcVWi0z6Rl0A8JvfeOUbP0e0Qor3TUViZ1y0lAAC0SVTuu97wD8eFJMdCw== + + + bE+d+T8OA9yFNZgFQ0FxifM+VwNsjggS2wh7MgVt9LN5IDiUwGYASdzB4veDp9kpijAWhSytKcvD +LyiyfgaoQtlUoVzPabV/BAE32J9FN5PaOxhtkjThPBRwsNt2R/Dgm4vcCEka8F2qvfO94zdIf9p6 +T7Q9iCLhxwq7geUquo2xBvHnlghflwKa5U4EVsI7AmdhIyLDuF9PKPHvmbK40usQtQeQmqmOKlJP ++xVYtRFAG8EdipblVWby8kxsSWHVKsVCxO2KWr/kGgvZj/n8vlLT1dn7pzJgRWGWJ8eiOGCQerBB +x2UWW4f+QwT59gTR2ck/51dj9E9R+3k5+l0F3f3m/CuHRFdeRH4RaVCjCgu4m6unMuTnwD+eJKsu +DXumVeCPqEfEXY/ImgJsmBWzML4DGrO/3Xn/FFW4GlU4Fnut0BHWICKwVQB3+0JdCrORw7K7m58R +X9NGh9WGSsT44TCoKdwxeLhIljEndq/It5a7iLHLfa5fz/V7HXYJ2rfQIAqdRgHgQSxMZp4RFCsR +Zsenm4gb8awdMfIUl7TiOMbOUo3QLmsVHZq+zuR8vE4XCkifGtlMiOV8YZxYADZhWhHQ38WiX5Rj +MoLEkIj93uUQi0eL4vgB4XBBcqKLYjKHWfH/3p9i5tkPDqUnMIpg1GZwvrTb0Q1GpPEzgkc0lwW/ +z7Nf+oxSvHL0iFdSyGD/Ra0I9f3nflVU76OiWsFUTARSvv/dRwpdvLI+xjBJobMIwhjtarpmWntB +NRSBDgT+7C9pugb+3w8yGvRjdYsYrCyFce0Q9hZx78jAtFR2KADa1yERLJUxhkdhqdlHYZoX/3LV +bC4GuSfMJipxMPFoO3wMuDG8Ajb6GBx0roUzisBWhLJSHfkaoNYvjHHpbBU48Nfgo28syHi3q6AG ++mEeCMLczwN1KOrXSBoyUF6g1KQeEyZCAJnDKY5gTDSOiK40CfbY/sRsimmJhCYRDY9zuOU94SJq +wTvA1FU+Nd3u7IEo3FP0q55nYFHoAJvvvR5db4FuduTEck8uRDgpZIPr3AvVLMeGI6rsk8bWHwcQ +g24v7O78ratkIIA1Ivkk8Kh7Db7J+vHP7sHRJZKE8G0QIxMqB/cSbQM3Eggs7JbsfwGx5bLCH0xh +RgP13j8H/21OtZfpzJs0/ZjwCrhbFsCsGittlb3wFvSU3wGEyqfTxt73zZPnfw0ijs36OePd9gsU +HXDhD51CFg/2BQ+baHgxPyoZsn8o01L4zjtgGnwcp9/BmNDDuERnU92wMDgbZaWPiI9FJGXI71H4 +JAucxny9JV/ppiUt4oZilrUi3wmZjc72nGQ21fGIIB+OKIDp4ATA0V5PPFlaU0vnlgeDM47v5xUs +9E1jrKY5h+Kqol8rO8tG+7i/sK3Vk8eY3LDY7dwRcbpbaNPIsWmIsY/A0EWVFajz0NobVcB/dxqS +JFhw0mnpKqRGYQD5dQSh9pelUrwPA2P2SmobkgA61ZA2Qdqrt7BPNtdHQAriVzbje70sgiq+H0Vr +ZG4DFX23jfWY695IdcwfIvZGgo4m+5PR327FR9QVPSFVYEnYUMa5bUlTNB+Kqt5cgX1GXHUCOqDa +vx/naxwRQzXqZ4vW/aN112uo3IB9DTXgRd3udLBpcw2pXo0xhJb5Cn8LzPWivuR4fjIdC8zDP1IM +S5TaeYL3Y+CqSv+UrcJ+mXlT/+lEifGY0GbBmzyvudVgkR6pcYMP4zhS8SiWym0b1m+MaGLm0Nqk ++vX04wQ/KP2eFBMKizgF5rFY1dBe1KoGOjbtATTgaA+gyW62C8weycluGW9JQgTqcJ3SCyalVfm/ +V4HWIHcv41IMhyCnrv1asgARAF2Cp/qxnspGiqr9Dmj8wqJPyTJiNngBM9Z02Wr94UTtsQD6tHrk +Cp1qbiVDcxw7bNxFHiu/ij/1xo2vHbGH/A7IEvt3sK6c4+Ps/UhmerBW2JvIBfGmKEBuv3rPgf04 +jYyG3rIaJECELl3Wl3yWs5IpIc3fUpMF10Bz8FFF+MmyIah/MX1VWsLwGjAGJF27In7/2EDcCRdU +/Iqx1d4DPYqdMCGTeOpwhOT10RsENIWx+GMug2YvVUzAc/2g1hDEmDH0EBiELXh/onubpi93Qrli +iipkVsDDXmZ/9OKYQGhPDaPICP04VIUeiI0DCjcjaGTHfM/+V80AaLsb+f031zEKUGmHwtVz9lj6 +IPJRY31iYWRH7M1UPRHL41w6bqD9BBCLtuJd47WmCypnejMYIZbYSwOxXCfZ1hwTaT5wo2GyLxvt +JDihJAFoI/8HILCXbbZLQwkeEJeaF768e/B6++QIVkO/mkNXP/vJjdZTByg2WFFntoezC8mNeQnQ +FaGJyI3bi3otT+ppIzd2Gizse1XsCrHifDN0TFnA1XoTuLUjSpqZci+QAqDkPyN6jL0Josf36/eF +p4r8C1imkSbuf4H+x3Zs5+O5Bfh+oVnMRoZrTfrp0+VejV00VXakjdtrsFFcER3EaUSYQLPH2gMR +Q40cwKYRFDKtdt7FCHA/RDwgOD0B6tH7BCrgfDX7xVqOtLOIkvk7ebiFw0JqeIxolMCJ0OgWOJN4 +g6L1UY4R4WMg+CCTF0aj/etMT54wlRe9Ek7h6irjtVBmKhZdTQqu1XV+082f4lBjxkAxiEbBAJH6 +iDVlRnvvdhf6jNAz3nfgxStp3Z71/4I56F4/qYwN1cmR2mMnxZfYEXj2gg6+9FCNgV8d2vONo4CK +3rxLFvVvzAGHJvM7u9qPiTaEVblB+fVdB+RBnoZMuUdBOKOCqdjHxyqMbbWwt/UbORzhprfMMV5z +P71vqza++Aft3Td3lv69CJUrMHYEMEi9eQeQCLqdLvupmzk7AnV4fCF21P6N1LkoadkGQf4ZGPtQ +5Wv/wN6V3bqnjqCRXCbqso534fPZjAIXQRTAWSdm3WlZX5GuM6Jxuyo2TQbgMEBA00iKE/lD9yHW +W4+AEkHOAdKWJkW+Dv0ETD8fDyM0YAdA1mTc8jEr/SWMi0cfpAc8rZ4j2I6iI36/xR8NOJlb1nlR +yLNmrseD/t9eDLFA3xHXsXUEn35+iNTEAfye2af2mG5PDNPeds6NZQI9wHrJQtf36VpN3ycLbooZ +VZY/UyJ3OqJmQR6B3CaLUV4ahW/wJ/trYVfytR1ox28zRZIutS/ZURcXOswu/Lj8ZM1G16+/nYe9 +md2Poh304pkw/lXGx0ES4iTWnSh/4YUeAx6RH0n9AE9Tdd+bqCq8l60c2clzuCEkUKRvUmeokdKD +0vPmekHtOwt/jmJgef1MrhVIHqUu0FsOUqh5wL0NPw3AFT7NCjBzHeFP6Cjg94loYr12PgQsTpNX +FKWeBYfw60TPfcRzbIpR3Tsfnv5Zk61HikGOipI0R907yCcRsKcfy7cvil3rU6WMa4TX2oGQg3ta +gXjfgDGGfLAVncMlMhFkWnGHttcUrv9sfR5BxpneEK44Z5s208tFfKFLjhlq/OzjIP95UmJ5o1z+ +6Ve5ZX+R/ewVgkxP4vJ++xCw/WTOJJO8QiQGldCvSKDxjBqF9FjRUuQpZoe1hKfTNAe+0A08EXvu +JIIXk4DwGOzfvnhmeAzNxPNGzI+oUaK1doMrVeLs9vsCwTPAzfkFaGnkNCJsFulSxNqUQNsT2VPf +zBhCN0/eUHYvUpkdRM2+4lRquLQ4O2BJVCNPUaJ5Qc2ZJfBvviJ//Tu+lWiKPC277AcEM/MbdcF/ +yiBAyAidQnTfSyLzsRWjeGPd8YLjU5D3EMFYkS+Ggmdvs72wknEqOXsQQ24Gm8UrUu6evqlOKnvg +2jtZTzM1LHhi0IbcYD2MCEpNYi3GgT7xSQQY2drcNS16ujQ3Wm7XsQEYmiaScx+JhzvwGvYPUR4h +ya1UNFs1r9EMCq1fRLrHL/ZDYPnICa/khKoQvhTUQh/VQepfe5CiIduvxwz4jooC3lNAU/gAyX+9 +dRjk730cFxzGKisGiiXM6chr7ZmMbwAVLVYcJVYcLOpo0heWbgYeHZFh7b18ywsc56gHCQRdja6/ +ZV4sRKo9KL4a1Ivn1z1DEbVSpncGTJPTjoAMoKO1EEdKQyLyBDlZ8KSUTr1x5wB/EdS+5y2Ih3ug +vBe6wqs7PZiZDd8+FFhDa3fHyXFPQWVZQU9zYedrgwxmHydMdsj5PU2eDhh159IwmGIJhGo4lkDX +u9cvCPdDoCUJJXGg0cH7S0YGClTECJMwBoqxTnmVs7TBDdIFRwigKTsByOYrfsBgpd+VH9AemML9 +RDVXfuBHi+V7ZwkF7j3z+VTrDM7/ieh0F9SODNCtY3+y4FL5XWooqaQ0o76Ijp1Q0najg1W9K2Bc +mls9ACgex479UnV0nW0oV49c7QQAs0ADEIkpt6OXsg8dQP3XibwGq8dpyh0jswY7RvxajHhqNaKf +n0QK4xegvYN+cju+NiyssMLG20i53APzLfb6zg4HVR362jRHuIU8KMKkV7vAc/p0Wjpxd395X+lY ++VFlvoEYrPcHFDVfbaNOCul8jcf6BM3O0QKNsOEtd4SnaAZcg+T8xFoQsHtqs738PqyMKDoPwN/o +PCDWw1OrQAPeE5dOkP34NC3E+h+wNWmQ3OtYQU8sXvKSzTBwY52MpMXEIG3A9AUQFofePSNw2rRq +gLFaJmExzUqhrJOiDc8rLdLAwdK9jCTNfZIgTk3yoeLfHQPr2NXbtfhCUSJZFW9ayh3gLlCwecpv +4RdlgVA232/9L3o1mIF1GjRWRtk0rueFLqKM5SwOnHzP4sFTPdksdW3/0Icf8M8GX27YIu+Qs1ki +2SS/05ItvyfKYmmrDbGCfaYMBU8NhbGHf9PIwhDjbMEorIJZ5G8kQl5+9fPRC6E9BZCiSYAu/eiX +6TyBm8Yrm3+/kEukIFHTuzGBn790GRRtVf1q/+LC+/fMubtqKSGrpup7U+3K6s4OcrRoaEbclJ2P +4IxkqQuNbPUn9qtAjW3g6jIPIXuVELKPUBCDXTvuJQJRJVT6VoCYJEWoSkZ3WZUnngdA+2dASUwS +4MPo7+wS6xn0S/DENw9n19PzqGDaVV9h26kwa8y/Jb/Xs5vc9+kyHadsu7+LarBFJxxc76JmvSxX +okgceVeMLVCB0PvA/iIEuFI/JTzRZZaeTFuMfiO+76SYqMYCL8FAZ/1W0Bg1irI9X5/cXNkNn3sH +blVVwThlQNn8NY84rH2b5z0arbcMDlRs2cs86nHg/pfv8HjV0Q1fDqi5wYCy2ihwfqlEwH6R5Jsk +HOrWfkQW6H6+HN9eXVJhtxM0rOi/RobDMkal9zfWswXHTqeekpZ6zpC50OJlnUTlBB9MCqtNkWhK +8SCpr3snJ6z7FUE5gFnMmAp0/ObFAMk7UgGIlKQHIjMSRj9dEnAqt5R1eBIy5KZkrn2VbpR4xUAN +hFbA6Q+6wTggC5a7oygU/HpNRUwPlXlk5mvAJ2H337CTDqlQExdkV+cB2xXRAhjORQ== + + + gwOiDyq/V39L9tQyhyAhKELVe5A2zCzAmIPkZXZDo3OgaI6I7v7/92+mpe3jF4EZUu6DzVraHEUq ++VLQY+h6iTg83w5IPU/+oB4kvn8FjYHg/nNqqdN9JwDNEYk26j/7ReWEt8hOPq2bHxK2D6CCrtE4 +FVCh9h34V94AtBGVlrPAO5CnqDgNREcW9PoEoNtpySr2Av1Bw+BH+aj5HsWpXjQ9cJb91Ewy95tX +2S3rChCGjTmbFfARBRIJpZ3A/LnP53DkLbN+DgKmeOo5HBiTJxIsDsyRDbQrNzWE6yhUa5TJmwTs +p/hSzsZr7uHucGG7hjQUavf93l8gr5gGCewzQU6f11xZkyv1CmvvcAXYve9HqUjOvZV1wUoayRXq +JQP99gdH0uN8ex+lDy8nKw6XEyIUak7qcQK5ZteC0u9+RmBaCpkGhi93ZPV3SmX2YH5m7PGRWNFF +QMpGT9vX3/xZWqztKUQgBGSg8htF8JRUSbA1552ENr4sJYd9eyvEw6u7/LUgtZW8eZyeKdYdIvHD +gaVrziNLAk4HGuR1RM/Qta1HHyM6E2ANFefD+omiF6JiJFb7I03RYyrD/fcmRRLszj3ZlSPp5ywJ +5UmI/CHlgMSdghNL0jE9q/ftu8kB7vDiOy2dvatrb8MCtQ0eT61ftGwpiGDunRmsNE24TwGT+jAy +Fv05ipdsYQ4ZtB8lGl6LW9G6/V9Xd/Mv5rPKCClzUtBQpf7Kbx+Rc0GgCaU1ZERd8/pfhLs3ATcF +0Yai/QwD1jdAgMgKbciferhCzUA1finNAgfae7jrPnotvLR0oem08hsfPQ4YUAqnMV/TFvrL/R7t +yvmfd9/TazQyfU5cZ9nCKBwJ6D1z26Vkpnv5pr6siifMsqmpLdbN0Ikj4I7fEoqRcGpMW55jStCd +5n814VARIrq8XnCEzurebNEUVykke0lb9imhrO7dyMzh1MfFeXX5pfAoWNF+N29qe1I8zwSDYehW +lXIZ7PSaAEtTWGAg9hmwJKQzpwbggCshYiCn2GHP4oxZNG1IXXPrcZqNr0GkOwBcPvl79c8tpgIk +8s/XseRP87YChsPjh38DoWuxQBgW6/l+dCpY+yFxgQWSGM7e/O2vXAGQkYip38NWYRx/Aw1rkC2W +Mx0W642uLujs2q/21W76i4V95pPjYXMfUTJ4FstpMiS4p0W8skU62FqfLMR979FSY81XY3Y5l8Z8 +CiwY3MHk1Lz/R/Y8hfyGNWKNW1VsrHa+Mw8zqPP+AB+jC9HUZ2V/JGIq4Cdyz5aSH8s8m7pMFlBx +s9F5VMHJXDSSdrBAuk9Cm4d6Cy03KUOXUOpA+4Gliedo2cjKy5h0VsnDa48BNt547ej4kxbZD6Kf +LFBN0uajjRPzvHjQ7rwv5txvYCEcOQoh3e7me3bzuocjUCxcAHXA6xDf5pHjHa8w6sS8qFkyCPuv +6zSJZqhmcjfGE/vK/ZdTMRCxvdiAqa8aSSJYQkXFPzr8ovLbnnGugLfVP8X6jy6I1FWLq/RnoxMc +/CCmYGcX/XMU0zRR5S7nOO8A3ikMfJ2A4kuB7NBOBAKUvu799wnoSuyoeTBbN5kDz4mKgOUAGnBC +Ar9ghJqbN6K0+QYHIzz3rYlOI1JRRpT5dZ6J9MF+ylJ1RUfszmEoPsnJNNdFBwyxByIa2KqFRJ7S +g0j3+4uaRlPqPlIMRfcR+Zu/npS20/raUy7AuKgPkxKgPmzJrorAlLyhn57wnEeQ36WNJPm7kjIU +vfZ+UngzhFn24rW/K3PVRbMZBXmAqMB0wWrQLqySL2FvtE7tgQippCzFhdz9ZgHLCb6IDTTGJeLe +NR8JPMITC4HXebynlYqKBKlNSeO+io0vM/DwFBBrX6+RUFFVlm3BUgbMglK0O2nf8KK267TngFnc +7RMfyebodvvkfmJ8Cix7H1ixwPNNUAA9+sxqjLbD0Np3bAriv5ORwwtu7Ob377NTSCWovDU0TXm4 +YlfMv4AHSp1cQPvh3O2NiXyJAWVNN1dWpXb8bC+aLStyBQOxcdLCgToktfkd/xrXAgXsgGcGJWmt +jZ9M7EyubD8/YVf7OB2czE12QVtHOSiUWIGgt9RfkD3DHnm/WYdnhByUKq8nRdREmTn8BpLSI5MS +7NaOcCIf9UzLCK1eUS1KxxirTbYtox55ewQxXz1lBKzsQ3WyyJyJPpS3ratthAU90KbeeqihFdWO +W4dOvqLJsX/VWhn9nbdtjpmNwjIDCe34y0ICAxZ5kwPZxVJzZPmiMu1GLpXUljdFAXwa+GtfTLZl +fajrCAvtK/UiKtR9fK75sT1WPwqVg18uehUjaISXVALS9WFz4TNwK33qANeMATLV9/huL4Q50HNc +XrA8OWn24azUc2IBl3CRewKQ2uDRajlCe99nwdXoiqCiy0y8n2WyTCCvNJaAvFbSQbT20yuqQzFi +yP+KDMy9ItRjbf12L0zTwApiGiUi/2LTCDlnv/ZwIeuKotWk/SywbwYIc+9kGiiUJJZMUDT+il+N +whcwewEhmZDKSzhCOIgS5Hprk2AicyYBNXPBW1yyHXdqSD1jpSSiECtiG4PfVs0QpvtuFNtOvlL6 +CDBu6hlftNPMvhQBXH7TsOQzMdJuItZ3hoDoEklZReK1+AKgQbCPpilAv4J9uKXnvkIzLYgRpvVL +Mls/byhFbeaTUQIBotUtTqGfZt29U0txx30F7DErYGqdkFeKrwWPvPOTaniRSFdI8Rz1WDTzrAP6 +aC+gFD/x59SNdWZcVWEphBcWekrs+cDNwLz7Wi7436JNO2aFI2bK3mVa8jO6Dbf16Nfe+qaA+i8c +N9zPPfuQH74nyMqy52YyAGl/M7Q/Vbf5FO2X/U62ax1iYFKusNSJEPSH6LE1nfyheoxSXrFIfW2L +/as6koSiXHInr0LVskeCYVK1ZCLp68jKT5UQXF3yXZgjhldb/419tdcXr7odkcI5oKf71JuLIpf4 +5AcpwDMtZsQ3I0dpQHiHLyZmvahyPAK9cQwqLiUVuut5yJ4AucfD5W1OjLZ10Dmz2U4KoqlnC3OQ +5SwzZqWXzUexADhWr719LYYqpuykdT+/z9mLU6GhmQokA5NhOl8IJjBfyRUL+ZjCpaztk2k/CGVB +fHyEenZlxr9yqYFs5ATkuaJ+YHOTTnZ7MoGopjldsmaqNibsiAOEKN21Sm5H0OBWfuj3on6nrOlk +jwm0oqCYtfitejgAe3K6VBan/wOGacAkbnm5qSrcYmRf/XaigOMQVZ2Or3ODmVVq1ATroCM/cOlL +hAhAWtF15kzNJRO4/siZDsZ+fm2IUBUU0KyH9UzQLaF4dnVlpR4gEsdS5jyD3WD1MGo2GuGXHbcG +gkQk37inteGcaUG3IMpSz573bIYLPoDIrq7XJcaGZ7RHq1GwIAV9OizClwU4XULMd8S7mQQYdmo5 +QREBsmQpnvHARShY9NGzIpBKNtgBoesTW+MIgcrLJca1HpRyWwj3hQs+glfaOdUBFulBCtS2oQya +xXqh9MCFogwP2BUA20N6htcHQhaCaGmgViGnj05lEjEAu+472F6Lj8tqCOJWqr+QpbFxIUsbU2CU +5mB6+7Y6cpRsJgEAAhTFfw09G6zhk5bcYfMB02xf/hI0B8Q5WiN1UyquTwI7oOfrxV1Dp6jZHzMz +WpFZK/pTEw33PoUbhKs8dI7Dg/D5gkUvtWkniKdulFVVbio4VSVBTcyFEqwc5wloCl+3XLvuPvzR +OM0IbLKR8enjPVM/6pJ4Co+caWcvVXw/ViFGsKLTV2W3Q4QKM4CVKJd4JrWqcEFLwHXROdoTVx1v ++aQEu9TZX6Jj0CDMVftAlCrUS7utqQMhjzNyCi2Aa/sTwaahUlvcCMkazG6pCbw28uU+oF+QhuVY +RN/ag0NlJhtSFFLMGrTk6d0W1coVdet4S4VT0mlFTOObodLXmYRjMRdL8pnW5SgiACX9Veydk6YC +kJbaARsNAGjPNmdo7FrkfCDfCMOZGeEAa++DlAbhJzUcWBnNaoRrDw9BSF6HybfCkUSsjAhmAIVb +nd/6UgoiRM8bZ/r9CvBovxDeygQBZfFROIWLxjR44Y0ZUVR3g6ibDLndz8u4XrdYOjiFPRZJFkkW +ktTvXUFGS8gtympM+WArRZGIJO7eXVf0jpNGi9dGDJJ2/ONb2s77BxvQLes8MJLu/H2mg+co1e7V +bPSDXRX30rGf590pR1R4gvmL2xF/BwUk7BwMXs+O1XQAzdvxJTj2xJGD7qQ+WDa2lx93Qwmt7e6x +PXKa2REQYo3IiVecZo2QOrdgSZWvEwin0ZWgxNjoOnKy9H061OWWv+Mvy6fBIRhAC6HLSchXBDlN +QPnS+gWBVMSw7lwfXhONg7ZEaCBrclCubBdZB0coS8EF8Xb42A2UCIbKhUIguIIvAwBwFjgbxK8R +t2CQeZQHYqddj9OtDCLE2Kq/JHAX8ObuX0EZ22q6SZG9yCxg74R/HT1tcbI9RFEdlGhP9tsnJbUw +OlUAvdhroCe9f5pLI6USm4tsfK0a7cfosJkTlCHZXDxhe3X7t/8mhBJ1aaGUqx6sZvRtlNAgZsPo +6U1SmZHjSIn3sYyo9R3uyQ7ma9IFwHdce8aDUYA5YE2gW5CKCALQVEUQqHjV3pJRNFY6plT0n1B7 +Qf/JO9lOf7vRcOS7sM/iXtMkf07VAHJBRUSpI7nEmnTdRyQX0cM7Lwxs/g58D2+o68oiwU20PPn0 +o6xKgT86xu6y0Aq7v8R4exyEQKKiF0E7GOdlNYV6Ci7ZKHcMZSI6ai1zrzQYNZgwuukb1EV4N34U +8oBBygZjBwnnoTSPvQ4KH7Ix9jXj29vrW/rQyoV43OuBt9QcQfF5SjYHFgv1Fb4/un+duoS9oeuy +N7TYV0N9XVbV9EBM7T+WyQcW+u/O9lcK0GyqXtlwCL65glwIeF7cgLyGA/awDwLZw4BxVHL2q4Yk +X9PuRBDOtV6/ckpt6sHPPhUm7GrTIcvYsTimDt8j9tR0BW3yOzoiEA1rbYQlJmJMjcwawwBYKodL +xCJpR+RwH/YY0lDaMqarHSMn7Ke1s9Fm4zl2wDHOKaUfVPgUcRkj8urgfspLWogFRXM81+05+TTP +X/8i/OjviXH67/5FV9F/5YH+hl1n/iv+95NxpgwaxBdh0OB8Q+XFZj1mWvtV/6cT5MQIgIJ69vcg +6THC0OGnqmQzLTA44Oq+B2bqOtkEQVF9t3Gag1xyDWPuWC0m7iwHFXveHjwNAd6O5p7BN9yM6NH8 ++VHX22bTgGtXg7AQff2gPvuy0BcWUCpmgq5oRrHuE4XqpMdpXVDNnknvADWmyIoy3Vh7CFm1cNZG +FBPRk6CAUL64rCW9BtAeVZnxO4shFTYd58jYLN7u61CP6KNw9Ycq38xPmtmrKsxqgMZMGGSeVRe1 +YuuRVxKl6IEiznu7l96vLHvpPaVDrtlHELC8877BEdgfP+I59qW8juoluZ9bRVYWiw== + + + A8UWO1B/HY5ZiVoyoXIJXvhu3QH5Wi7/fvchpsQCHovpi357PTTWSoUMmne/9EnSVUWn+2a9TQFY +n06KQVcJIGjpozOYAEJgG1nNqH6p93yc16FZtK+FKAm+zIc7URhU02SQTFm6vHcH1IsfmQyIUHMA +Jv2t4wyGFCrTi5D+OkEI64VSfE6QX7KfWJWIiWiwM2Hkx70+aI7hFjtfJYtljy9WP7MPYOwvqVv8 +UOGOVvhuy459JjVWaoiH9TnrDA1EVpDa5TBXDRGwtsauBcLJ9whPIGfiyYu35g9R1cIn5M696qxz +02Jv0iAirh8iWH4LuInO+nzO9Bk1XLTp+CppWMeFcdHcS6pSdnTZB8x+RWJJT3YK3bRqykB+AIUw +sIk3kjX3Hz5Vor0A6GOsGPSwE6V+jCmIac9+ZvloTPM003izWwahsO/BrhEG1gdBikw5oEawiyDC +GQiE0oA03GKxS4Sbsx0Bgt2IADZbhInfM1nb21FPPV9jFKD1bQoFq3SkKZo1eYNx/dgpn8dhQjGC +iq0nIOHVqfkFHLDkXjGrClAJ1DWfaqfc2Kx9x10JaOgPA/0AOOJqfl6C71HzUVMXyGkBRlVZ0JkM +sQBFc/pi/wxrGlvF/b6QPfWp1w0R7US8qBc4JM/nWMU586HJW3QyEVNIP42knaN/jv/0QH5EPfSu +eANx6YFzizcbfdidmCg3/uh06gOJBAMvzfDlfpYDfz3PObvE/dMuS7+uBOIC6YmQ2KNZDxdzpzV1 +iGhrqWOh9HgfzIBRe79F1BXMYztYKTpKPIBETB5RfENWaqbICDPAnp2B1GKo5r4vzNAX1+NmTYCz +i0SbCwem7FZZux/HpScRYgcxGGMapetzn4GmthHP1dm2QRwmkW5oHtwuJzapHtnSeXEG+08cgeqT +RTke9nuXQNMaHnNUAa4K6/0zIpWgQ35lJiw/HocNnkUppMsp6SGjat2bxjDkFoAdtzxfM4ckLBg/ +k7D0V3FP6J8k2vakibTTHdjAwGogNRFhb39nTDVltBm1YDKmQkb/txKv/2q2+a+0nj8sVqANFtu1 +GopNRdBOENjaSfYKuym4T9cD2sQ9QrYaXUSTQIqD6QDGNJJ3F3VHS9GfUwQtJUQb3HEzdDVDa7Ee +qpggZuQrdxRo/UjZTxXXZ9OJUw15nH2vJolQOXyS9YKKC/BFzqReqzCvnEn18h0hbuU9U+A0aHWh +YE7UFRy1IirkcnAAHQCHWdLLjt5rtAdxkjsR2DjsiNXPuimIBZwA7utISrGroHFM27YqFHzHsZTu +jMB4nBIklqIad5hg2oAic9v1mItIim5PMLjcKlJDoHiOVDnGA2IctZXZayRq6Goes/o5g7AC6nit +mR0b5Eftvlt+T6NX2WIzB6H0sir1CnG2bJrhFup5AEnkUgQjLi3XWWo5jL+ZJC9+MEhDFCPkZCj1 +3fUrxK7qHL/bLHdQ1lFX8Mx/0z7ewU0JW3CumOXudGsiB2GEJIACh/DFlh3btQW2zod7aKjJ0+rm +mjUIGRye+lsqbqUuQsTfei/++vd8F4H/s9sE/o9cDkCbqJ/VnQrtTMi3sAK5hge/nygsPokCQEbU +0GyH4/BusFFBOyYgoxaQkaYzQEoVzEV44wnoJ0Alp/rfkJ4CO2IiCFAPDEmMGGQGnK0A/ShVSTnl +KEdG06hiZRSVYbc7E3redY6Bdgdnur7apitIL+uz45G+qmxvWrK/CtQkNFl4+21iPKfvQzEX53ec +lcNnQygDwMH3iGyKxml+tqrQ3EcUe5wuIR5jY9ROwKlRIF/Sr6MPc2jr++9YWNM2sOpEVXa8Rc8R +vrgszBKmqnJe1CWfHpMXZ4Z+xImJcHXfEXgkGhExDATJWqQ8lN0jov/RGOaKqctNnVjBD6UdML2+ +cpxsp/Y9YeH2OFAQdsSiB2wEtERaIfQR/Lbs2NiCltcihL5Xmk1oLELZfUU9yHJm1wDkUsIGG8R9 +7fpB2u0JePS0vZQJkbWogX2NIPOinXX9XkVpsrOKUt8WRxdIVn90g0cYoJ86+o1J1kJVo/5xABx3 +V7ISqtU57hlcYTwpACdpBilFMUpFv17k44TpABoE6umanO7JfjPtaXyL+MfT01DnAT+Wev8QpeSB +oM0nCaL/DuAwjNubCem93O8gBCybApO95rmKeMGwTxopqIdtucqekqv5jHq2sInI9CBFmq2gsVpe +OTiitD/Zqa0CwXBvyLsRqAM3ZEQaYA2fZSO0jlgUIDT6OfAumblWwG8lGoi46tfbgLpbN2qKroUD +OozSlMbjCOTaEU09aiJmHhmxbB17vfnSRxFqBRV1uBfVNYMHj8xxxRXd8gy2dl3HxXm6fSuTu9cc +fWKuOWW9z4hDvrut177eQp9R10HvMEueiz8oTcNEW4qR9QOPUd0inlyqsw8m+vszIHPVMQMd+xaJ +c/w4DGAGK06DotS02UfV83MA5CxeFSBnXymsH6IASdE2WTFlU9wBmwDqUavnfbP/uSZGEFFIlCQy +DhEaPdEIdw0qwAeyuc8k9gYwuhiD53pvP0zCEvjFEJZAA+uHB4QS+yl6NY11tbav9prY/Txfvvf6 +X9yvrOn+MMVcQFdFSFXBICiaq1EqVcsNbE5NgW8/NV18NwxjF1YEZk+DFNCVhXQbbzMTzRIETJb0 +CDbVnGdSBFNEFo07FW7ijyJOFT+m/dR021X+eIwIAJa/kKWRphlgVsCxBF0iqOAI1MBdg7HCnxJ4 +FhEwnYjQ2A1whCC/kZfVExUld+uXHZPAJpp4AJuQSjIKMWO+Tpk5k6W0yerRQpa2/XUDQAPG6DG4 +IG6zphHQiIgYZb2mBDcgJY5zYRgcOT2aNgvZb1OXeRDKg5LvDIK6RCQRaMGvv50k/T23R/0V5dj7 +dgF4cK74ORKOkX+7XcKOtoMc1/0Hntw7gg22kyt3YxzfbP7cfG6Z6I4ZE8BNdbjM0UsGYbe5Q18R +7FPgHfUHNgFDw4EVAaaaTyDy+B5O1wcx3hwWmEC7XzS4mO/BezcsVBzUN8YLqESs9UVvYvGPBvdN +YhFyP79YvZ+dbj1Fpb1XJeOKfsq+ViTUMkWe2HjTOi+mmDvRQ5YOG/uXyH+D6HQNhyP1hPHYxVXY +ZMXYOLMiyFbeEQd9wSn+X7KW70xiMxBB5pV+BoR83TN1/z3QXiAdg3IF45tDvlB4WfzUOBh/sjZW +Vko7fDkFyxlIK3zP5idBws5L8xAZSR2iwt74qu4BL7ibENjnZPOkCOA7ME8CYDZzCk8OigkGMiNU +n+WooQA9ml4LFBNQiBFEcv5pp0xK+1cE+KxbRA40KjoFFy4lyDWUKgQNqkXVPkCeulQWXSDTsglq +FEwItMwnnYVWj44PZae90lP4LAdo86cBvtGXO9L3wXkdxe6O1pDIZ6CFZ2AeO5jDDz9/YtUJRJ8f +8sjGDKWAzI67ggQKYjl3RGf624th4ClfghS3JRgG6Wk4SCsHQEHcgVDbfFWyi7LWbHR/iLhrGib7 +7v7RzefPQUqeryN5jm7D/QqNYzWMEVLRk4D8QAXYb38/t3Ytp+k/j+nQ3ALIAb2CLtDOqMMgZklc +89B0WM5/k2jtpyiYrNo3VQl8odp5znEwVWWNdKY6QH/Bv4sdwOLxbK8QY5f8hYB6C7IFwArfzVab +A1I+gilhII8Mh/N1VtNvfbV7Z8tbQ+HrnuEUi0vAbWM97IVCGX9dG/404F2mY34AT6L0GCTfe1jv +mYCQXriQ2d03EK3R3wNPoJuiJI4dzdegovhtRBR/SHBbmTLGWbIAm+33h3KD7PHvA/5G1PDbD59C +Bf/sFHSTZqahSvr1d/apwEqveXbR78i0WwHWH+695+9HmjoI0r20okH4QO7s9XPgfXarbb2GOsIP +H6eypRQgYgXxmVKgZs/lYLg/xkmmAyZBJfZ3dewJ627H9OjUR1Bm785vtmZAKSM7ZJ6gXityaGiG +0hXm5quG8THgNVkAQH4YjPrZc9bVfmVd3bv52YIKAAym4PnerrBHyPzTok0gUmx/XcqbIXrRbWPn +0QvPmDr1gCQieT4ief7uhmxTlHyqmZVDjFl+ikZfxHjMPDseofxdojh/j2NHB5+dgy1q2yN6wF45 +gJBNRZYOBoxNurkL4E1mz3HnkctAzUA/e+9xfAA/BqnAmgxAB1XI+LYY/nsAXxgAfHrLnfLn70EE +R5FpENwxhHiytF87KSQxQa0LMVHQqqj5azp0Gl984Uh3tWOVQs8RoMYdlQcGRtfJpGKR4cBDclgU +CWDagy9/v4dTcoVBio9oNlUPcye3UMyJDvXCRJmKyv3+inY2lbTNTjl0QMfXjaUgDMQNwCWKBY1c +qyvdhK3trY283NgzUNkGgm6/oUXncL8H7wDR2LRQGrVbsj/9ocQ/KPw+P0j0v4+HeaSDKtvtwZ1l +wUwmL+NLuK+YQGN2TrDY0N/j6IR5eZaslL9mjpFd781WRQ2abdw7YpIC+9bC0TLPIPXIF/g+8I9v +4wHyDzuYR7Hab1Gw/cIrxDFNUfQV/jLiDRU75Y+In6btz6gJVqHKUe8YoZV65MyF5IYyNwFTMgnC +4dYWpcQWRZB7PzxId8Oz/MEZtB1n0EfqDiq78IBv+xKt6kOx79rSY6yjqFVloFwD6ggcH3bAc8Ut +8q7sr9/953WMR7E4NRUi50Sj62GrHJdsE+TvA//lbI+zoQ9i74eP6xmNz8XS9TQygyafO3+ScgPY +CsG3vVVXSk06ZOfZoh76GiO0+BQaVN4gNqcWTe9zGBE39DLWiViJGP090ToRJHFGAEYmojxfFgx6 +PSP1IXD6jkRJSqvhW9CNI6BpdXi/loqLXDEBFpMm2NIcQhEwuJxf5M3IWMuTg2y6/y3uDqlZryT+ +IhK+S3CaFD00aoBHn1qRxG+Pdr86obDo7+N5iOag1oYthUzZsnLEpRCc2tyNN2ZMxGlNUNEQ+D9f +DhZFpz9UJKNHDaF3Rl+fphpR8Pw9DiVBqSjaEnicJ1af1Y7lc/AnT4RBiRh/OIGZE1xKS5ETaxTN +9fYULfbohwitSiDT01PyBKxvnOD1GhALhjjEW6zCbrYDYrhmkKdypDXGWL5nzG9Dk3ZpfGPPxfLj +2cWed/Nu59neVyjiZXB8oFOIjqhSXaybIhb7Kq21akpJR6P/FAEdmeft1tH8q3YXvWeiwF3XU1oD +ZtwOOSfAuHHLyMTNNZgszEZ6aMdmYBRnsBECJBtHQfvoh0k170OD6vmiD+BhmmPzCO9DtdHmgmyD +hRu6o/j3CVUJ8B7wekV8upg37EIRTzgk0552xwADf8WcuF5AR/Zs6Xs6e8wGsYoBWUVEEeN07T0l +N4Wkqp2PCtLi1pwCAYPqKiAtXrQg5msgkrG/Rln5uJUuVbfXNCKiVAhU8wpzDB4y5cmBle2IyE3B +8rpe0dwRqiig41u1n+t4Gt+WaoXrdiT+Bav3ABdIw4AVT4zooXfKW8ZWyeIu7TeaLw== + + + D0CPl3xgsxie/1417vFGDaNYawYqFnCldkY8a6yOfdMRhnwkibbgDSZiQfDI+CY8tQ9go/L7PK4C +dNWkz6FqT2+TE6gDsE/Qan4IojJElBx+aEO3v6DsiOsF/C0I/L+dRMTlI6fdJOE9UbVA06qvyCJr +9KIHDp27OETQ4iIxdjzAaKZXChLROtp/oy32ygx/PwrkO2SYaAy1c4NdFDv1F6m4MQzfWyate/L3 +QJDb0VhopFX96zMonQhgpi67xqGb1nCSFUn/iGglmRvf7VVE/IzCX0EYJEIozPztTjcNXAjypGDG +I6HS9VCJpRE9aiyNlAE0Yibiy/kU51qfkr11UAfy4zijhWvDUyIzrxxxl73BB7n1GfBnN9mvh+iP +MUr/W1sBSJbuK/MSPQGIICGZsdcDISZf+WDguOTC9avOar/vh1a0DbBBdzAi5FiieDXai05HMzoR +yuaAZzvErBdvx99MYRBpmvMMchP34dCg8VOYJ/gldG4v9B1S4Re44Av8RJtKKeIdsXPU8vV9XWkm +2rbLH+vGF4jLkpVMe9LbAqojFqxM7JDyEBuy2ZCSeiF57p8Rue4nU/v4+LxCi6fYvqSd9ZS1kFcB +I/IZ4X0dua9v//4jqKD0edklYwd5vmfP95xHGk0nUPwhNECfcQ3+v5l70yc7jmtP7LsjQHTffau6 +VXffb61Zlb3vDTQaC7GQICUKgkhIgkSQehT1FHreYiL8/Gm+2I7wFzvC/+r8TmaerIvuBjUTdsw4 +1AKB01lZWZknz75QiIWNCwhTU5eFGGckbo/SASCqGwSVjtX4oEMuEp1RRM1WdNIqKWOJ6hpMGSMm +lCU38SMUjRBq82Su2qtSGFFuQkJU/9CYNAdx20Z5e0SU6jYEFHVto7HVKLJR0CiSjwIKCpXKMaxK +wahKK7qko2o9pCJiVAUnwmCSb0iGUCpMqDqVqxg/U64JvD3mnrKm7xUJGnmo6+/pZvRSlx2hEVmo +54nSUBfio/hU9QsK7cUvdBmwTBcRVrXTkmJ+xUSFyhZWec8kLEo6WsUPAt2mQlANr1jX5aP4YBqR +Ul1TGkEdAGhErGpgUiFA8sBRr4AgLy6zUOoNVdRSjDZS2eOEMcSJVISMikmlqm5kS+VfZKHqzqdJ +qIGR2i8p+JsIjbqhqVGCYtUz3ItVqXSqeRBmuvcpPaLSnqlCNIk1N0do1JemmQU1hqF6kbfmoXhx +EtyJ3+Qq8Es1Tr/jF2RPU+JIHkWF5/TGmBs1VENVbJakL+pkIHS0sQmMFVRKVol35NsjdCAv9q0B +lkSoVsTYFaqmcnsaqv+iit5Qy7pAh9DqGKhcR6NQZIyqQg1JieJNzK5TCT8VScxlcIhvCzWKvPl6 +FJVPpSZuwkTYqJitVBWdVr9QHZTUC5SoEoSqPx+NIIWXRtj6QDSIIgBU8d1QDyILi1T5qIFep851 +CkKhiqepdnuJipQja5AaoeJBtZqjl0ImcJpD2t7XpLirN1ESpzpZuTLd1SgKm/qlkL5PxV8pJvf2 +L7LQfLmw4e96kOpSiEFU15JM2vQUZYSomCrlStItKhJVeS8AMwuM41oVGaUelrG4PUKjlKkEd+tx +iv6gaBlwRkmGC4o+1hX81HWOVc6vLkoQkWObisbqcPlI53xq1YdOk/LQIopC1MH5OgQb4pVQelpg +euEQa5Q6OF9nKiQkKOYqakEZQFJqCZTqwHwVREO5PbnpqUrzKPEopethiv2p0hRS9S9QQQ9RHOh2 +H9SdlarURZRzpnKLKWGfMkMzYQZkegAO3gYh6dCWTJVIvGOa0NRpoaBhUvB1+GGuwgIzcpXcMYKT +5qgKaMBhwzdHUWKAULWMVWKOSttUSanUqojC1zPdjk8qw4jKv8UXSb1TkUoxIVqbcSRJRJ4cCsui +Kvu6nrMOk6RIbh0dpHpXJ6opoClOqAI2yfUp9PxUJVaNIJuUypXQWS6UOBPaF+kmMuTSF6Ynogog +hTZE4ThqKbGpKC1UFg3VNE5vp3urPBuqdheoljP8AtLHVEgcrmSg6zfrGtyqHWWm83e1RUYFBOh6 +1wrPyYoRiLtGUEVaVSAamB7zm26OIuxSoygRSHW0MTGsZLLIVW3J2FTWjqm2VqYiivQI0g6T9PYI +bXDItZRH2eFU4+jWKAoK05UzyLhMGUC5ar1Nd4ragWWqv4/JflMtbdS+6BNOqNMMJ91nJg5Hx3Tp +UVFuRkFKvzbrkbrBZ0aqWKzcfBHlCQllviRTj8LBQLkiKMUhM4YiBacSTWSSDIBridiwD9EvE8qg +x0OhqguRq4oFOtw9oTKYWLmqlxgp/qviI0lcUxH3tgBcovOLYm0qValwxNxTFb8d6iwvSF7UnMeM +kHoE8bFbHFTNeWsU9ZJRUjIlTqjidIlupyNUH7FIxzTrpt/UNIDqQ0ojrQPbRJiZitapqWjNTWID +U3aHmgvlKno6VyEuitGB1qlyybnudZSrUrpUVRjCL9npVOEuVe5Z1c8UqvqFcaGrHmCJ9nNRroVQ +UgSV7Sbxl/rXU7AcpbjSLJSsSy0kKU4oIY+OyqKhulHYktxUW1JhoYmqa0yuIEpylaoA1M1fmPgL +bSG48Tt1noEuw0tFBsmOr4xi9hcq4VfFhFAEmj4R+8tUMc2MqhJRnQhovLlKv6RSYar+GjW6VlFa +VNZNx1zihFQaQ06mtlMdXpNGpot3otpEUQXwVFUG1BUGcXJUtfaTcTj/Xwb7qMzbT2bf/hdOFlCX +2HQzoVb95TtyyXiTqff6y0+/LPTWJz/++L03OX747O3PP7/76Yc3D//65vHb9z+8Of3xL/948+Pv +35x/9/7ny59+/Ntf9EvvfuL5u7+8e/vzu+/e4BUfLU7+0xUE3vr5u7cfTUiv/PGnN2fvP7x59u6n +b9/98PObR+/+oedNvPXDH36+YzT95+3vvn+nF37947fFM2SgNL1TdUTep9748j2e//L9dz//UT+Y +fuplz35696/v3/0d7/r+r5/cl43PwJrev/vrxoo+Ofr63e9/foPtv/jpxx9+/meDX/74l5tjoQf9 +4tc9ePf+D3/8+T/z857/+Pe/3nmc5/eGxw/jN+c/fGeepH+n9O83T3784RmQ9mfg7XKpwSfv/oBV +bvzi3pO/0G9y/ZuTn/721z/yPJNXP/zw9sO77zwxvRd4x/j/67/fU1nlfyv+c3bvoxTywLvCX/4E +0N+9xHvs/eqbwPuOnnx+b5mo4jye+c8HACjJJdR6uoJdfwwLlAU4UmB+9i6YefaHYlVP75FeC4GU +Yn0p8h8KSkA9NKkzJfVjCkjND1RvNMqoFSQmg9BTxT3qmCpJwiOfP9YSqzKkgXLk5PQQ5UyLnGwe +KWUAmaZDPCBWmfX6O8jYRKEGQVZ8rqqzFOnAvszTQJ27QAKVCk36eBPATXQVVA1OVG0rNZZqwJkJ +pAoMI3JP2SG33n567/fqcdW0QcEpLjGPzLIAVgWraDhtjzkIMtBJoUcnlDx1ffck12b2dKV2yPwi +SMzsFP4UhBqsFH4NJJuVBgbQTjz9wjwOzMwqkuvUrIOiBM06SP7j5YFRSL1q5T2/Nq8LLJgMOOZ1 +mWoboOoUUQX0O9fL26SqLZvNp/Iq5kNIjIsNmDxyngaq7ApzImlmgNAoUjOBVClDBpzq76OgbmAK +A3MGJsA5A6Q2gBoYxfb5UPknNBRfbIAykgwU/PyNLyg+7eOJP5iTy5VBXQ/nDyu+loJzf3FdH0MZ +IaipRGbgyvfC+5ir2DQCQ16LzMGpPjbmHpCQ5ukpIqrQroFxbGChSjwlWERNyE7N2yjV0wzlM6Ya +kLxlpPd4d67r1C44JXlS3yQSbT4YcEwomuj8npwXTOa2xNwyqlxm5k4obFYDA3Oct+YtjkM1SlEr +kVTs4p+8kDyBfNFjnjuiJEsFTCnrxXxhFpsbrZJQeIug2xn6Q0XXeSzFnpnPsAh0Y2HFijP7OorQ +tWdqZDZF2QK+BqqptH4dhc6YkZKXlubpxt1Q+cAEpgp6jNtZaFCCymx5d67g1NKfUPIlJyeSpT+k +dhGYgsayzNKJLMl5NNlcGZynkaFW5DYzlAJMJtJAYXbo1tt4GXLjQqpuHh8MOAoZTBWDPA0M8tRs +cx6aGy0pLd7gFXW4MDuUm8BVNTa29A56QCIMhmekiJk1kAFS30jKp7xzYcWKb7yQV5zoZh50plTh +9ZpHq1xoi8wGmPAUqofCJz7E3rOU954qGVskkmbVhMqZtGivwsQ0nQ5iC70xh6E6UaCvgaYDhGof +DFiHcKqsISY6VFomCM2mpllcgG/MwZOrhgFmPIh1aCanUgR8XcjH6WmgasenhBbVV8lMkOfxhiRz +aibIDGOPddcIDaSoI7Nkg/5RRF4xpojUYZQnkFHOKyBd2swaipApJbb2zk8wpxJFG79QSPPBgGNV +bVYjbibNKqJYGqAqUvULS4tMC0BN2DP+DDIwmgkys2O3VnBqzzQIc0Yv6jfOZxqovjCbxJaAUrN1 +kjy0aBGRjMSvUzWlT80Eqp+HmTeQ9vjDsKC/+k7RvCILGZjG3p0LK1as8kGMCJYUWPiJF1J4jgGT +4KeBuFJMxKkllQFS2IYGqmweHiolDw14KHWhuTXpjXUVRIApPq1MRpYIkDtpgxWZrw5YYFRf/Ymt +4LGJWYXCGTsrryK1ROvGCnhpFBQpzMz0cR8MVOWbakGPMhkNjTPfLLRYrUdmAZMKqlBvCSqFrpix +mZGbKeyUpVtKxvfuWsC3ds8o2NDA4zgpCGfMK4NgFVrCydhNzRVy3gloEeY80zRmSk2hMoYZxikL +wrded12cnUwMX1eVzj98arwZrRpEqQRgacX9W5MUNE+1DddkPM6EpXnSAFV1RUMAYsZuPmt103NW +eoS0RIGFuJScdEzvVJNNnQOdMxEUOa82lllq6R05j3lWzYUiqjfOV1RJ4Hcuv7iiUlqETUVsvyuw +JxIKJqRBFN+8XwDGvGFhHmR2ZZD1WBRiohtsbC6VNvXuXACvTNXR5yko3uEDgwO+IJERyaPkI+0v +zxmYR+YbyHRmlkbg2yMzXgNVRbXANGTObx++sagCP0TKdEpFn/M+6qYJGrMlbyTVSDFjifkYoP0u +SoSwG5lECQsa1NfEHHHKuxvLf4IiVCiE38XML7OUi5yHd66/YIjSCkxK4mKGaDqgqfApc8AUfsLf +EAQRM7nMyHyka7K+RGDJUp/UV54mFbFh1RnViLtzAad2ywPVpEFNTMqxRV0rRAepVkYJSH0qNTDJ +LO6KJGNgXGwZxWiYlZGqzUArhcviRny8gn+6tNDqAqGVhaI4S/lSyPSXkSEKEuYYucWmMORPY3vK +L1zL1IJJ2+e9SfiuB0n6y59G1Ub1BaKWLTK21zI3OmZGJRdic4WokrUGRonWI1Tzu4hHZiHTQsq6 +CM1Y2hANo2hyw4eyKP4n19qSgJRJ1iZQkKdKA4Xg6yepChlPkBp9U1gVMFLhXrkGJg== + + + IU8apolZFdUDts+LRBgLDcWimrHAQGM+Ur3+NDAzchjVBEyKL0hlzBOEZgKqABcbxS1MtLkkMiYu +BcxFXhCnG2dwzWDqp6nA9laluludAlKjUe/Os+VDJzMTo4iyJXwwYF0ZVuu2qeGtkaoGZNmSeSHV +IQ2smGpuIKUcBUZMJYdwcZYGz+myhRGfZcosLIxzC7xNpClpyJJHipW+vvsjri2JU15o8xlxaklc +nvL4TBhtglLMWH5hgUuRKGGxJClk/lSFbiqDm7GVURPZPDKKXEBRxBpIRRBZ7Mgi+yGhlRpkoR9E +ActhbACjT4ik/bYoL1aQZ9bmIllA4VupkmN51rsFFEpcuMHGKTjA0os0ZLXnU1TeLjbI+WNZ3SSY +5A8Q0g6UsthCIe201m7xETgMAmGnsKpCEN4FTNJiXhFZQmgXJlJLnmUg7XllVj6RWTGBZbehIRb0 +rk21hD/Wvoj6Nxb7wrNaUSjauCIU0e7dRs6w2BjV8NpQ/cjurO5Xqo5LRv9kBQaWZMXyC1NelvyT +/SvGUswSA9P4jlO542A/SToi+wWxZBocZExOFG7feWc37DhGrqCCa2mhBjBTz1ZsoSaYYFgkYgvU +FyFTK2CtIzQ8I6PaYlbPypk2U2Ez7873FwuLzU5S24dE2oXFhsOQvTLhmVlTz6wgFXLKugImfEfJ +9mUMRqpwm/2KiGn+hm5596dRQIkZarAuVO03zKRBntpPy5kZUoH6Ym9iay2kQ7GanpFcVfp1aKYo +NMsokWwALKyQFKVp5xVGGiT/Qs4TUKq0WUNqLYg3tnZTDmOeToIyi2EUDGuYMllMrg04Nu4mw8At +WGZmNHU2s2Aqd2sWYrxQUbiheadCWPnqo0VsKDg5a38U13RLwSGBQGSWixfESamV13dPwkxNXXZr +g2f/DYFj9iVQdR0zjcoxMoyYCg5Z8I1JzOyCshcVDae6VyHb7IU0yb8EpsBxPQ1VQEhTA1alLwxQ ++wMImGqB7fa8ZrOox5zGcvpFwjxat55Tn0+9C3NhXphbAUJqw7cBRrw4drfdnte8kPIUEmveSdng +osrSs4OGird4GlioKJG+QQQT1oxHfYBPzfN5HlmGKMwOqWktTwwkT5sKq06R7HPnusyCU9Xl1tAM +SrrWC05VWwJDuZStVQNTydQwp9q9BpixYJ6z6YqgxhJA0mPCQxMjt1GotpAGGMuCxOb2+SSLzLKo +VhK/ytitadUhT3rjA4ovY5cocCZmZKNyksYxIikkJ9dbSV3DjHhCAUCaQlAEb64NcNLS79vzmhdm +VFeWMSWxHikqM6AtYAArAf3agGMRWbD6FsBSbfALA+38vHNa876Y8kSsNGBNHdTwN2ZPOdX98TRQ +BGzQVC1/NBCEn4EBqyQ0gbTSseEC9DJr7GD58fYKinvHjqN0w5FDMWtWdU6MhK4SaEMzljJ1GWjX +q1SwU57XmlSFESB0OBdbS7RgeXsBvGnJhpMxCFJzQWMqimQV10TfJALGbAQMspCBkQysuMLKByU5 +RSwzM5mI4w3LhHIF/uKuSyNbJjqt3sxq5EVFQYR35yfob6M4TdATQwZD6hPygcFJbumo8mgpYKbC +2QiYK4OhAmqplYDCOBgVWBMqRZ/tUMFDjdh3xwJ4ZdJ6kMicatR/dQMzdu5mPLMkM3vIQHWeqnFO +LI3gSpUlzcqkvbVWU9fdeayqox1qd6zAGKJ1d3jmYezAi6iaGvuPlIvSDDUQsvHe9fDpnVMyc83I +xGAkIVWu+wODjV2OSIXRQIissoU9Y/sMkc2YHaeFEYPCrDnaJGPbsaKbRmOkrHDvzhWYXYjJYi8M +aVb7+4HBWRhvgBnIsqpFysIJbYCnPEFsJzC2JwWUPDYzBObWCk7tARWCfBhaK0K+oeWalUXUj8qS +Prbm5Nb1bzzhfEiRNWoFRh3N7XXbnPPG64t1hTZQhHqh2HUF5jTJxGkxJwgyJgSsoVAHWRYKZBpG +9jRlwkSDsgXsWJYLqA6Ud+cKiqWlNjBGJhxORBUyCnIUx7w9ccZhHqr17C/uWazyy/RYu0EccUGz +huKXL0Zmh1KKilmVDV4BIefnb3yBQdQ8t+5iQ+I/GHBsgijIqa9Vn1zliEoDNN9LwChnYGi0EWpv +ZWwxRhMzQGNFkxo571wAi36qdr2RC4T1iShwkDJYIxoBDbJLylIWDEwlT6Abv/HYLGRwYCcwoVoA +am8NwUx0B8HYh3x7XYYcUaSzsfBRNLs0wjF17TE6NjnjJM/N6iIJ4Kn85RfKXOMq9X2URrO7/Tpa +h4o7nP1NSURUpS1nlkLi3QcDNvonwCkRk2sDpp4NnophDA19y8ikFhpOxUZ4mldLmCra8fTudxGQ +YrFTE1IZCy2REzDImHsGHDKVqZYGZlXKqH5twFnAHDDKNMoQUCfyhqoeGwOpo4sBJmx7U0XKIsOX +pdSCt+rCEJiN5oVBRGJjEClKiSEfShdKBR93zjIWWwaoPJb29t+lNRnRyWI9VdqxylGBspmOUhIU +xa7lOXKMRlb00pnrBOSrTxqT0SCp2vKGyvUJTSyIcovz2sdJBRpMMCNVQddOLZFpPqbZvv2GzFoR +NjaMYuEzfj7UUXL0fM4jqe25nYCD56R2eVwbsMoGNddAkxn1Mj4dxZX5ZamZlzpJ2Hlj7VcmrE0k +TxCbyAapozQJSGUZA4PKykGjJyAbCuMd4e21gRonAE2ba8OiEKbIn0IlwmECUmfXyFwGqu1oplWl +baWZIBa8hCxhdYQKJdtZQz5IKsfK6wrDKGRUCBPzMsUBNVAGvAI2olIrNpHbFRivNL2M2ltrYCwZ +SD0RDNB4npQJIC4+QWk7hfKktybZ+Ig00HI1Ac0uBNoap4GpSM1qc4sJiY0HJKMAP26cUXQIqWYs +whxKnrG1lTJLteOODiDTEZSCCluo+Wj1mdlpyhIOEn6JKCYwhhQV6WwuHSX9hQaNWZYQkY1aI2Jg +7wH1XArN9VIMQ49VYYbmqLRWSxNoWYJ2JA6knUAX6TMknvEttAZ6qe+fAZpALGllPQImrEIXTieq +epPxWGGiAmhsxJjBTk1RxIdJ7ZjlCYCRqWEyqcEMuhK84Rz1peqZ8vWMdNqlBjMtSIR2UaTShtHS +ojS+EzBgoLRut5TCBJlwKRzVQGpqY04h0VIa5QWb91PLYjbAftoOkZq4LMXiEzMFx0/lbCm6y+6h +wZmVw1NjEiKThWQXH1NOMm4YwYRiWxnfyR5j0ItizoWx6VHRNONlIDNnyFNQGW89Bbs+PmnQiY1W +R2G+Ka+LY7cyjmShOTM2LMfEXfh5aNXWIBSaoaykZdola+Y0GgclO2eiMChZJyUzfAIaRy8J6II3 +9m6DFjMPmlbTaLWvkTkXyqpjoKXmSmrkCfLQSqgy4gmyODCzykjyFwij2aiyfMUXCGNopgn4XdQ2 +nsXWmHeQDdXEu1QPUQMWIuXbZU1yqSaaqjUtP58Y3xVJyFIWJ2jkfHPnLWJIFi9V7LgGiw3Zmdp5 +GnBqndhyFRjrvC5NZbZGFbAgYMLcS1kQM0MSATYmMjoHHhmHfOKpYRIEjFg0UaTTPm6czLkN+aZm +49b2p2QADRRGuaLvEryLqXW8qBhfM9RwKcXRdHwEgIngfclDFgBoAQlPq3yj1wzO2KiYmZgw+oaU +15UaSx412wwZmAcisvNG9sOUUEZAcpdJswlK/NLAILUjOUgkja1nX2p/nwaqUu96AWHIk6Ym90Ol +KGbFBBlb6zmKlootmNBao25rIMf45QWfpWLZlvBRdrIZKgIG5mnIk4qEv0qFqvEEscm5yYstDKlL +Js8qzNGE+gWG9HKOCfVCDRNmP4KjpVUqLktysdHHqUSSYEFQURkN5Ggo6pZsNoagiTB7QEnk/HzK +WmFi9FVVd8neMG1qWCp9KskEm4KoTd21Aac2Ikb1ydPAMGElK4o0lfm0YsnWJGnNRgmpbCmjl5Gc +k8yG4EmV5MLPF5iYSH5/ZCkq2+1pYMQnwww0ybRtTq9Ual6ZEJEUG8q5hkXG9EEv5xDUJLMhoYXQ +TGMTq3oaRpeobmYG3wpNKyEfKY9VJdfN2JilvSTTSEQj40zwPbQTCJ0Ioj+L7vq1AadGNsqtaENj +hSUbkRaPE2FzSswB8LyRsThJtmcnqqsyn1Wqo+8ATALW1EVidya1XiGpRXx2FsnAXubCLyRDZss5 +bxiRGMlAwRJTQoHwqeF2xo5MQKr5yseoCWpCAToR+01idvkmsQ00yAm3EjM2jBMjbwhtskuIQkQc +ihxxhA4VXZc2GFl7LQlMrUc1UMnA12Zs4VAPjChGdbNiS/qEFvCoaZ6lyCkJ5LzYyN5QFUCogYlg +uZc6yPKsIVN6aUOOk4iT91iBM7Na9T4xVI4KaGnxjICEHDxBnIYGXMjeBJbZDfE9CXUEtAFqdz4B +TWgYIQKziiTijD4lJcd2WtUKxzA27VqhXcyYtXKYAfX/jCOWsKxqm5BCy2Td2AZ1xThGBKMAEjBl +2VsV+OXnY2HtTkzPAoooYCk5M4augEq/RLfQK7QXelPkwGhzdZSvViuASWBdO8Rt9IfFdND24iUs +ucXSRv5RGIHW2WPJBs4wsNsVWzOLsqiwSSYmvGK6zgGNNGvERvs840nZFEp1xaxvSdpMvCIFM85t +mFimbewaGKfstk1skGKc6+AqfXMNH49Jv+DrzGYLmtVuQSw4qILAEauB6pKZl5nkIrKE6sMlYMGx +s6yYQAVHap4dJ3ZsxnJTYpA2Vg2TGGkFe8AJbMJYcuskiUnryJkDRZrUxoqQmWWpCBKeILETKMZp +gIGVqSNNEKh9ZFrIJxwTHWdsXwhyjgWi9ispx0Ny2H1cpN5lOpGCXSGhDTfhXJ5YWD9nxumjd3lC +CKzKm5rnMyNyxOSLEuarApNzFyfWNZKrC84eyuIuRwbjKbzSfJGhJLEqB8NilNUrldeS5W5FjDRQ +iJzZLXt3YovEdL6xfZ5TA3Kb0UU+TxOORhzUrkmETLWUYZcnSE08TG5NGXEhteY2gzcuggpzLbDp +CSJrC8m0Rd0s1mS+FmpdHFtSmGuTkd2CLDaHbVIZyQMeWtnMBHbEkY7P1/dVsjmIGlennKPNSUXU +3UMyq5Ox/YKgCFcKLSFSNm0eK3TkGJXcjAIOaUu0KYY6Edp0QGUH1/4X0hhsOnhuvNzBhhbN2lcc +2FRwuiIysitgTyPFCtuX5TETncBkudGyRMb8N5fFJ2Q2o1SFYV/zlxntPKMo3NRMwcJcZi3ZcWiN +rZm2wPLehgG/jtNdIxUrZCZIjVMnytlvEKj65dYzRTWQWeQJ2DOlNEe9gMxE4uY2NWzDvEGzBixu +qNbF1wbMCfxEPST7tgLrxd1ww7FSJFRpKZ420EEiKuZbsGeXkyNVMDED2WujstrZY0dHGhvfMnUz +NOvKbKC/sPcmyqzor2zPiQGq3G8zUhXJ0eBI8gSxcShEgp0fRbQk9a83ViZBFYM4wg== + + + V5BMJVjCkxw1R42XOW9FGjEZwMCGokY02VLFmBkHDgV4CHbLRKku+ZAoP2lq8qDSjQ1Th6OB0rA/ +UzuCJ2DjSWo93rS5NjYjyzXpVV/LOTKZzaWnrU3YR5pL683fSD/nxMrM5i6oJuChnSALOcU+59yd +bCMKnUqJGeCnHMi5jQoLA0ZbRoS0SIilG8CZaCoNv8C6kCOSIztU2HxRQ//v8o3zWA7HVSUBP0bl +VBuYDbDILIk52V7Na1OijTFCAW2yvZFF1RcIniBhUZC2wOYlqdBODcwzjhiIk5DvTZ5woFGSbtCD +IinbZlXkVOyN62ME1n2dFynWNq1D6lhyBbWZQ7llIKlWu8zzkrPxVMwzT8A570Kbva8ZnHDwkKpO +Ych6xLl7Nl5fbiS8BFaYVT1TI0aOSCSWAHO+eaKzUzQwKeprGPoXBxbtCT2tfAYKHnMYQWayN4iC +53ZhRuGLVWCrDVq03DXcyJtQT10zWHDEtzr1a8PMheV6qkqDYeYR30g+tE/Ha6U2/zmKtD2bpKmA +70OcapMGyV2xTbiNLcehJJGA96HgZKk1yyfay60lujjg+gOcukcVeE1IJpEqNrNSm3QT60w12nUg +IgnwNuVbxCHL3ywoJVp8ZlFb2XgMVYiN2hiT3F3EpViNh63iFPCSM1CVcDP0lu1rpB1lnNmtMg5Y +veJUqzxnnY3zr5SBQhqlz8T4EpBkTdbZWEVNrb+cFER7jnEUsjIbB4zPRfpTQn4rDinZUFs5TJC6 +mmoaTNYHmxOZRBw8RbYK+7UclKoayHElnDS28bqhZU5JyCkRieq2zV8W6qwIAsYcxKbkp+VHdpW0 +iKRXQznzl4Vo9S5mWbGJPyOgzapQI61dJivSWCNeANtl0sIQeEcUsBkrbEIyG5cSGzKQWqWTgLFd +gZVsaQKbJ0l9JMzY1N7zhA0ClLBl8+1sPvmn45tzyUjD7o2kSDdLtRvWAG3Qq0oiYVMYG5cI6SO2 +pRVBg7EJY05UnJNgMmy3hsbaPPDMPF6EF3KRhITiXzkJB9y3MMUlEWejc049gKygUjZDzIZH1mTS +jWSwRGgVSL8s1PJMktnqS0U2PIChTU9IRV5YOYtaKyaTN8lsTpywvjgaaIQkoVVZfj7OOI9BFSLW +QBHkRakAtpKy7ZYom7Veq/4vvF0sGJNN24qrEDpjC84i/ogo1/lJVPI8FVzwSmjRhYzXKTPoVLKp +JZFW0BI2UZsimmzWvjX7SRtBJTaK6RA4EVZJY8FU1ftkMZa/mPpNRrwNmZEyVHlztuEkAQdYpDa2 +iPArTdm9Ic19pM2N2cET2XBmYXOn0tiWeBAGE9PE1p6yaXLp5k0qIvfSxNrACWXUyFQHeugdNCmF +aWIdNkRL7MtTq3ybykMayCdrenAtld+vCKRWFP+U3YFJkZCuL22qyrZy+DjvH1m++FVKCuQJYiun +sfiYkqmdpaHYOP6Edd8aifBb87ywGSwyj3ix7FlJ2N2QFpWXiFYlhfczSDi/JjfCIzmgbei6KPzf +rE8LXbCGJzDoE4aFB1/IjLmU9WnzplIwMGMP8X9OG2I9UJX75tJKYWqdv+xmJrmReQRNkPC9sC5W +ZY20gdI23oFjsukGWfe1ip/mxaZaFqRC4dKWAREcA8FCstjwtghyCnJSdmz8kwAyOxHWMCoC6xqj +kezAB1gETIgUo7824MKqYyN5Qsu+xcoogRRxkvK7qGZuEYhiq+mlNlVURBvpW4Hx8wolorIybcrx +USNam5atNNlTM0Fmr3bGxWoodieOOS3G1PqiboU2QY4TIEWykRNmEgL1WOZzgmoJ2hgnjlbLrMJF +MU6W4nANCAqSsmpcZK1zgu4UIzJndorEZiQU3FckOsApMfqDtBMIQ6MTLRuZCSzzYpqnegrxpc+D +sFiBEMxVE2MfpJaMob20HOqU2nIRyUY+oRDWwJgUqSFiIw2EEzBEEfWhmkxxRFFmg5NTnS2ogUX6 +uIpP1MDUpE0TcjCJoE5nBeswqeYi1zG3er+M103IDWavgpP0BHJDM8qDjUwYBip7LAPvSI+RG+IG +Zy1kFODK5qYg0kY/aiBkyxYk1I5VTUBRrRFHlHMSShZt1A2IjI2TgLbsUmZ96Fm8YejIbYIugW1O +mnL7MjjPWfDkXE3Vc50xTCb6llE3OcPqxMqmM1PTdOsZj/RtyhLrlSBpQetPBExtSnzOWjrVj89u +FnqgmvE2SYk3nDrq2mzVwuxIhcdDtsiqACLO7eKaUsI6RakYvq1MyNFtWW49nXTkTOwIbHWVLA3t +WKup8HXKKPo+2eTMeoIi3UVwUjm1zrWZCZEJU8lDG+IhKKPXLCCnuD/mF4ng+NecOuRwtQphSBXG +ypBtr+zozKmeUGQoXWqrpNBYYxchK6b2pVFJ+pilPhPZRG3pIjZVq0oT9vmU2YgqqHJtwHlQcD1t +esxjCiLmZBdTM5SAAdPlIniEmkEHtr6CUYRVA3TWoVJjxMkzK7OpVpCGj+TZRqXVItF2IwVB6Mpe +DE6EfZ3hnDmFIXABChPTT/24QxbS1Jmf8rQR4yjXjMzJ3cWoaDMgMsnXRinC+nFpI10LFYbWVNgo +g5yzJbj6a6o6HfHzLE2QbsjGqVwlCbDSS6LJtRld1KrR1upcWnVJ6KR0Dcxivs1ByIFFqs+GLVZr +uG5OEbqs73GFJBppaZLS2u0EAZsjObxLKl+wrXCkTTLUiqOYNQyKCXJb1UbZLq4NmCPEhM6pZLAM +pRWgdJi5DCk/kgmQtK+T1t2rLoMSVTE2CdmgwMkhsohSELb8hlR1Zix7Y6VRFgYBweUQZJEqLHRQ +CAFJBmDyFdvQVKlUaFZhUh5K/VGMiGEMj5L2M+faAtHG8xyQlyoZlmDCMhFl94oNUORM0RKrNUvl +UrA1dcwGZJsKuollo9ZOttRPaosbSNXFml8Wa2mExsrAcm2tw1B9/Nxipn44t9EFqtiAGkYBzWwR +x7tpRVEQ2MjgVFd3pOcV2NaoMJl7BMyspBvoYrpqZMZOlIhLAlEWZVGKLTYaKEEzez3VXhmgFdYT +HQFLLUhUQQe9AClzM220YX0ycSMELBQLU51NjbTFZiIOvdTFjG3xDV1l2AjTTJAjk2xJMRW2qliY +8wpyK8KrYP/MjM3tpTU5zzpI4I50z3xDXjB+GDU2YcU41NdFAUN7BdgHrINjcltH0PBrna3Kekyc +6WRYnUHE9k7tGqbsiEKPio3DhIZmKTvJotxEDuoUD7F5PZYmkp+dkkamVUATobcRcqAjR60jX4eu +6EhfznMwmphxtXM8C9sWlVM75HA2apNsxnJuvjSBAMr/HhVpMCZwREcKcKpAoMmsjiHhxZr6Qjp8 +ITexHKo0jp4g01xLv4tMixqZjRBlRhtMEJZOSy7zq+tNcARRHicWFRlpTJjKtQGnsY2q1PmFukgq +pxqkuhyYrnNtQ+fY3KeKxUbs+TcZG0olijhOUujyZzoNk0NqlKORJ+AUS3LKmJdFGyEVuj6zajFk +3AdS11q3l1TyYu3eFrqk1IKlBlInKv5WUUwQ2XSFjOy+1wYcSBvXQwHMTFTykCOTksBsWLgSNuPF ++IIUUH8YhTZFG6nh7MOkDJ9UmLHGYKcSzlObcH4zN5yJXWrAKraOKSvvuJQ5U9DMZuyFYW6f55Rd +qenPtSHCzK6KrEvqUCRt4pC2tygOYvc2ZqM+9RJMOXEmCtntpBiWNPiRG2sodbgpYjuNl4vauJva +XHK1yRmZ/lD8WGTEQZluBOhymIBMN+JIpSnrTRw74aQ/xUd4Xq6yKjUnMSxf2rBVY/Mh3h5y2kke +FhIDswy6T9oSJKk0HS+WVXKZ2ITuXHui9ASxFZGklj6vDVgYAYF8p5kRWthAlNuYQADDnAPFma4q +oSfjeE1TH4DaolH3S7MvOhNVqh5+TA8y9qVhqDHQqpwybZ+jXjnGkmjjFCVV6+EsQtWmiQU/1UJO +v98omNSWzSbAcVacDK3HiRbFMWM01jBCCjuJ+GV89XMtb5oVGIq2GVRJK5Acn6SscRrI8Z/sAs6l +NbVI7cWyom/KQZ0mgkbBGC0MF1aSb8x5IBt6hkrx47w0HR1FyoOdMw60LTMvai5IXS2Q9RSZ270y +VaZJpwgZaBir6reXciqNZAZE88Y2Rl3ZOK2mIXi3ONyV9Kec91WjVU4JOjbCTbA1mnS4lCMXRZSz ++hXa6H2V2Li8O9tbgwMbWau8BGbWgKPhmDiQXmiDUm24kdIWma9yOj+t38Z4g23zwXKkjtRl7nkB +ecTBxVxNj75AWprDiniunZJ6ZKD6UvEX2MSf0GiQKpmWQ5ZNRkCe2cqbUvcy4U9gA6VJsLs2YCji +m+kpWpHObVKBQcNc2MrScsOBk4uNWiNRwP6XnAItmX8Jk12SC+4JQwHSJkwkT5kjUV61rWmYC5ZP +CCwzHsveDk0M9cBIMi1WMYn6eVPJUB+u6f+Qp9qSrCVAEyxEvblEYoBKPWILg7C0KDXqR55y1QxF +oMyRq3gkmyjP+V+5LfSpEkcNeiVsb1MipJ3AeKRVyisbq/KYbUI69jznCYo6MCYLgjr32bzdzMbf +A2yEOdpDvvnUGJ0RlLtP5LHVIIhGRJGdILQBvxCz2W4AKik4RZcLfQG4QXszg4uRrVpryMGpmSCx +KSK5ZatkQ4qZUin9msFhVGw6twjJi1rGFD6uzzKk+E/mllLHyeUh96JR+cdBYZoKU75RnAVGBjMb +zcxBS3lgvWlyozhkXlSyL8KhyWjHiTcmzAWgsLhNCaeNUDNFmz2Um4zYnLoecZmeiGfk0pRSJ/fy +44Wgzbn8ecDyYVElSAG17PxRZjp9lQ5NIqzLYl5rYJGW/bEZEYzUAtnJqPpXpjyvFPwyE5ikCiro +4D/agdAWXwg4vDVT/ctZ4LFBmJm0apjJNzBji/QOE+qTqabHfBkKKy/R+KIunGYtmbRBbnRHcjbR +5laqt947guac3xEY1CKgYHrAZSBpVdEGPSuMwSLlM+TE9iznoIuN65xZ3Sw07Tk00Nh4KT094TyQ +LOOasqTVmkz0zPo5N1KoyZ4tmKKyS5GAVqDnljqZdf8q3DAmebKj2DoCOdcGylS8G9MuUwYos/1i +lFJtDosy80PeAVsygDwFlleoRFX2KpiSDjSFCaqnTrO2MggnIJD/IeEk0YyFJnJW2JR1zhGlSS3R +iI1RC8DE4qHSWHmC0Kaha5lP1SBhwqXMrBpoeKUqt8VOjYiyc63QarYlIrHcFkKQDLxRxIRK0YTe +mfGHscuFRIzAFMoRqqYw43Icck0HETHDYMGBqj+EnHoj06LOQ2rvWGIqQIsiyHcjm//WArgwn7CB +WLlG8w8GnJt0QrpFOXvzi1yMLLEO9pBFxbRIsCbJITPyG+dZ0qTCCvuJDTG4sQAuDqdkqc1Ayg8W +zAa12LQa2gibN8XWDdCGiMUbsZFJbCvcJhxgT+1dNYyL7t5+/6kqkaMONCpqmOoydw== + + + HxhqY0A4DVIB2dWkjtsAUxt9ZiVJAkt2jXG5H4oSjbjzCGeGRJIplgpRYrlERZ8y2AbeZ9btaotN +31z/BrLKYCPg17YpIaVGcCBz4UyUSjA0X8f1rZUCw8fBjtpb09IrZ694RylWIkitNp4LW/uSrepF +upYCcpagSqpf/lKqP4cUSutNV0Cbfp/YAgo3VrBRS9JWf4m5NJOCMjdX4XcGmHJBEWOb/jTFtrIe +O+kzGwNDQHPUd9WcvGtVppIUJXKFrCJAtzf1xmJiXCxem5KTpPLbhMDUZqJ9KukssRmJpjQ+TZCz +8ZJdxrffz4XQSOrnfnfCduaJxEbgvIr95+yDLLfebyPfEjDKOJyWS97fiCbi2H9y43AXp9z04YvE +RicpUzjp9rqKkvlsrMy0nmNL5occ4CGilCtcxza5RGSmGnlMQiQDbfs6Akfsjo3lRsn9JLNFOUyt +utjWqs1suuPtdRU7HNmWlkrS5x1mw7HS88xHc3690NUOljphQ7BfqohzIbCNzku4cUa64c3kLJAi +lPLjp2Pun8JpfSqNxIZLhSkDbyyfvyu1Ye5Cu1u4EDJnDwlrE6NcFBNLLgoanNqMIrpMNjlDEVkO +DeC6juQ/Yvd1wnXxbq2gqO6X22hb2yQkt4UOUlu/loCSA/izmPMNuORIolWaU/M8FwJJtAXNkGzb +H4AtiDdfXyAC13bN9OVgRAhTLoGugmL4qhWlytOkgN6Y47qoAWlRPcrC1FbO5OAak+7K2U1cYSqj +AB/OoBGhzco0+YOqSCbflshm4FMKjl0dB0+rNXDuWxjZrJqP13ValPr8eGJesKK7GmzTUiKbqR7F +OaelREUDj1QUC2NzVGYD22nShC9syHTgji+zJNGWr1fkjs+Jne90wbkcu8ofY7evKjFwffckzAki +W6nO1KX/YMBGZaQTCXmauDDlZtYUTOmbNv2Vs/Yo3yPgYheptafT6yQXnE9MibOYmlJwPqLyddy5 +MJb5QqvHmYoVHww4tEVwuEsfAU2rglx3VdBAk9JP5lxmlXFoiziYLOTru99WbBxnbptSQrxxsTVg +cvBDXPQ2krbaW1xUVTFCB+9QURXFliC2FYGVqTPmCW6s4NRydyk571VxQObuec5nmkt7psqBaYhh +nrFSdnsSrkJJ4bScSK/iRbliehyxsWojLaMoEMaaPOUkpIUFq8hpKMyTynGkgSLmYhWZMSZQnkLI +yksqoiItI49sNThjeU9MYxktaJiik7e/oCgGf2Nm/rTEemVstkZihUNbdsT04tVAG0mukji4nlli +KnER0JbiTKNPfZcqxqzMM7YTC6WKfjBgGXJXHVl4xotGHtZhdccU12buUCsziQ0y+MBg264Nf+PZ +TWNyClYURWPyIvQN0rX2xYeaZCc2aPTOd3H18ZSLO6hihtyNk8A6C4s+lRjqNYOttzI36TMiZZWN +bAjaBalCV7WXiIAZxzzefl3R7iDP2RIsrMomJAstysyT2m4HpmaKMhLloQXfmMNMnsVc/pN2LOAa +vwAbx6XeyNzYKdh6oKrpsUWDLS1hEaTxyQlMWu2Gpf32Cmj/X92T3mTqvf7yo78Njx/mb85/+O7k +p7/99Y/P3v7887ufftDAk3d/eP/DR+DJqx9+ePvh3XeegnoAe+GUCsXi/6//XnSqD71A/e/1P/CP +K/zlTwD93QsD77H3q28C7zsa//zeMg/ymGr95YEyz4WKfkG8T3RqaQG+/hhMlQdJ/7jenOJOYDHB +D3jn83tkngTLCKh5HLRSzEYVYGUCvoUXhCqhkVAQ4lAa5ylkYbA0T9nfgXVknUpS/MYjax2U+yxK +wRxD8i8qDQ/yQE5adRoAL5XFARNQ1gfwBzfn9THU6ivsxZ888glgSxLvMS2XmlrGkfoKqiuv2/vi +H5SPnmyCr++9KLZZ/4cqlMbkSwQrC8ifRFSZlhniCQiOYHW0ugg0IoQMgqXkVCIuIF+hpJbDZpH0 +BdlHC6YvUJ8S8KfRF+BB7+/mPFRCC1YntAflg9n6ANd2A/z95qKf/tde8dtbOGgWr+ySWGVKKTIW +81QNOwv9GO2E7sx+E6g+8tsbKGrq0X48KTVuDxjI7zdAPYFpnvTx2FT31ft41gL40Qo2wXa1xayb +n/XxBnz7EYkw50XnSTKN/qaNncpJ74UYvDmlvYnFmzdAxRotsPiajemK79548+Ye5dQELU5vjY0S +Ed6YtQB+9P5NsF1pMWvxQTc//dtPklFF7r67Jz7ePvuf/x9QHnVvLcGJtBCHL6Oway0NKDBEnFiD +E2ob9L0hT8pACHoakFIRMgJhswEk5xMZZXRpFIqV152d1WYTR4f4S1OS9Evq70f0jopNQsL46ga9 +M2BFzDOqa5qIj6cgVxU5e4vX/StTHwoP5lUJVVQ+/HjpmemhWXzm6T0NVlJEsSm3KNd/0zN8e2+T +ghG/z7Jsg/PpIwx1AIMCZ+TMJCA5TjQim4MnYKIVLwVM6Iy+NTiQJkGqd0Hpp9+beQVFYqq7AImC +gSqwQ43NzVVUwZUJvyyV6hxur/ZT9CZTWvGt76JTTsWN7yLfkZDJx99FchJpeze+i7JHKBXyxneR +C4wEYP1dZPhnsAq7/ujLMsrvjOTHX3Z7vf/ZVOL/tfQFBnlb/gq947/8FwlhqmBCQjuTR8qkasSP +nFR7qLabv7i+8QtKnjTQYpo7gRtTkCy2scaQ1oiPTt9cvP/+3Y7+q/r+52//ik+/h93CWi/vrc/e +/ev7b989vzzxXj+59yuSERI1w1L9TV1/+/pvPPL3hoGgZ//4z0fTb/gJ/m/uxVhdmKmFQi+gQfeG +Q7W2s7c/v93xyBYW3nv98L/zerLlBE436g93B6P9wWDP83c77p4/OBtOL/z+Ybebt1prv7+zWD4c +T8+GkyPHE00nxFOuL7o96fd2HDccjXam85MgvpoHV8PZ5QDPjk7H8+uWE9Xqg1qt127NeoN8PD+d +B4+n6yej+VVveuL0skZ7tQ4vZstj18un86vV+lmUftmfnLvdvcH0gdc/6Dhps7Xu9vZ6o5PB+GSd +PHMHe+XatOUkbk+2naDRXLqumM0v4vTVdH01mB63nNDtZW4vHkxkw1n0xjuBeBHJb7LD38+jF3i8 +1U2aDljo8/zot9HOV2H2Rbr7Zrp64o+Pmm7YHx36A2xCUm8uavWJ4666fjQYyv5ot9aY4F1db7fR +jpqduOWm3mC/PzrxB3vD8ZHf33P9/Sz7dRh/4fYOG52o2ljUmsu2Ey5WD6fz82Z72WwtRuOTyfSi +NzhotsJ6fdFxosn4WMrXnW7idtPh8KhWn5fKA/y23Y7bHfyk/eFZf3zu9U+8/lGlvqg31wA6bu66 ++WB43OsftDuJ5+8121G1Pmu7accRrXbU6oTj8elseoG9bXdEtbHaLg/wU6lOajV8SNTzsz4QoLVu +NGauE1Qq/e1St1ofN1qrVidqtuKut9/t7mC2egMrX/eGB20nrlT7zeYKi6xUxp1O6veOut5hv386 +mlxMpqdnZ79J5eNWe+p08/H0chU/mSzOG61loz7ttBNM2Budub39eiuqN1aDwcF6fb1cXLoOiPqj +wfiw3Y2BEk5XDCcXo+llv5+vlsf1xgQ/QM7F6tlodu0PgV2XQM7B8MDv5c3mvOuLRXCd7v1qGT+f +LJ94o5OWl3Z9+etv/qeD029cP3W66WzxJN97H4rf+IPTtiuAJK1O0Oqsm+1Vs73G93b9nd7wpO3m +bTerNRaV6hTLxgBgeH+03/Gybn9vtrwWO789On339Iu/dIdJu7ueLC6D/Kvds/fRzje96YPe+Awn +8uUX//bw6Q+dfl5vrWarp4dnP2T73/XGl/74otPNm60VttFxU0xea8xLlWGjFbQ7IQ6iXMHpjNpO +4gHhhwceNtyTne5O291x/P3uAIiHu3CIPQQGYhgebLYDIGq1Nmq1V74vcBmbrWW9Pm811u1WAAQD +IrlOtiO+FOnLcnlQLvVrtWm5Mtwu+ThEfKzrH/aHl6533HEPxqNHk8lVrb5odyLHFX5vH0cGgtBx +QR/Ol+unjpdulb372w6QEzRlNns4nTzAZaHZavNmMyyVe1vbTqXsu52o1zvqD469blYq97EMx0mq +tXG9MQUuNVtJubpqNKNWO+x4u/3pQyIsjSm+ooJNqAwdRwThF1H8VRh+ORydZuLlv/79/3z+1YfP +7teni6uD0z/mR28G07N6c0WXqJMC4WvNebU+B6TtpPP1g9ni3AeG+/LFi58WwYN6e1Wuj31/V8g3 +UfZrvyc9P6rXcRHixfIBKEzH22l1d/zh2WL1NMm+nMzOnc56sTjL9l4v4qveZK83PsbOj2aX6+jZ +o8ffr6Nr10uBlqvwxTJ+1Ruftzt5t7ff6RK+AbvK1UENX9RZ4wJ2fdydXb93Asrm+0euJxqteddL ++6Md4LzTk+vo5dnVvz549rfjq3fOIOmNdubBg1l4NQkf+ZPzIP3q6OxP+e6vLi5/n+19AQrsuuli +fR1mrybLR27/2BviE47crgR5AWpVahOQgmpt4Xp7+GejscABVWtTt5t3ulmttaq2wxaOtXvc9c8W +4Zfd4V61McY+T5dP6s2gUpttlUagMx0nabVBwQKQqXaH/mw117XqpFIeVis4ymWrGcxn56PRMTCq +XB5WyqPt7R6hWaXfaK1df28yezwYPRqMHi4WL2azJ80WsGIfZA30oePgCE5c/3g6f5KIX3uDva1y +t1IdOG6CS+f39lw3AynAspvNoN2KtrZcoFa9PnY6oecdOV2Q0LTVSnq908n4tN+X49EuLkKpOq/U +QlBp18twcTr+aQdEu5tg2lLZJ1rnZsPhMQZ4Plje0Wr99PD098vk0Wf3G+PFSSSeT5cP26B73j6o +gdOVNcUIcK2wA14PE2ZtOuJsMT27fvx+MN5vdoKun2Oq0fSB42Mn5yAgnpfP5xfL4KrjpsPpkTfc +94dHLu714AjraTYXcfzk8OztKn4Upo/m0cPe+Gi8uJwF1/jTHxx0/d08/2IeXFYa42pj5jj5ePLQ +8w9woKAhQPJGG+QL139Ra6waLdEfnGOrh+MLf4Cdyf3ebm+wO5ocjedng8npbPV4LV7Po2fdwV6Y +vgySp6PF2SK4HCyOxd5vHn/+j8Pz99h/3BEQk8XsDBS1VBkAhWbza7n3DqczW1yPJ6eevwOyA9IK +ygbaValNgQOdjgAD6nogUym4Xgsn6x263ml/+ChIfosr03YhYb6YLB9XG8tydVauzsGtMAmIXseN +wMW83j7ue7OxAnVq1Bf4IRyrDDvga95Ovb4qVyaV6rxeXwIT7m93q7VJq5MMRqf1VlirYyXregMk +VAxGJ9htMESgDfan3g4cb7c3vMQ5gqb1+3sdZwH6A8RutkGOYlDILtiok25v92vVebU63tryWq1s +OLrogt56B81m0u8dROGj9eqiVOlj8dU68b5GE7h9MJw+W8evFqtHIG7bpV61OgLt2g== + + + Lrmlku97+d7OV5P5Q6d3UGuucCPazsTzRX94hDOaLJ44/kGnCxSVEAZGo712e+q6odffH0weLFaf +r0Mc5YHbjcEcj87+2HEznDW4BpjCYHQ2HJ1hHlyu+eJRIl9C2inVxiB6ILaj8Tlwe7G+mq0eZOmL +f/+f/6/Xv/uH0087ftyfQCR7FMSvRP71zv43g8kxfQVmbsdu92A4vp6tvpgtX03mzzDM7Wajwe58 +dVVvJ2DWjVaCnZzOH03m18PZVZK8/OLLvx+f/bbRWfn9/VX0Qh78bufonTz6bhFeR+GTf/v5fw92 +ryvNebubOUAG/wDiwXR6CfFGSSkLMJdefw+XCDPjp0mMAPLPjuPJ7bJTq+Nz4jZd271Kbdlopu2O +nM0eTGbH2xXQllmjJYeTZ7Pli9ny2WB86XR3gQ91EktmtdqwUsFZDOvNuQfO0j/ECTod0WgEjQaY +y7BWG4MBkQBTnZbK42ptCToJ1AIHAcmqgIBUeve3WpDBqtVZvb5utSIQChwBcAZssVQdVBrTthsD +aSez6/4Ql2If244b7XnAnGNMDjoDllcuj8vlSaMRuh1Zx1fUFk4nLpd9ELGt7R7YFsZ3OtE2UctR +B8JeG/xo0fWxLdL1d4eTS2xar38MGczpgHZ5eLDVwlOiUh9vV8fblQm+7vT499X6AHIpZAbQ9o6X +O97+ePYkzd+k2W+Wy8vxMJXZkyR/2RsdAcEgNvvDncXiQuav5cGbRiucTo9Gk0OIiyR1DM76o8vp +/Jnc/y7OIcdmEEuWwSN/sN8jorS/DJ6mO6/PLt/99Lf/7erFe7cvhrPTyep6sryGyjCaXszWT/zh +CZAchA73Yjg+na8ez5ZPBqOLyewKvHK+fPzo4feXj3+st9NGO/V6h+PJ2XR2iWfHswdx/OLw4Jv5 +6kHHS3v00kPIgWH6Ot9/O109CpPPf/jLf8wOvwDCNzsRaN1o9gASOygq5GFQgFYnxd/BMpxOhFdj +SaBLxEq8fa93VG8s6nTcI/zUaqDnoBUnIJtZ/uvx7LRcHQFPOk7ecmTLBaPc9fsn/cFJt7vfagn8 +drvsVWsDyKKt1gp0aTI+Gw6OBv3D8ei81U5Bo9rgqu2oXJnW6pDBFrXaDDhWrU5xsl1P1ptLcLdS +qdtqhZXKbHsbHHPc7oAZ4c5CSF6DcbhgW90dYJrv75P+5e0BzehovJ1+/wAyM+aE/IY5sX6gFoSu +KuR50KXqhKT36qhUGgKdiB1XRppSAX98fw/sab68hqgG8R44hmlxoG5X1GszyGyYsIur6oQlbIIn +vf7eYAQ8jKu1IWg+6RqepLOYPMp33+2f/nmxejIY7E5HO1cPvj0+/223l/dHR4Px0XR5HsaPd/e/ +nq0fVGrz2fxsMjuFjBcnr9bhl+vgK9zZRfjKHwLfgmF/b/fwq0Z7CWnc7x3s7n93+uDPl09/uHj2 +/Ti8GE6PTy7+EIhXDQdYveP1D4PkVSJ/k+68Gc+usKTJ7KzTFc123HJATPaD+EWS/er08vtIftXo +7LqQtfwdnz4EJPdkvrqeLa5Io+xKbOxocgKx3/VlmLw6v/phnb5cRE/l4VeOn1XpDu5AioMmAs4L +PgKRfjA4xYvAOMqV8aC3G8VPofwCJXAiEO1mi2eD4VmrjtutKE99iRN3nAwiWX/0EH9CMPbcHezD +dnlYrk7AtrA2/LPZhGwmK9UFWG25iiPrt9pr6OA4a0iq0/GFSL4cjS7qTejRS6WR7QE96jUoU0G9 +MccjjSaUNejIcaNJ0j5eWqtBJF41wBPrS0j+rpIWQB77wxMcOvQFYMJ09gB/QkDCP/Gi2fwh2AeY +ODhgvTZvt5NKZVoq9UDHSKirTEAJ25DYyxOiijWoY+DFswoQrDbFi5xOBlyCUNd1xHh4UqkDo3xg +Y2m712wFYMcQSsF2y7UxNq3jBuWy89lndUiwPkTuVtjvg36e0vWfX3T7O01iyulsfHx49JtV/BjT +zhaPIHt3B1l/LBerw+EYPCskW0HyChJvlv9qNH0I1bjtymoz7rg7kGOD4Ol0eVFrzbw+MPNgtnww +mp2OFhfu8NDp7wbpy4vrvwTiRRvEYXzmDYG3j5bRy9n68/H8MdRtjG9COOkKYELLicazh4vgi9H8 +WXd44UFX6h9DkgGxHUIi6u+0OjEub70JYWZ3sXzh9SRke9ATMGt8LyQuFxett+8PDperJ2n2VdOJ +mp01xH7IRdD6QTFK1SlEC5zgaHgcho/buIYlH7I35ldKd1SH8FPFoYfQ7EBA8KfnH05mz0fjx1C9 +PXevSrcY+juOrLddgoLm1hthp70HCZkOvRVUqtDrl0BXUCQghtrzY7e7W2uEkJ2AJIPBCSRzz00m +g/1OZ7213QY2Aq86nbzdBp/KwaA77XQC5bo5v7/VrFSgSILiBV26UJBLgWbz6fThdHaF0wEPhcxM +cr4r6Ya2w3K5j2XjFfQJxMu6+AEBbDWTdlsA37AwCNhg/cQ6q+NKZQziBrENNwJsdy9/+dXLn7cr +/c/utzFV18nnkJYXB467pMVUwdOXpbJz/7NKpeSArLVwQWpTiJGQMHEc9eYEmj6E6unkYj57MJ2f +41ihPk/mD7zRXq05cv2wP8gm0wPQq1B8MVtdNTrr0fxB28sqjTnOGggWxq+i9OVoelprLaAuOb4A +f2w6gdPLoMGNZlf5/u/Xyevx4mHHF0H8OdAMZ91x48H4IpFv987+PA0/7w6hL4TAK6eX1zsrPLWI +vp4FX0+AOYPDpgNcCuLk5Sp6Cr2D9LjGHBcTXAmLxz9xUritYI7QLkeTsyj/eh4+90fHXXB2fwea +3XR+MVk9qnfC7eoQkMHwCLcPewVxCzQcyOa5OV6xTUfQwiFCImq31p6b4j7ixHG1QZkbrQW2FNiC +c3ccXEkBnNku9UnwBtVqr8FhSyS3TMBfSGqqTkHZwFXBAbte3iSdMSbO29/HyDqpohC0RsCrZmte +rfTHQyhHp4pT4xvn26VRo77GmUI729qqu07Y82UTqn1jXQYDJSIzH/RP5stnoMnEhesTfA5oDsTI +TieGbgsyBVS5v9UolV0gHhTergvWNsE9gkIK8kXUppcvoSx7u8r64d3f6oCC4Vu6fgZFCXsL9jcc +ynpjWCq3S6VmudRuNhbDweFifuG6q3ZjtFocQcIEyW02lyTv9fIa0MBd9Qc5Dgv8nTYHynV9Ssa3 +6XlvfNhszWbLE2+QA0KGGgioLSIdYuftZHEFqSAUT5vOEhuOx2tgN5BafREmz1bhk9niLNl92Zsc +eYODweQcOmkDmODl+e5v5eHvHB8ceT8/eBtkXw3nD6F2NToxuGSUvo53vwLRg5w2Xj+sd4JqfVnG +KTQhq++F0XNQWnzCdH4KNICsQtJvY91ux8H68yz/uj8+bLeWO/tfTqOzanNYacyq+LQO8cqTsz+c +XP1Lb3bhdNMweer2wHcgjYwg8eIowbbS6OVkclau9hqNUbcbl8pd3HQcNxAAiEdWEQcstddxQ2iR +zVYE0RrcqlKZlys4rz0oaI3mrE4/ZBark/RCeLhdGmDwcHgBIQEaR9sNG+0FDnFriwSeeh3saeh5 +SbMx63lJmjxsOSB00BpCRdYOW82oUQflnJXLXs/PnfYahAs8q9WKcbNIBGqsmmTRxf4IvL1SG1br +Y5CgahULG4NDQXyqVPEVw3ZnpUQsf2vLAR0GjVI6wmK5ePDjT/8HGce2O9VqH2IegMBbsMIqJm+F ++/tfHhw+B1I1at2+t+p7MdRPhS1rUCqvKw6OfgVdDNoo8FZRvACiF7BuMT9VppVRrbpst6KOg49K +B8MDMj315NmD3w2m+1ulXgW6J4nEQX90vLP/2+HkbDG//Ort/1BpDMjG5UCPznxfjsaHQK3Z4mJ/ +5+UXb/4xXp1XFGKARPv+wTp4+fDJP3ZPfu/29oajo7V43vKSRicE5+pDjF8/lQffhvJ1Gj1+94f/ +EO08uV9yFX0GkScBYDp77A9OoM4fHL+F/FwuTyEz4J/47XxxBTUZJLfXlQ+u3/dn2dZ2A7QCSAUS +OhgfXF7/+fLZv4wWl8vZ2eNnf6x3Zlvbze1tx/NzUDCIEOvVYzAsXBOvlzpuqNiTXyeSQnoxsL3r +J+3OfBWBbgfa0L1dgq4HDXdvDBmsC0Eoni/OeoPd+1vO1lYHejr4iGI62Wh85ZP8ELfcoFLrK3oy +As2BtgUKiZsOcWs5P4nFVaUxVmYxKBoQ8CJiUpVZs77oeflyftEBCnnpcHgItQ6EtFYHUxvjFR0n +Pjj42u/noF24EUBFpyMb6tJBOAdG9f14NgWOAbV6IMjVCoQuehBsHRrl56/+pdaaVMu+1wmhgIB2 +bW/T4mt1MJc8zV6sgstK2fGced9fd1rQLKCnzPzeznR2DnI3GJ9CTKqCmdam5TL0l3kHB9HLx5ND +kHSw4Hpt5QBD/IQuJmFjHgXPjs7f9kd7IPIOWf9wwUMlMIs22UvPv3zzb/XO3Pez8fi419sFHfN6 +O64nXC8+2H3x9v3/sowf1UgcTXF3JuOL5fpJtv+rwfS0rrj5YH5cac16wx2Rv3B7ux0owp7sj08u +L97+h3//f86vfov39v29LmhaawUU7fUfzFevposnkfym0z+GOjabQEIDpQV/T/BeyLGjwfEqfNzo +LLDDYxKc9lqdZdtdgfZ2B7Lby073vvz3//X/bndX29udrhtEyTUoLc6oVMbdmUNUW4cPofKA5jhu +0OksHTcGU8DM+PBwdfX+p//Y9qCt95VPKsSfjiPA/kBqovjRm7f/49mD78BTtrfb1aoPTABzKVVG +oL04o/7wAMQBch34KagNZONK2S+VPEh0s/H5evVwMN4r1yfgmKCTWyUfHARMedTfHfX3ZpOT9fqh +103j8KrZWoDsbG21G/hwkpMF7mkiPh+MpCaDtdpQqYcj0hPBvp1wPttbzI9Ai5SISJgDBINAiB8c +EDZwu+RAo1lML0EeP7tXLW1jciiDhyC20BqgQpbLfoNEqSFejb932glol3IiTDsuZN3FVskDjQJn +7HaFC03cSaGtlMqEwBUiXCO3G7luPB4dZeKLyeoKQj5ODTe3RR6xueMlQKrB6HC6uIAKOZwcO162 +Dh+H+Qt/AOV9dzA68PqyP9wNwof98UG5AXa2IJG7sWiSHRI0dgJePBwdYJ8xf8fP/cEeiGGljsnz +5frx7tEbcfR2Hj93B/v11gqEl5TxxqTSmPqDfWijXu9oMHnU8Q7XwRfr8DmEq3prhvPCCrFvtTq0 +rZhE5ea61gTCuNulNv7sYp3Ri1R+kWbXcvcphBxIOBMcZdUplTv4J7ZiNns0GF30htA3I4jKHSeo +NUZ0m6D/jg+AqHH8pTz+bYVcTmNcqHIZm4zb7VUqfqMxHU2P58HVYHxC1qf2ol4bVKs9HAROv0MW +M1lvxhDye72zVfC16++SStiAxIXjmEKwrzfIdtcbnsfZN9AmiFN3cHbjEkhEZdhpzg== + + + m/V510mS6DGQodEIQJOdDvjjtNlYQR9ptMgvNh6fYswWxOxSH+9ttZbgjyUSHfuk7YJOktemB8oz +GR2SDkI/ffw0mkvPPwCSgGQ5HWijC1w96Mil8pBU1CYtZjw8A6OvVSaz4cnWtnfvHuSuHuQTEk5q +YP0+kVAyaIzAjtv4Uv8IZBPEk4weFaAWBIkllgR8BqslXjN/MBodtyGxuNFkduT1s2YnanfzlrPr +eMdR8s3O4R+jnV9DYen1d8FGQUaAwyDRYIKNdtLqCHBtvLTrpJPxUaOzHI52x+PD0eQiEl+vopdu +fwcqPGR1Hxq0nzmemAW/CuXv5/EXDrTFTup4e12yM4h6e9KCcNg/3Nl/N1s9dbr7jXaMq931JWgL +rj++q9OBFHfRG5w73Z0aGYjGpIPXp6C0/cm+20+7g9z1oJFJkqtbdBkdN3L9pNkGfkbQLKCxuv4+ +uDB5FbsZmDVETXyRUu0PB+NLt7vndXdx9OCnjTq2sbe93QT3bLRDyJNtN/dI7lqCpOBAwSAq5T6x +IeiJLUy47/WAe3mjnXv+8XBw0u4sCT2UsRRn1OnKLt4OydPbnc+uGxB4yj2nHTgQGqujRg0s6aTj +yE4nbTYhbQJhIDAL4K3rQYA/Xi6u59MLkIhmfVWrju/fb9y7V4EQVSGZp7+1jYtGptQaKb8J1I0m +6Rrj+9seqGi1uqhWsexVFD7CAQGru+2o0yJHKoghPgRPgbV5zkG6/hLK5vY2BLYhVOPP7ndAwBuN +JRnowG2hPDZBS3eGw1OQFLD+amWGB31/t06mjH6N6Ezc7x0vl4+xw1jAcLAnss8dPybDuysH40fL +4Kts57vp6gkUMexGnDyHTlFrTHHcg8HedHo+nT3qD47ALCrVydDfz9KX9TZI9Bi8eBE8Ozz/c5R9 +DfxptML5+vPB5AHdx+YqEG8W8Wu3f4DD6vp7i+D5Ov1qNIYknE2XZ15vb7q4artJtQ6eDk1/dzg+ +dVxs1ADyHgSbejOtt0StGdUa4GhyMID8cwg8waVw+6I/gmR12YZ+1w4qlUG9OhsTJUxKlS6Y4Hh+ +PpydNtqgV2QwnC2eLNfPm0Q5523yBoLt7kK7d5y8WltCTnZxg5rT7VIH+le1scQPGDdtXTPsOmAK +olZbbt13cP0hfkMaKZPVCzwoHI6v1uuvFsvnZCkannQ9LMAjLa8xA1X3SKDam82vWs25014Me7Jc +crehu5WGA/8Cj4Bj0t2H9NtcQ9hod2LITuBNrWbiubv4021LXLTPPquBu1XK5J28f79z716rTFon +SEcAYlIBbekI8Ov7W77r7nY62L0dx9kLgsejEWRasZxedtqRFh1rlTGwzmmn0Fm6Tra97ddI0+yB +fNVr8+XqBXZJmS8muMhAsyo5GsCXFzU6pqTdhqSalrDI8gicCKdcq5EzAsJYHfLe8Hy+fkLBJ42Z +3z/w+4ftbgqVZLvSAz3E3QmTz8HmGhRYkrQd8FAgJ/jCzPPy4eB4OrmczCHV+x13iVMeTA/9MbmK +RhDgF1fjxaM2GYsg24CAzDFtpTYCQ4RA2xtfdIdnrbZ8cvqHpy++r4Hx1efAZLCwKcUCgZ+GFfqi +mcye18iRt3a949Hk0iNH6oHfO2k5Avv/za//+69/8w/oaBCrShVo4ku/m/b9nXT92OvGbVLkd8Cv +typuqTrsDY6W66dR+tVs8RhS1mAoB6PdUqW3RSwgIbrhCPpphxSK04n6ffx2SF7+1go6PkS+Yf/U +dfbq9RB31mlHteoAqhmUMqxKRQWQdatUhT6YyPT1ZJzXaqCf61oDCxtVqmC1GDx2O8G4l83Hh2BP +NQj80ImAolWwWsg8PsnALjbwDIQFKme7Gfbc/T5I6+DUdw8a9fn9+837hNgDYAL+Ui1PoRRAiGpB +nccetpPh6AHYSq2+wp91kMHqcrsCNXOhHBCHy8VjsC3om/gi/FAcDojVlksrgQiHb6f1APkjXL0y +MdyF58YQqKqgTpUh9MdeHyIH2fxBWzAtlGV8e4POCIzYr0DCry+UyQLXbVkuD8HsWk68TaEaLpmd +gQNNPLUGcXOggfp7/dEp5JxKxXMcLABMPO3gdcoRD5kzjj8fzg63Kj64wHh6Np6cAE/qzRDXudGM +mkSo+25n2e+lWHCtuQaFGY4fzBbXu4ffreUrCF3An/H0ApID2WFwncs+FuB2M8/fq9XXjrvTcbIy +EB6nU5u2WpHrZWHy/OLRH47O30AjcB0y+4DpA6OcTgzxtdcVAy+fjA+xISA7ZJKFqFYnxJ7OzmbT +k+H4EDisxOCJMu8nwHwwBYhS2CIgDCgVZMLl4gL6FDazhc8hQ3pQKgMTcC7rZnOlmMUE+3z/s/b9 +z1qV8qDVjMA4BmD37XWzPhsNcRA9UgHAXuvYrjkk50ZthmNVbH1cKjn3P6sDSwFs1pe+k41GR0ok +mw37uxAdwZ2h20I5xSuATtvbPbyCvAbEBPHe2vZ9TN7vdSPfjdvttNmWjTa+8XK7MtwC765Dl0+B +/IPB0WJ5NV08bHXIo0FG5pL32WdVsNp2c9lqzEsloDc+DSoh9sFR1tHM6abt9ppIYguCQeb3JMVH +OaT3Aceg87bJlhuRBYwuIJjvslKZ4KZj/UBUx007XlptLrCBwDc8gsPC3yFVroPrNH+1jj5vk/lx +CbEN6mezPWk70I8S4P8EMmoIgX+/1sLjE5F9MRiROYjiWEBCyQuMIwugEs7nYFu5ss9DdIGAd+R6 +O2T/7O1SxF1j5XoSlArnC/IISZ4QiYjGChd2ODoD58I5QtrBgeIiQHn0hwfL6Ml8deV2D/qDMzwL +CaQM5AfB6e212xHQA3sCStJoZxCJcY6dNjYqHo0OyIvt7vb7pz1vr0leACx+AHajfM0jqD+QWuut +ADsp88/PHvzuPihbHXJvpmKlhuBT5Qok/6XyLgU4lHIJ17+PP8mjt93b2vKr4GWNFfAEPA7EoQ1Z +tz6GLIeLDBaG42tSABhQC2wIoktve6u5vQXk7EOXL9OXrrPky14//uyz8v3Pqo0q4RIWBrIAjllV +/kTITvgVlA78BZPgLS4FnFwOx+cQ1UDG75cG0JFJ/VG6A5gdVttsg63LrrsLWQXUz3NEu7nYug8V +uEciIrCoGUJwGowoCqU33Ieo43RFt3egPMXkvBvNTmbB1WT1oEqqKETWiCTJ3i5+6JhqwNvQwVOk +iK0bnTVJ8i7JOWMKodx3u2I4PFgsThars8nsots77A+P+mSJOu36URA9DONnUJC73QzHVGnMK40Z +5POHVx/G0wNo6E43KtenW/RpyzqkBXLon1Ak5+CwS2Eb4VZ5sl2edFySlKBbgXqDk3Z7+6Ppebcv +t0oOdOdKdQSaCTbt9Q4hLXe9IyBzvQENYggO3u3tHZ/96eTsz+PJtd8jHyIuDoWg1Ml1okI9xyrW +Lne6e1CUoLCD9OFm1Yl6rFvtfDS8nE7APlIgHpkdVLANWbC3e5UyRXvi0+aLi+nqAc5IWTJXpKeX ++k0ohs2s0YSGQqEmdbKCrsrlydaWBy6m5GGg1qQGyadNJtCum44HB63muFoBWYvBT6HBgde02hRQ +6vt5rdL77B5QqF4u+aDAwH/Ifr5/Av2LFIpSp9+l8AYwr2plrCKHgwb5wfGNPj5ZOaf6kFVapISm +bSejj2pS+EeN7PzDe/ca9++1aFXEwlK3u+NR9JrEX/pAiW4EtCzR9Zlr1Gp35GT+MMperqIny/Bh +mD3rj6HFn43mDyeLh0H6IpZfi/03Tu+oQ4ElUAChCB/jcMn36uLW77keqNmKyJGfAT8nc+jpRzhr +nO9kDob1cDjeXyzPV8Hjwfh8OD7rkdP8cDZ/cHHx/uDwt/PlJRR5sj51oJHtQBaCkAxtaDA8hNpe +70DwmODuA3Mcb2c0u5gsH40XV1DWII0rn+9CRboee/39BiRkb3cZPhe7v/bHZOUG66wruleqTqFO +ThaPx/Nn4LDbZLQEZQuny8vJ4gKrrdSgiCUdl+JXx7NzcFVol6DkwC4Q4TaF90ABuca3dzwJZIO0 +M5kc9gfHXe8ASAstr+UCSaAFpDUyVhNNIIYIxu2mfn/fwYJbSdOJ6y0KYICc2YGm3MRVlbVm3O0f +TucPIbXWGyHZGBtzFXswgNQEsRaKp+vm/d7+oLcHvMJ6GuRDJ75DrqUuzncHmniV1F7wXJARiCuD +RgPaWQiq6HsgL+Dv+XJxWqsPQXiHo70weYaLAPoJtOyPjiHutkg5ymazQ4ptbixx0DhBf3Da7R+1 +KIA2LRHFA/KQ2xEMhciIE4NQrKLnUfI8Tj/HcUODbjUJXckV205wjsMpdvjB/tmvQ/k5tKEgfTZa +POgDJYKrbO/rwwfvk71fj2aX5OR1wzj7fDg9B33okWVgD6czXz8Yzo5X8XV/uD9bXkbyxXhB4Xnj ++YMwe7l79Jt8/8tV8qw3PgULWwdPQ4hV45PB6FSNOZ+tLvZPfjNenLU9gQ8ZTK8my2ez4PPR4rqL +sxvsTxeXyc5LEKIoex3v/GYwvXR6u4PJRR+IOjoGQVB+yazdTbyBxM90eb4MH4fii3X8YjS9HAxO +/N4hWGeTTBb7LgUuriBXtyFb+jhZ8GVIFwm5UfxdTIifwRiPUGx8ywGdWQxH+0Bgx8uGk3PooYPR +cRg/XUEZn531h4eDyUnHl1XwNWCgv7uMns2D625/9z+R9B5edlRXvvA/8D2QOt4cK+d8q+rmnHPq +2zlndbdyRAEJSSSRDQaTjG1wxgkwNmB7HHGOYGODwXg8Y+M0nnnvm/e99da3S16rFotu9a1bZ5+9 +f6HqnF3WHDkE6xlowPTDaXGggDIn14NEKoDF4Tr9qA4qwhPQSTbHCBUoPbgMHxKFLwJ6hQR2ODi3 +i/d6wEYJKBJH0SQKQQtC2AGEozAiSFcbKFKHAB+BH+Ffea4CZAFQP2YXrAU2dgkYHNwKjicFqaRF +WmKowiv5bG1ZUFvW+h9XKIhlELzgR5I4mVSkgiJX/GjU4VVhZu3WMjAKzg/DsUjNA3qJdLoYTsx4 +fBKK6QSVBAkNPg4MO820rIVzFETPBE0C3Of26kFrgopKpEPwRV5rKWaXEgq0ANgVY+V8LDcbKywy +UhlygBMypcYmxRd9oA/pHJS8oDZZuUpwOZK3vF40PpmtrKBk0gUQROWlUBvyKhTta9EplC6jZAWo +NoCoviDMsgb4IGkNQaszUgWyxe5RSb6MUimETOJMgRIagj4pGZNqeJpT2gybK9V3JWPC5laCeFrW +J2UDft/j5FYQj3uDOqRKwFobLwHbYngkHJ9M5BaN2CAcn+LEOqCKzSnjdB7Bk05rBaN8fWkED/YN +xPb1h7+0tbnDFwoiUZzIymqP4ksYnaK4rKjVMTrh9is4k4Uhw8FIdQiUGZ/Rwn1BbwTIxBCYd4+G +ESmSLTJSA/5rDZDJSVqrUNs0UtOkVFEjE1p0UrWWcNfM1LQabkJ24VQkkuwm83NquA== + + + ff3J/j8X20eDRJzl8r4AsCEFxHd9R0CS5qvAJhahaC0rS7G4HwM8h2DCB6OcWMsUVlPFVZTKAdT4 +0Tg4dOuRvZv3B3ROKkXzc4nScrm7M71+PlZYRagsxoAWSo3aQAilMDInSvVsfjWSmocBEkzefv2G +gNerIHgM1BFireBNa2YnnJxSwx1ezFkbdvyQCaUgmnJbS9QSvNKQzTbJA78UrS05SCSIx2ipRIk1 +Vm7KRjeWW0hXljklx8oZNdKUwy0p3NLifU6thGI9RqkSfB5nM4AkKBnHmRQtFOFTkfhcZ3CiM30s +nJwUtAbOFWEuBKUiarVwal6NLaVKByEm/iC4D0APNYhFeLkMdCyZExhbRpliJLMiKHVWLBAsJHZG +1CdYpUOLTYqvm+Fue/IYrzXHnAJMXCg8LekTFF+l+AokOfwxSqU5ueH2y3YXDdkrKAVJL+sxayxa +dACKMYDHGbHs8MheC3ItygYEgBwD1MLItMPaEWP6g2G3F34j65HpeG45kp0Pp2bggHDBMKGC/FgM +ZdKsUmOVeiyzaCZmYLJYuWxzcj6/hmEAJgZOFUSlAxVqJqazla2plUuJ0gqENxSbkvQeTH154lB5 +cChWmBe0WsisNSc2W1N7+cYqpAogIS1WCL4AXyGqVZJJJxIDgFBILUYow0GyFpUUGtup0qpitPOV +hVC06fTKPiTMy7VwYjpWWI5DdjE5l0+XQ3U/ZozZ0CBmKAZAVi2WXWhMnZjauBTJLcUz0wvrN4lK +0+GKsHKfV3uC2o0m5sudo2pkBnJ1ZAz3eORgIMQKOSMxkMN9PT5T7h5OlTdgHvVIq1xdxKisyw3a +DDR2jKAqsjEVya5nqwd5pZVIz0KBgKFD8IRkDMKplWLj8MLWHXvH3z+7eGp+/ZQabfNqJV6YjxcX +1Wg3np/vTJ+c3rhFi08gZDxIhHEqJusNAKhsbbPY2tZjE4tbl8u9bYRLI1RC0iqhSCteXFLi83pm +mTO7XKgZLyz5EMXuInEqbsQms42D2fbhdHMv3dgz4rOtwaFwsi1o+XBmVjYnAKmU8CCRWyj3duGD +rAi5Wnd4RT9m4jDLYllUG2q4nyxu5Gq7GJ0kmISoFHyIhNMmJ+XDqdl0dT1dWS83dzqD4yDhGLFC +C1XAWxi+Fh6EEzPZ8lahcTCSWgGkBa70BnSaK4QiE5HsnGx2ea0hGm0zOcUolSCdpuUaq9ZFoxvN +LEKEy92DjFD0BxQUNXweMAICgmXU0ER9cLjY2crVtyoTx5KFxZXtcxAZYE9aKGXq64PVsws7F5d3 +L03OHdXMmiAXE7l5jMoQbAGl87zWbk6eLrV30+XV7vRJKHyXVya4NKCoEu5nyuvNqaP1qSPl9tb2 +sdsaEwfEUDWAhUlrV8vASM0VunuJ4poZny53DvqwsM/P62aVZpM2O04yiUx5dWrzlqn1C1tHb7v/ +g8/LobagTLTnLsbz6wiRx6gSr3Vxpuy1li1JgFQujwBUGIrUjUQ/mgV8WFcjgwCeyOTnnvnM1/XE +5JidUkP19sQx1YD5AmDc1RMLALxrmxcROmVz8iwoq+hkrrpTqB+qD04Umlu7h287evP7GbkSTc72 +5k5PrZydXD5dHxwcrF2Y27m1P3n8oSeey9QAfuPhWDtb3Sy1D1Z7hzpzJyfXL1Z723NLR9eP3QrE +2hpsz25eSNcOSJFBY+r4/O61fO+kYlSj2RYfygcwgxarcnjCzC6amblcY6vQPqDFWtX+SqKyIIbq +itkm+Iwabumxnh7tdWcuJAvrCBWmpUw4OUGLoKyKFg4bPTU8iKSXio2DpfZeKFLVI3VeKWvRXqKw +GMvO56qrtc7m1uErc2tnAS0ZIZ8qr9S6u725E9XObr62nShu8HJzYuLY5OIZX1AjmDikRLG1l61u +xAvLEwtnZ5dvvnD10UZ/z4tGIee16AykvZmYk8PzemKr0j3N8aVAwMDIFMGk4tkpJdKOZme0aDec +HBTqG7xSBxbTIhOcVIilJwv1tURuTlKLBBUDNqz3j0qhViwzA1fLiKV4djZbWzVSUyhTUiLdcns9 +VZxlxUy6sqSa9UR20BjspcvLRrxXbK7ecf9H4FScVOzNHp/ZuFSfPpGprUfTM4xQB0FbLG9sH7o7 +lZ/1I4KsFcqNlYnF45OrJ9tzp6c3rohaW9UnKa4wZsNBHoTiC92FS63ps/HCZry8FbNERT9fmivX +Fzx+0eVVQGlzoY5skfsgkpy10FXKVptrsfQU2HMh1DezK1piLlleCacmHV7B4WJBfWGELshlzZyI +ZRcztY1i+3CudQh8X8johVMDI1HPVGaSxflIdtqItwe9jWc+/Uqpve5DNCPaHsxfHsxf6c9fmFy9 +EM7OVmvLjzz04Yc//iVQKd3ZYzObVzrz58r9YxPLFwYrN6vhibNn7n7fk5820q0xB8OKdSM2k6lu +9BZOrh26vdrfnZre+9Azn8s31yAHKq2tbHUVUm75wNVTFx/dOf1EJLky0duaXTgB6cHLJcWEpJpI +5Fea06eWD91z4MwHahPH19ZPzy4cpISMFmnr8YEYasp6K56dWTl4bfXYfcALergLiUcwSTgDK5XB +fvrQtBdJRZOLjcFhlAiRbEwx6jDFIC0kAyRoq9E+cO2+p/szhzAmVZ88W+wcS5fXByvnC72TUmRR +MqcIKh2OTKNkIoDq4WgnkZudXT+7tHNLe+4EDeqFzjWbB26/56OMkIqlus2JQ83BCUFvw7XFswvx +3CKI0nB8woh1XT4BwXUAZxhUNLM0s3zTqUuPAJivr51e3zrDidlospupLOVqm/35U0fP3Xv7Ax8C +DFldPnLPQx/qLx4HTxQkEmAWwC+ni4erE+dqE6dDZmd9/djJU7dEYxUUJlqrC/pAjc1F00sz63eY +yQU/YmrhNvAplICoAuPX9OScFGqm8nOX73pi6/DN3qAKogslMtn6brKyKZt9lMjxQvXEiTvvuf/p +kN5k+AJkVKy0lqoc6C/eTLBZb0BF8bA3oPgDkqRU9SiU2CZMU6511EyvYFii2zmoGkVPkGbEeDI/ +X25uNXqbtfbyxMwuK2dtLkpS84XKVr66kyqsAYuJRq1YXTxx5u6VQ5eCuJmrrWbqm9H8Yn3qZKq+ +pcUmYZZPnbzj4h0Pq5HKqJ0RFECkgRJuQ9I2Jg9D0Obmj3zp5W93pg6KcmFx9ezBmx6a3r66cODK +7sl7p9avCnLzphO333zLIxiVVPQ2fGm+upkurhYam+3Zk5X+ISFUP3b86tLaCZJLpctLueaWmZyN +pOZKzZ2Vg3e15y/o0anpuVMElxkewwDzBQVsXQ1nK+A1OLmTLiyk0u1KbQElwyIQemwCOJFTapHE +THPyqBJpEWyqPnVK1BskByqihvPFUbdm85m0UI9n1tx+FfRkNN5TjXpzsNObPxbNL+AgJvFMsbhy +5dpTslFMF6cnl8/U+odDiWleKQlqGaXTGJuDUZixQQDTeCWrGA0NqsbshCLNTGEehNPszN784lFQ +PtX25sTiye7cye7s0f7cwWZ3zTDqDz345De+99O13ZudXhUlEhRbgLRJFncSRYj5FE7Er1553yc+ +/WK+MAESrtw5AqVR7p3ozN8ysXwVRCBBgfY6la0s2609xRLJ5XP1A8nCcnvy6J0Pf3pl75IZaxWq +ix6fgrM5TmsSbB7oJlde3z546+rmBV7IVxpL6fIsziaDeJJiK6HwIF3azBTXAohhhGrhaBchIhA6 +NWq5M07pUEzOMFt+RHa4CZqLxDL9zuTe6t6VTH0N/MW4g7U5KYTQMDKk6NV4ZjFV3qr0d6aWz24c +u6YDYXHpQm1JDBV4Lb9x9L7ZjVvyja1cZbXc2gI88SJg6mXJ6KBUDCMjkfQ0pEFjcLA7d6Q1vSOF +qyihGtFaIj+dbaxX+ofz7V1B76FELBprRuJd8AKCXNHNDsukgkFN02rV3m6hvR2Kd0vtA+nKKsWn +oqkJSAZGKrByhVUqKBVx+WR/IHT82O3W7p4RJIhEoNwsncOA0sgG8QRKxiLxVqm+DBSQLy8tbN9W +n7hJjy33p86W+4dFs1mqrZ697QlKzP5zZweCpxmhoSdXSxM3h1OLdreAU9FcaRE8VLq03Jw+1ps/ +t7p1+/L65Xx1O5FbkqTs4WO3NrrrLp8YpBIIESc5wN5ZLTYLgBCKDSg2urN7LpebQsEnitVEdl6P +zQBzhaLT2ep2JNKZnj+RKs5D6gLkkkwSQFKWy6XKYq21QnHJIBpG8Qikt2p0QrFpQWsn80vR5FQ8 +MRmNtFk21env5Zvbotll5dr120qmH4lzYmNm+WbZaHgCIeBHMdSq947U+odqvYPN/mFermeyU6fP +30dRYVaqpmvbUBSV3pHFQ3fOrJ1NgVAkEhcuPzA9v+uyDGkkFJ6j+QxCGi6/CN5KlKssnwdFSgs5 +PtRJFFZyjQNQsNZCTcRkuYwZrtqdhMcnWPuphZqg9XCqSnMgaWp2J42gkmYUjERDj7cTxUWwRaLe +SmTn9EhXkrOV0uzi1rlofpoW87RQ4JWqqvekUN9ILKQqWySfATrOFhbK7e1Se6vU3aXVqp8IX0/X +ST8mJ5OtvRP3bp94oNg+JGqNAArRMMGbW7t+3PLoKOJy0jSTBGrW410l2jZSgyAVAVTpTh+H2aS4 +TCw9U+sfA1Qs1JYVvUSyEZdXsNlpl1sYtyM2B6mb7Xp3r9jcq06c0TPz4IV9iCyp5Xx5IxSeRMk8 +iHaSTyNkuNpaq/W2PYgCF2CYA4yIBVGdEku4WAMMtO5XqFVZq3v8SqG6NbN6SyK7nCvOt/o74eQM +TJyulo4evTWWqNk9rJmey1R3mlNnB/MXQ5FpgisjZEKSC8eP3pZK9QJBI1NYmF48U2vvJLJLiewq +yRZisX5v4jCChsOR7vLW7Z3ps5H4rKK21FCb4oow0nRhjhNTMFMEGQ0nBnq03+ofml45z/Alp4NW +xeT973sqFKp5/SGCyfBSmZeq0eRCe/LkzNJ5UOyZdHdm9QwjFb0B0R8QUEz3+UIejxYMRJCgdW9z +YelMIr/o9oOnlrzBkMcfcnlNiq1ycmvMxty4zwNeW1Z7I6MBa22bVwDlyckVmssJbGZj7Xy0MOlB +pQBhBPEIZLUc6spaiyDDtnEMx6Kq2eND7UgKCmcmiKWBgt0eiSAinJCkaCOR6inhlqA3jdRsubNj +RNqxaOvA9vmZ5WMkF8ZIM5GZ7E4emZg9lbHsxgSv1oNEFOKZyc0BoTM88MX27Orl7vSJzb07V3du +4+R0MdfZO3olU54FunFbjw6tG2vh2Ew8BZ497fKoFJ32I6rLRTFcotDcnFq90J48DPZq+/D9g7mz +iUR/bfWmzuRRViqQXBoCAufxIYYid2kq57IeaLIkHZG0IihqNT4dILMYkwPDDiXAiIUAplNsutLY +i6UsHGZ4S0U4nEwgqAlCwTYWGBlxWygR7mVLa8X6ZgzkNxFD8Eilsd2ZPA6FgFFRkA== + + + AenSRiwzb7VPYWLeAMQ8Fk72GTFHMOnr4j9vxKZL9a3e5EmGK3h9MoqahtmEWoZ6Z/g8aBUwy6o5 +oOm83xciqDgvVzA6i9F5xejVe4dnli9OLt6cq2wAF9gchMfLur20P6gQdEqL9pO5eYiDLOVVrTQ2 +TsIvoXwA1TmxiBNJgkzRdNbvESfay6fP3edH5aEhp8uB40hIAZlktAIB3W6jeDb58r/8YH7uwPh4 +MBiQjCicYd6MLqSy66ncqtUsYhwPhzugo8bGMQisD4QW1B2X5OScFiqtrp3INKY8KIezZijWUCI1 +ToUZScEA/V4pGulpZgu4DCFMiLnHLyOYiZMJXioxVtCi2zsX8rUFJVwjxSzKRDHSkNRsBuyeVgwG +RUXKlmpLhfKcHCr5UXXcSQP8grmLZ1fC8QFUiqjVMpXNifkTIFSy5VnFLPsxsdOd3zt5WVDTw2Mo +QZc4tavofVEuQ3xcPg0kayq/yikpj4cQpWSptd6ZOTq/fq4/f7LW3dIjjWi0durU5cOnbh9zUCiR +5KSGILfM6CTL5P1+zQeTiOkYbsAsQG5zoSYjt3mtly7t5GuHUCrpcNOKlo0meqyQgPGCLqWZDE1n +aDLt96rjIz6nLYAEZYpJKKEGODVQFx6fyotlJdQSlLLTwyXz04nSkp6cJPkkmCZ/QFW1cqWxBfZw +3IbbbATFZKF4Y8npYmUjHB1c3wJDYHgkk18YG0dpLqFHWqXWFh9q4kza7RVdbg54MIgbPkRXwv3G +4GRv9nRr4kgqv0zQBbfPgMjA9bg9lM/Pk3TcTAym1y82ByfN2AzN5+DkASxECSlaSLJCVlGb8eRM +MjUvgIIiIxyXHB1HRkf8bgfu9zAEZrqcrLWY0E5JQu7E0cupSHVsJEDiEcVo01yeZQskmUCxiM1G ++31aOjVLURmayzhchNcPNWuaccvyN2dWs83JTGOiPphfPHBk7ejJ/uqOHC/ScsqMdVS1Zpodkorb +XaTPzxGEJkqpkFkxYjVJz8lmPlXsnL98//z2iVSlRwhRSkqGk9Vqf9Es9T1BHv4+l+2ZkYrdgdAM +IA8oHyFTWCp1DmuJGYSOCnIsVe5piaqWKFFK3EeqpBgOpTLNhYVMdwYTwxhjWrfHmbjbx4+Mulwe +GhI7npmp9/Y4JYYTPCuaarRE8oagJZRIgVGSZqLan1me3dwNpSsBUlOMZijcv75PQRge9owMez1u +LpWZjiVB5ED5qFDIieKSGh2AS0KZpB83UdqIpCu8FncjrBcTaSlVbG7gZMpup0eHvUEvzxAmTUYR +RPN4BaeH9yOaqJS1+ABjM0AcKB7aOXJ+eeeUnqyMuxGnn5eNth6dwMj4yIh/dDRgsxNBJIRiYbvD +6oTgdIksD5TaiaZm9XBfkPK7Ry+sbB/LVCdwNmxzE6AQ5EiVUXMeRKA4M1OZZ8Q8xecgpYGjMTLX +6JwYzJ7XjKbdiUNq0Ww8kuwJapaTC4JckpSirBcLzcVCe8mIV+PpbiIzl84vR2KTtjHixhts+/d7 +SCph6A2Pixra7xgZ9rkcgiiUSuXVTHaJonPj4+TYKIKgKitl9o94h0a9I2NBii2lctvxxBJNZl1O +QdHKopTI55tLywe2to+duXD1voc/8OjTT3/qhc9987vffuutd/72H//57r/9+dUf/fz2ex5tTmzB +tY1fXwNGYJEsaN1sq1YeNDsLg8mFtc3dUzdduP/hD9z54COX7rv/+C1Xzt927fb3feCuux/+8otf +ef6VV9YPHNk6cKpYnQIlgOK6HCqqRoXmo6qaLFe6M3PLaxvbx8+cunzXHe977ANPfvITl+5/8Oxt +91576ImPfe4zL3/ja1//3g+/8q3vfugTn1s5cFxUUwimeLw0jsphoxxP1CTFjKcK/cmF5c3Ds6sH +WpMzU0trcxt7O8fOPPHUR37+2i9++7t3XvrmNy/dfs/E1EYi2fR4eI9T9HkUHDUT8V65vEQQpsNB +8lysO1hr9Jdy1alksZerTx04evHytffd9/Bjz7/00r2PPH77Ax+49sgTWqQCUgrgzu1keCYt8EVJ +rgliHieMcKySzNaLlVajMze3dPDYmauPfvDpJ5566lvf+/6v3nzrK9/69oVbr80tHipXZjgh4/Nr +Xp8EEEQzcVCzcEKXi0fRcCwxqLbXE7luItc6ce6WD33qU49/7KN3vu+B+z/w5B33PHj1rvseeOyD +X/nO9z767LN33Xv/8Qu3sWLG6+U9boaiTEWrRqITklhKJLuhUCEebzaaC9sHT0/Pzhw/ddNNF69c +vv3OF7705T/86S//9t5f/vTen998++2nnvlksTgxMoqOjpJQdOHwVDa76rDzdhse8PECnyaptD+g +BwIKSYVpJppON/f2Tl24cueJ81fvuO+hxz/89JHjN/dnj9W7BwQxa61l/R8ejjK69amNlZ3Tx05f +vXTxQ09+4OWXXvzVG79+5/e/e/3Xv3zzzTf/6x//+N0f/vUr//L1pz/+ya1DN5Wam76AGfCFIuDK +pUQynO6Ahdg9efammy9fvfXxxx9/5Wtf/+q3vvPZL734zLOf+vq3v/3ab3774stf/d53Xv3HP/7x +0tdf/dDHP3/83G2JdC9fnO0MNvLVKc3IZjPlxfm5m8+ffOiBuz72sQ999guf/tb3vvXWu+9+77Wf +f+XVV7//s1/8+c9/+T//9//+5T/gSv7wvZ/+9IHHn2pPbpjRJgAmgYtRI1Urt9fW1uHY2d27evvt +H/7o08+9+PlPfOEzT3/2M8+99OJPXvvZr3/zqz/+++//+3//91u/e/eZj3/qwqU7c/kJkS3QeCZs +9nPF1SBiIH7RUFIA3Hu7h+6489rDjz3+8FMffujJp1762jd//IvXfvr6a3/5+1/++h//+Zvf/u53 +v//9S1/5xu6hS5ncLMcVQ1qH5fJmvGdE6q3m3PLy9pGjJ+9/332PPfXBjz372Rdefvknr//yV799 +67U33/zNO2//+a/v/a//97+hWn/8818//8WvZ4vTDhcDnOh2c05rhaRCkHFFLeayna3tQ/c99OB9 +jz70iS88+9M3fvn6m7/5xg+++/I3v/bWu2+//ft3fvHGa3/685/+v//zv3/37juffeG58xdvTWVa +NA16G3U68UBA5NlYuTg9Pbl+9PCZu+5+4OHHHvvyV1/62a9++d2f/PDr3/327//0x7//13+9/e7b +b739xj/+5z9+8Ztfve+RRzv9tXx5WQk13W5r8fP4GMaSYZ6JhI1SpTIDmqTbmz147NR973/o8899 +/rU3fvXOH/7wte9865dv/uZ//fd///nvf//8i1985PFHb7/zXsNosGyZwdVBa3pzefumoyduu+Xc +vXfd8uSj937za1/893/7HWT0W2//+pe//NEXv/SpW2+9sLa2lsk3zFgbQUy/T6KJEE+phqzXcqVD +B3bvvnb3gw+97+FHHvrUJ5758U9+9MMf/+iVr7386qvf/vNf//qzX73+wovPf/HLX7zltruX1o41 +O8uynImFq/liL5OtJ5Ol+emVrbWNg1ur91w5/y+vfPHrX3/pO9/9+ltv/+ZPf/v7a79587Vf/+rd +d3/7H//5t3f//d1vfv8b9z9yz9L6gUiiLsoZQUrIglkp1OdnV06dPHv82PFjhw7efcfVl156/o03 +fv7mO7/90WuvffO73/jVmz//1z+8/fY7b/zuHSiW17/00otXb7tWbc7hmIGjRkirxhJTJBFjKSOi +peuF2u7m6hPvf+Brr3z51e9/97kvP/+z13763l/+/Pf//Mcbb/38vT/9/vU3fvbCC5967oXPHj55 +XjPLIIcArGS1ZEYbkWh1MDE/Nz1//OixDz312Gc++8kvvPC5L375uZ/94if/8T//61/f+9Nrv37t ++z/42p/f+8Pv/vDuS1995YnHn2y2VwLBEBg3p53yuPiAX+W5dLU8V8x3Du7sPfHBxz/9hU9/7ksv +/PT1n7/3tz+/9/e//eT1n7759hvv/fnf/+2Pv3/tlz/+7W9f+8VrP3jqQ49dufW2VLrBC1GPF4fU +UrWcoedj4fLq4uaDDzz4la9+9aev/ex7P/zOu//69nt/fe/td9/59W/f/Nvf/wLn+eGPvvmTn736 +i9d/9NRTT546f+vawYu8XBgdxbxuyetm0QDndqAkKvU6szedOfu+Bx94/stf/OLLMJtf+MlPv/+f +//M/f//HP/wUyu4XP4GJ+uxzn7x06ebN9T0z3CyVN3Qx3ix3aqV6MZ2dnOotry7OzvQPbM5eu+PU +ww9fueP2UxfPHy0VkyFVoAg6EKCQAO+040475nZiRFCIyvFSvNSptCc67d3tjZ0Da0vzvTOnNu6/ +98wjD95y69Wbb7vjttMXzg1mZs1wSpSyZhS0d9HnYQJeBkc4EmVAuBw/dHZ7+2A2kWzlUoc25m45 +f+SB+y4/8cS173zjS78EuHnz9bd/98tnP//0uZtPTM5O6UZcC+VIsK5BEUEkkTOPHjxz9uzVenOy +XG7MdDtbC1PnTmw/+7H3f/fVV9586413//Wt737/la++/NkvP//RT37kvsceuHRkZ7vVmtLDZY+H +xXHdF5DH7eBrUIeD8LpJhVGK8ejB1cVH7rzllReeffmrz7/04tM//8m//OUvf/jC5z9824VDR7cX +uo1msVjFMNblRClShwNBFThIQmEIPqonGqXWxtzS1dOHn3rs3k9//NF/efnZN9748b/98Z2//u2P +r//8a5985qErl4/VqwUUYZCgSuARpwMkjbVEeXw0iAfkqJaPa+mZiamVxfmTJ4/ecvHcHVcv3nfn +5Rc//8x3vv3yl1749HPPfvgzH3v0y8994tF7bj29t5NNVUhK9foZv5/HUI1mIul0L6Rl8CAbN5K7 +6wfuvvOuZz/x0Y88+YG7b7v1mScf+9EPXn31Oy9/4N7zH33ojmcevffms8d21pf7zV4m02n3dw2z +NTaG2sZJFAn7vLzbgSE+Ohsr7q1t3H3rpS+9+NmXXn7+mY88+tTj9z/37NM/+sEPP/OJT9xz9crW +ylqlVGUpBUVkj1dyOSiXPeD3koifJlBO07LJZLPdmp2bX6c4MRAEbcl4fYzHQwcDIo6HXC5yaL/N +MR5EfBKOqkEfTyIyZR08Q4lRM2uEkkEfGvAFg36MoQSaljk54wkoNgfmdtGotU9Bc7ixkVFwtQgW +FAJeGg3wkgImxWRZRRUUMogIJJWJRoq59NRE79CRY8trq/F4HObR4URtDgRMB0hlt5t3OGmnixKE +hK4XGMbEMIljtIgWBjsa0UKZeDQVTxSKlcHUnKmbyXCkV6/XshmdlVAfA64ZRUM0HTOiHZJJ7tvv +BLWjSkWJTRtirJEtleKpVEhLaKGtpeV+PVdORyZa9USswDIKyxgkmQwGNIcNt48HbWO+8VHP2Kj/ +n52saCoh87lydpCOFEvx3LWrt5w8eKCaig1qlXquMNdpzrcr+UQh6MOHh8ZHhz32cQ== + + + dHi/c3jIbRtHAbsCPpnCTEXMhMFmRTPJeE5g1aA3KDJKwijoUjyfLE00p6daUwrHp8yELkRIRHA5 +qZFxfGSccHsVUSzKcoGmzYCfDfqgcsORcBWKWuDS9cbmwuqFyeljshhFPF5TlNNmQuNDWBAAE4Ms +EqRio3tMDXVtNvKG/2cUhCiGhj1ulkQUFpcjSiQdTibMaCaWB/nOBnEeY1U+qUk5QyuaRsPthkqR +zEhLkCv7bnBAqoyO+pwOPOBlCSLGcZlifnLv2G2egOT2gLZMMmyO4wvgK3E84vXJEAEkYN0rGxpy +wDEy6hsfQxG/RBFRTa0KQp6jEyQVtRpJOQm7E/UjIX8gDDFnyCQaDI3bAm4P6fHxIGxwRPJ5aZeL +wqk4LWZFtSDLWZ+P8PsIEhdRhCdJTZDSAVQB74/hMSilfdbmPi9oXb9fRVEdwzWSMlxu2umkfD7B +bkfdbsLlwnFUA48sCjmKijNsGkFUVYrxgjE8Yh8Z8vg9MkXGgNZJOqeZUziRHhvDQAP7fdz4WGB8 +xOu2+Z3jXue4J+ilQnKWZ3QCFQg05HZL4L5tduqfW8udDh5FTJ9HsI+hLmunEm93Ch6/7nRLwHEE +YeRz3b2dE+l4wTHm5DFZIMI8YZAwHMCoIffYaBALhsdGAzfeMDo64sMQ3eGg4YCS9/oVuB4GMj/c +CQZVuCpVK6ez85pWM9UCGVT8HsbvpiY7GwxpANzBqRAii7MVhq9KcgXFI26f5IWKvt78VlZbqjmZ +yG5kimvNiZNaeMJmA47jC+lu0C/tu9E2bnW0kDSlMZg80WgfxonU0H7v+Igvn5pAEX3/kBdm0+lk +kEBIliqp9FwsOumyU6NDbswPpMk77KTPI/l9IQSNgWuGr9P03vBwYGTUMzrmHhv3jI95/eBbiThj +3bieJIh4IgpaaIrlMzSTCQYNBI0Q1rJ2NYCEPX513z7b0JATvtRuo3DEZKkUy2Yg/Yq5hXJtc3jE +PzLigUknmZSkdgS5DqcN+GWeNhv1eZpLjY76x8Z8NlvA75fiqcVQdFJUazQdTyQqupnz+lj4rMMB +gBnyBSK82Mjkd4MwEWNBnweMdBNO5XCSNjsKWecPhnixIPBlm9UYjQAoQxANEDIYDEHE3G4Bx2Ja +qE4wsdExn9eryHJDUWsEmfQGTJzKO1zS2DgO6ed0EvusnQtO+5jfNuZ32lEc1aHcggEVQNLlEm+8 +3u7D45F9PtPjsXoOEETSHzAcdpAKmi8QsjrpjZFjdg5iZYTb8XQ/iGow0vFRP4kYkIFD+5xD1l51 +DMy7z6uGQwO/1xgbQ+Cw2bDhIY/NTkKErQUGWCxkDPTIrMer0HRYM2o4nYDcdo6TI9b69gAWCFUL +qwwVGRvxUUSYYotub8jpVlxWt6iMok+IasvnD2GYDial0joUTS2gWBIjUk6XNDoaUIRMv3cECej7 +97kwIkaSKZ7JaHIxGAiBet9/o8Ntx+anD+F4dGycxIl4AI3gZFpWOqnsGs9XbWOkfZwIBhQojdER +r9/Lk0ScFWqs0JC1HssVrRaUAVkQo7QYGx0P2B2M1QWUL4mhuhmdqHd3k7lpio2zYp5mc4rekvUu +weQ9gbDz+v5WKHaP9/oe/6EgjkZRNBoI6gKfl9Ta8EjASoOAiJJR2ejgXM7hEeDHRLS8vHqMV8pj +EEOfhKCQ6jp4Ipgat5sFfjy4c3J2aRdSKwCwhicoKkeSWY6vCFILsp2lo3qo5POxw8MemItgUCGo +OCfVzPisog0wNJZKToaMGozFomAPhyA6AAvHFaAS/X6NQvVKcZ6kkzCDY6PI+Bjl9Zlur+H2aEak +D6Jr/5AbHAoB1O8g3C4y4JfGYdKtFpEhkkwDCLg9cFVxJBj1+kIjYwG7kwlgKVXvprIzDJ91ugSr +v5nP8PhCIO9JKg7VMTpGsEyBIpL7brAN7QP9oSlKj+MqPq9u9V4eJcBNsEwcrsfvlZwuznV9IYrX +p1otTRCITHh69mi1tRTEdLhymsqSeILEkwSe9Ho1+BSwqt/LuVwAm9ZibF8wFk+vLW7cU2rsuX0a +BIHl0whqNUwL+OPWBiutpofKklAS+BKORVxOaw2q3Ups58iwb2wkODxkMZHXw2taOYiYkKssl7GD +/HACxfDW1rN98JeI3x8K+EM3/I9RuAAsKGOoMTbOjo7zI2PsvqHg/mEUZOTO1rnZ9TMjdtzm4kiu +Kpkz0fx6urIZik+yQn6itXbiwr1BKmL3sHY37w1Eg2iS5RqqMW93K4AJfq9y3VDIFJWiqRSGQUCi +QSwGSIKRGsVHcTaFUHFKKAhaGaPiJJeTjX40tcJLVYBuhksEMGsjmAxSRymghO5HNWBeHLcwamjY +PTTsdTgZSD+aTol8niSBbTHgFIBo4HHAdrcv5EdTBF1lhaoglkW5CsMMh6seL2uzIXAqwBAMTxBk +yghVD2ydY7nkyGhgfBwJBkyCyNB0gWaKGJmE0IHtPXb0cjLdtVJ3HPF7BNBUHF+CMvR6JABVUSnj +ZHh41Dc6FrQ7CI9PxMiEHGoEUJ1mU3OrpyW9duN+9403utwuEUHDGBZTtXo0NuF2CeMjAQLRKCax +f8h//QjA4fdHNK0VCXc4PiOIBY9PGh3HHC7G7RUxPAlfXaxtT62cpznIMbHV2SjVNgMBfdxGjY7i +tnHK5xVJXAfGHBn24kQ0npqPpuaDWNzafuVVWaWWq+91Zk4KcgnAiqAKEHOKSbtctMfNOGzk9Y1+ +GvD7CKg+O2ltMHELSFAP+BS3kxu3+k7QXn9oeeW8ImVvvNE+OooCiipSC0fTGJr0eIAu/S4nCycc +2m932DHQKlAUHp/GyjWQKMlkTw1XxsAfBbUgGcfYTCgxTQoFlIorWnVz4+ZTVx4OkmEENyWtboan +IuGpRGJOMnrD4wRNRKf7h0SptH8/wAgJmYyhiZDeHcyeK9W3YrHa0RNXaalA8plYdjpdWcvWNgrN +nXz7sBDqYFQsEak//thHB4uHoST9ftHnl/1Bg2aLkdg8L9ZdVjd4DUDDbzXPSaF4JohlCLKghXqa +2XV7hdFRL2KtCLJ2Z/iCBorF4aDprCAWc4UlQciaRkUPdwKIwQkl2ehySi1IJt1+ze1V4WpBNV3f +hKvSbN4I92gyCUJR0/MBRA4GZJIIQ145HWwgaOBEDOQTSkQJJs0IOaBgqGK7nQD1bhvHKDJBMynV +aNWmTiJMetRmdckAkAwiGmgzSD+3VwbGoUBtIlDa6I37PEPDAUgPr0cjiALP10Cf8GKVE8okk0GI +GMVlQdx6rcZTYYbL8UrF7eJ4OnLl8gOilAbQGB0N+nwK0DFFxnHcBK3lcrEsk2KYBEGE4WLi6alU +eVkwW3pyihEKGBEN6Q0UDY+OILZx2u8zMCzFsXWBb3s8xriNxRAzEumC8gEtDeMaGfYPD/nh8nA8 +FzL7yfQ8WAwb2BZrNxkX8IWsTWF2wes3eKkSjg9A04p8UtXidoff7sScLtZqIBO0HrwCbbl8IiMV +MDbpRXU9MSWZvUhiptU71po8HS8ssGwymeybiR5BQiVqQVQB3B6x4XDOWnWdl6w+OcGATlrRi4li +oVBZjSQnstnJk2fvpuUco2SL7c364Ehj6kiusZkqr5NcnmRi/fbyS1/65vGb7/L4BRTReL4giLV4 +ciVbOMBwFUWpWUWKhK2NwGiaFduKORvP7tS6N5nJeR/4TUTR9VoAMR1uwQ4OFI/wUgk0G8lkVbNb +qSxevfWR6aWbXB7wPgUjMa3FZjitq5rTZnQBlInHJ5Ns9noXHdPa4+AJuexW6wCfV07G+6KYh9y2 +2WgSj2hqmeZynFSVQs1SfTNdXAliptsDqIjZbQToOkmtxHILmcYeKVZYuSppHdBvDgduPSs0mvDB +cGw6npiFVBmy2rkH4VsAARwOsCp5lisxXJFirYY2tFDm1RYjVaGQ7deb4aN4AkYkq2XTqE1ObKCo +DPkMYCXwIBVSkGCjY8jwsJfnshybhG+02xCaNBOpbiTVI/msFu7TfIlmciG9RdEpq5OV1TU3EQiG +r3cD0BxWE7m4LJbTqWngBZ9XCgRUJ/D4CEISKQxPkXQGYB8wDWjF4xVvuGFs2Oq0A+IqxXF5US7B +2IFwI+EW+PLhYbvdDkwhwqS4APPRKHglMzZT6RwNRXpmcsCH6pLZliPdSGZWDLVBXQyqK/ff9dTE +4lHQ52BeAmBS/KoglVW9pWgtu5PyOCkMi7rc4tgY4fXxINTDiUGqsJzILxC0qWjZam/TWmws5ay9 +BtF+prjc7OxOzZ3cOXqNEWJ+hNf1htU3VSjDVQUgbfCwEe1Hc3Munzw6hoWjc42J083pk5HsAskW +/FjcEwAsKmQLC6JWJdg0xaVZAeRrTTEbwONqtBHNdOrdlWh2gGFKo7U+tXKx0j/BSA1ObsLhcEv9 +zuat1z6YyQ/G7SToTwQtoWgxkVjOFg7GkguWiuMySqgKMmYchKiTMuJTMwtnT55/pNTcQfDI2trJ +mdkjUOMcn8pWl4vdvVLvyOTSpZXdB/PVw6BCScoUlDxGR0HFAW9iVM5hNb4QHU7a2h4+hvp8QP26 +x2tt4QwSKVZtxcpbenolSKSDmKZoZU4qAo5RbIaXCrLRyJSXtXALNAxgC1gzu532WCscaL9f9vnV +sXHMbgd3rDhsQQ94aiIMLK9HB+HkHMmVCKYgh/rl1pF0ftPhFIaH/UEkRrMljEjzQgmxpHKMpCFV +yoCEJBmz26ynmVbHHh+YuzTD5HWjDQb2hhtGbWPI+GhwbCQAUAbOgmHBiadpJk/gMZcDOFpwWHiO +gMwjmTQnllKFxWR+aWry6O3XPmzG2jSfydW2o2mYuFa7d6Q3OJ6pbDh80tgYSlIJEngTMQW+SNJp +K53GIaUzmcIsRkZhvDyfUc2WER8kistaZEJRSpMTB67e+xGPX4IQJfMrBavwlwqNrXx9K5ycCSCa +JAEltewOsPYkhkchwWKpxcUDt7ZmTvhR0+mgcDLiCWh2FzdmJwBkeKWZKm4vbtwWjvXMaDdVnEMp +c8yOILihR9tzGzdduffJM1ce6c4dZ+VcOlbZOXhJCTdG7RRCxhO52WRhgVPaqfxyf/qAEsq7PWqm +tGNEZwkqJ0oNXq55/AoQbrG8VGttwlWBAQeJLmk1OVRnpYLDI3r9Sm/mULYy70UlI9rszh6ZXDvd +nNoptbejmTlWLjBM9OOfeun85XsRQgNxaETni50TueZhSe3Z7CzMUbe1urVz5cZ9YFpDgtZN1Q80 +Fs62Fy+E86seNBLSy09/4osHds+P20hwtXpkUOke2znxYGvitNU4btglsFGKSoyMoeN2CjKW5qqc +1AJ3BjbB46IIXCepmC+gQRUXWnv1qZMLu3etHL6/PXWKYfP79we6vT3d7DqsVqsofAVEAGiiPX02 +nl70WN0/BNCrHAveRwFnAXrM4TFA0AZQqws3qPch0D+jKBY0An6VwOMgs4OBCHCl3w== + + + B3peB/DEcRWm0gnJ6ZNQ0gSPE0lOFRurKBVmxUKxtZepHoikl5q9o2Z8xmqHa6cwRBGljD8IkZdc +VgNP0WbjvN6wCpZTKABgCmzGCFcDqOQLiteXgaXz1fX+wk2D1Qssk+h2N0uN1SBpgPqKZmb1+CQt +VPKVjXrvsBmfAJXCcoVkZj4cm4jEB3q8z0g1PxJlWajc+NCIf/9IwOfXUpn5RHY5nl8zEzM4GQOw +ypYXBK3kC2qCXAECqjZXDp+87czFBxY2bqKEVKuxcNu1x5JZq7N3rrx1+PT773jos1Nbd4nmFELG +YGpoMp3JLdmtPm9Y0OoTaLg8EorHNLNv9QewOnKzwWDY7RH8iImQSUlvmvHpdHlFNeuN9uLhE1dV +vY5TkSAm42wa47KsnM9Xlw6duS+Vn7RujyB6vX8SaFTWWw6X5HBxgYCSSU50ujtAiwgSpvg8LeQo +vqiYk0p0Ilma788fv3Dtg93Zo8OjRBCLhiIDSWsTdBo81MgIBZAiiwVByNy4z+lw85I+iCTXZX2g +6BMgh8Brk5QFlUFU3zx85dwdj64fuXWwdN5IzALUj4yB96Gv3PnRbHERpGYwGNWMbiAYo+h8KrcI +3hbqyOflcrmByKfANt4IHnCMJPlaOLsRy20ksmsYmvb7dEVpBP3G8H7X6Ah2vQkqAV4SRJHLZe0A +6g42Qc3CtVmDRUOQG2p0RjSshcGQWqJRx60lamlB7bIy4FgZR8MsFSEJE1IIAwhFUiRRgiOIZIJo +CmDW6WQrxaVUfmB11RtHwAtzYrXYOFAfHM3WFg0td+H8A/MrJ72IHM/OLmxenV65XG4dHsydnVg8 +JxmtMRuhhppgdYNAuEEJQopTRVHuQj5wcnEYQNh69004ZDRJNoNSSYoroGSal63dkRSfpfmcEenR +bFLgE/XOemvqcGPqUL6+uLB6ZnL+uBKqGZF2rbNb7x5oT+1o8QkPErPaPruFiNHO5hZHx4mRUYzl +S4oxIWsd0EucUANA9rhFgoj5rRaUGM0VIsnZ7tyZSudIPDOrKPndvTPv/+AngTchhghqiGq31Ng9 +eOLec7c/1Z47Banr8nLRVCcU63sD2vWXDeHjDjaIhMGYBIKmx8OzfDZg9SXG3V6NFRvx7OLOiTvu +euTTZ+98OlZctblEhs9BKLyBEMwUsBiGpgShxvE1MDhDwz6AJj06S1qd4SUwQTB3QNYyiHY8DAgw +Mb3bHWwlMpNmYpYWWwRXovgyUEln5gJCpOwOQQtPilrN6q5gZz1ezepvP4wEglq+uBTwS/tvHN13 +w5gbImBtgp5ipXoAjQyN0C6vAa5qbNS6A+Z0CC6X7HLL4KEQJGK10cYi6fIyhYUz6QkMN20OEoYQ +y61rsQVJ78eL61BHwLaidZ+qgdNZGB1ofoBKl5NzOXmvWwLbAmH3uATQpZDq19sScrredFntqnww +ETYnC1dC83nRemVGJRKt11sbIb3OsqnJ+ZPTq2ervW01UqPYKEqG/Yjh86mKUsFR3e1iQBlK6mQ6 +f7DSPDm5cDloNX+maSoRMlsgjZxuFuy5HyyD2tWMPqhfVsi1e5uN5hpJ6FhQyhVmlrZvOXT2gaNn +77t630er3T1BKF88de3eBz7Iy9kAqgfwOA2WIbPSnjg5u3gRQdP7hvzDgCF4UgtPKFDISBSq2z5O +gdgGL+ax3nkkyqGWarRlUHdUEsNjAp/NFecG62dJvuDxqMXSZqN1Ip1dnFk4Obd2lhELLjcf0gp3 +P/yMGumNjJBen8EKoMn7JFN0exWQ+kAfRqQLDs7hojm+EE3OJnIL3enDJ26+b2XnEiNXdL116vQd +4Ps8PkXV2/HUbDq7lMyssHzTeh+Wg6TICAgt4LXhEdDPoVRhpdrfSxaWQKEhqBaLt11u1uFiILWg +CDaO3TdYvVybPEGw+X37g1gwcvymB0k+BYwACe/2hX2BhKROZIs7udLesHWPy+l2EQQZGR4JXH+5 +m+AFt04XtfAMJzbgGx02NBiUwCY77EwAiRA0+Nn63Pq5k1ce9cCImGQgEAoErNVritFSwn09uWik +VzAmg2ORQn6eZsF6yxzgPJcTxBLPA1KlvB4JvP/QkGN42DM05Bmzup0T11uWCV63iqNRDAm5XRTP +52S9HstMxXKzpfaOHpsALxyJ9YxoBadVktFI2uD5NCdkVa0RDk/6QNa6OZowETTkdFEgUFkmTZBW +iz+/32CoLDhr8ERQ7F6fBOAJhDVuY4CaWa6YTM+qeg1FVQJTQ2ZeDedixX5jemdi4USxspzPz69v +nMtXZgg6Go71s5UtXmtFUnPp0qZizPj9iUAgIkkljs+AuHKCN7Qz18VDiCJS4C8oqoAiJqjr4VHX +viG7zyfpRjcSmy9Udhd3bgcNpiqFzQMXjcQA4Mvl5nzXN3dQVCYc6ZUa6yPj1NgowTElQEW7kxka +8cHhdHMsnw+ZXQRS3c9D6ZFk1O3mQch5gorPWgWabXUOzSycAM8liNlGZ5ei016P6LDRtuvNvR12 +kqIiLheF4rrXHyKprB7ui3AxZpsRS6xcbvV3OSHHsPFmZ73W24bfIFTGEwx5A6ooV80YOO51q9EQ +GECtacbmjch8IrcsKk27Q4Xcc9jpdmNpZnrbahM3hnp8KqfUEqW1cvuQHOoMDQeNUDWb7YyN+vbv +cwIagDAIR7uinIdCcNppr1eDg+NzrJinmAT4slRpI5Ffbw7OpIobWqTjQyQtVGm092StFkQjLncI +TKvLelkeabPh4+PY2Dj6z/cy/LMbHo4mEX+YCIajofL8whGciTJCqjl96OiFDxy75fH2wlklOkky +CV3JLM/tLCyclpSKxye4PHzAetpookgobFRRRHG7CVXOyGIGDAuKJfzBpMOpXk9gzGk9syNGRgAb +UUBRcDe8UOe4KvgIP6KyXKLWWZpeOLC8fWb98OWNvUu7x2+fXjqdrm2gVLRcmtneOsfyca+f56W8 +pDQppiopPQRJeL0qcDGYa79XCfgNBIkjgYgXJJZPgiCzdJqXijQblZVsEFUxIoJTKYxKcUpFM2q1 ++vKJ03eJakkQc+AsaDYrqeVobFpV2xSdBTEcCdfLxQWH1Qfba3dwPr8hiFWWL7JcHsfCul4B1IV/ +BR0FljyRWWoNjnVnj2/u3QH/D7Xfbq+ubZ3/Z3O5YEBFraU4VMAnMkwMQ9RiZZYXMwBikHhQboJa +ixWWG3Nn13bujMX766vHvvqtH4ejfZtdopgaeIp8ee38lcfO3PKEGOrtH0Kgani+AN8CZTVq9Rik +HQ5NVnohcyArlYBfBuHkdrFuN+dwsXY3N2rnx6wXeSia3uKlrNNNgYl2OAibDbVZa89YxFrOAbwf +w6ksr4AzqoDhypaXItnJWG4u3zxgpucFow0KudXe2Thwp2o07FYLbqv5CUNlUDTq86pAiMCSVmdy +6+VolDV2j+Zzy1hACxvFdn9Fj9SrjaWFA+eztflsbSmaX2SUFkomzVB5a+3M8uoV5PpLNNweliAS +HF+mmLQoFgkyLgqZXG4Sx3Xw2j5AD7rCsDWSzjmuN3+2ZsFOQo0DrVx/Gi74/DrFJnglD/Nbqy99 +5KPPP/fK96YWj8JvADaj6Zn24HC5vj7R3V2YO6xpWU0tKGpFkiuK1sKJnMMuDQ9Zr1gaHQlAarmc +7Lj1DMs3POQeH0Ps4xiGGKFQs9vbXVg5ZXfRoGoC1ov5DEGrpPIrmeK6EmpguNHtbpQqi16rSz+H +YaBIrUdgYMyz6X4xPzU67B8bQTA0Av4uGNDGx0mXC2pKYZiUbjYgMazbg0RSlIvR1EAxGpxQYPky +QHe3sz6Y3LXbGbgMiowCk3pcXNAvkbgZDMjRWJMBjzziRQKgeUxOLMhGUwMAkYoYqmZTtbNnbwd4 +ZLharrCXL+3qeieZHETjPZzKgAiXuGwhOwVlNTTsuf7OgiQvTCws3zW/foeoNEZHcbAMwOxeN3Pj +Pvs+6yUanNOl43gWDBdKRQKY5vHy+/c7/wluNJeJ5xfA9IHXjuVWwskFis0nM9NGvOkjZCVSL3UO +tCePbR26dubS4xfv+Mju8fsYPs1yKZAZgQC4ztC4DR8e9o6NBjxuQFSapJIuq08OA1TidXMEqqKY +ImipZnf1+Nlrg6VDPvgRyDG3XGocBtRVtKoZaQtKzeWVCCaJkRF/QAVIp5gCL1Qr9Z1GB6x622bn +UGAWGlC9TJA5jzdkcyo2l3L9BX8ihoehVN1uBurF6+PMaGNp/fT6zoVSY2lp7fju8VvUcInh4ma8 +p4WbyxtnOoNDKB4JBEVVTa2unshkevApcNBeb8i6lxiI0VQq4FP9XmlsNDhuNcqzmj3CGMfHgiAJ +ItF+IjUdTw4EMbW5dbHZOYBQYS5ULXWPNqfOJPLLmt5cWD5dqS0DTEFAYompWGxK4AtAjg4nNTrq +v/EGu9vBIAELk4eGHaOjiN+nBgIq6CWH9cSEJ7CY0/Kqfn8Q+DQFOiFfWgmFrKdXcD0kHlXlgtXD +bdgHcOp18xii46j1jNs2HnQ5MBIznE4AdnR0HAM5IXIJgQ2LQoJhEpFY55bbHts5dNXrUzEswfNl +4PR0fhkULI6IDKVf7/yM4XjMuh3KFDmmYJigwxMOGyHy0bBeAoVzw412r9+iOVA+Y9absFCbnXB7 +BeCd0RGf3Y6BUAGUA0fj9SmU5bbiGBmj+QKUXq6yqhn53aOX5tduqtTWuoO9ufWb+gsn47l5hkv/ +/yS993dl13kl+A+MyAoIL6ebc873vpxzxMNDzhkFFFCoKqByjiwWWQwiixRFUaJEUVSgkiVbwUGW +rFa0pGlZtnu67XHbnjU9PWvN6p41v825pbWwsApAvffuPWd/+9v7nnO+L5sbyFrx2c4cGYzAyRPu +jiMMdiuDqSqwLblaYzOGmCMjsUiYI+lUpjy/fe7huZtvdsZ3b99+/e7j98xkHyWSOJnFiDQn1qzE +TLVz1Ju/baSmGDbVaG7l62ua3RHVBhDSXp9b31hR+sB9HDsRPHY8eHIEw5kaI4+hZOFZmT6BprKZ +wgJB2UBPpjJj+wc33/7Ml85efpiuLmiJAcOX1rbvLG3dEPUShCm61esNTperi4bRyGZ7gpAA0wGc +L0GmgZ7x+d0eo273nLDqVm9AgDFUThx3WSvop0ShqGo9ki6jWNqyqsurZ5PpNsFYVro/tXZ1/cyD +7uxRuXdW0LvBkJhPTVy49gpC6qNeJORuTgY23y2g5xulobAqsbmZyZ31zWvHjwePH/OC9wdJULMH +YEBQLAG4q1KeXd24CrxwDNIJCoRznCTjKKRqGmD1OKBxhjB5IRvwk36/u3PGM4KCT4mEhVhEHB4K +QDGOYeLADQGkFUoTC+vnZ5YO47n5WmsLMBXDZuZXr5BkJhAQ3Pr/XtrvZaMxk5MaJJUCMTUyHAVM +CHAbDQs4amIw0D8o+NCRoRiQwQwdP/a859jzI88/N3LiuA+gGuRoicvSuFGrziaAcQ== + + + 8GGymA1HJZrL8VrTiAOlvdQaHNY7WwuDtT//q1/unL0NPKOo1FKFGTs1CW5cNSdxJhOOCgzpLC9d +ghBz6KR/dCQQ8CN+HwGYEKhKoGZ5IcUJGQS1Ga6oxbv17mpv8lS5Mn3/3ku3Hr5uJJoEm09mVxKp +xVprb2n70dTC1fHp85rZTTrd0/s3BS0ZgoG1tGJwGuQpWe3xUicc1X0BDpgy4FBG/eKo2wgMBRYJ ++Cw7MWc4U8Cs7e3eGBvfENWikRjLVtbrvbPTSzd3z758+eH7tf5Oo7187tIDMzWlWy1ZrVN0Bvhi +oIoBH8pSOxwVvT434qIxQxS6qjoODD4EWT6vW5OZoXIeDyCZKBCZsVjSrZ8ZVdzlIS6vWU1aSJNM +HIxVFHZEtTm/fHkweRpgo1KbxGmTE5KGXgu6kyiFQlrAL4YDKoE49fJir7t14tlDJBiWgB6AsTgl +VCihDEKvP749ObXL8TmWBYmyoupVQSxQVFzW3MpIOGZXChNgHn0+1OtBAKIwGASCEQkJ3hEMcJpl +lFNJ9zwOS1q9iY3d83d2jx4bqTmcLsXgxMrKhT/74U8KmT4QkD4vSZEpgasJQpsTGqGwCGSGLBXG +pg4su+n3YQBO3mE06COhiIBEJVXMEIQOiJ2hsqMjbpXdEyeAm2DgqBry8VBEA6k/7nQfPv5UIEhh +hEXxWUFvmpmpdHkpW5xanD319rtf6Q02QaJvdE6BtOikpwG0KB4kLyAhGFstv/b6VwWj+vzzQydP +eIZOhkbBHflokFlYyhmrTx1eui8blShQBUKBkXJmop0qDFoT66X2AsEmnMx4sbEpyA3D6hvOgObz +ilbnhYpljlUbS6KWSuQagtoIhlWQFGDM8AVF4HxJMieITeBwETw16uePn4wB0RWBLVnvUmyeY7Ob +61d6/XVZr9jpyUpntzdztLR56+zFxxPLh052YmZu70vf+gvF7gJ1BKiMEytWoq8aE4I4Jik9GDUk +uVRvbfFiyX1KE5D/WBEUfOF4lmbKI+5yNj40HAUYC4UlcBmsWE9kF5pjZyQNzEt6ML5dLC9STKbb +3xifOsUBlxSVUNwBDkjgCz4vC9QgeNtwWI+EtIifA1ke0MXwEKaqNUnO+0AW81Ci1unOXsw3NlWr +G0PtKKQ3WitWvI5gFkakLGc8U5g37YHAg/xoAkQF/BRJmMEAFXAX2sxoRPa62yEk8tnJNZArRSEP +3txKdmdWr6zu3t3Yvbdz5uHOwf1Bf57CgS3VSCLh7u0Muz2bMCzl7tbAHNNoF4oLpl4NeHE4ImGQ +EfSSaEzBIDUcID0jMEnkLGs6AlIeqbkNpI7HQn7e7wP6JA2EK8+XHLuBoCpB2iiuc0IunpucWDi/ +fXBn++DhxNoVhHQpd2LuiFNrGIgUKoviKZLOMUwa6PPB5AZwjseeHw14iGhIDfrBbdKhIBOLMJV8 +Y/vMFUpKhmHNyc0pVhu8c2NqL9PaoqWyIGQuHN5d374ClBUMA94o2PGpqZnzi0uX4skpXqo0K+Of +/dxHrfHTzz/n83ixEGASyLad8UZrVzXHI1F5c/ummegcH4qMeokIyDKoW7NOUGrx9KBcnl5bOzuz +dC6KKrwKhrSj23VBK1SaS/uHL1y48ylKAEl/Pl9fx5lCDDYRPBGOmaGou66dyc9ni/ORmHByKEaS +KdNwPSMci4dC+tAwNTxCRKLiyZFQIEQiqKHbg3hhudDYLja3gWvOpfpP3/ro3JUnwZCgmnUnOzBS +A9XqAd6OQWokIkhipdM7QzOlkRHCfV7tPhtkTpyIInBC07oT45v3Hj6l2SJQkrLe4tVWFE0DnZkt +r6/svqA7rdm507fvv9Ue2w6GZHd7ZNRyC+8jNo67633RMEtiBhDSgaBbIntoGPcFxAhka9ZUubaZ +SHYGE1urp2+fufbqmWuvbJ+/r8d7oZjCcJlyfaU9OA0AIKsl4HYxPImgLlH7PEzAxwW8FKCpYmZa +lavHnvMMD0XDITbkrhczoRBQhiJN5zZ2bgZD0ic+4R8exoFOFuWObg3AfB07FgmG2BgsQ6hM0I5o +VMrdrZnNm+3pi5ze57Sqk50qtTdRPG4YvURm3snMJnNLstWBCXPU5xZEDfq5SJD3eQjAiidOhgES +IFiNIXowKvnDrKSXZaeKsVaiMDG5cqXYXC/WV5pjO9UWMFMFoJ8h9wBLgQXuG4/jRJxmU7yY7bQX +rl5/0bBbJ44HMMxS9SYvlmOw9axqXxwlnFR2guLTgEC8PiAgQWKyBLkM0AtEYCnf2dw805tYhRA5 +X12e37y7c+6Vrb0Hkwtn+zP7drqfdFrvf/SdR2992W0uhtj1zu7C6r1SZb9U2dPMfjgqj3rgZKLJ +CzkwR8dPuEWeRz1iMGyhRD6Znrx+58m9x28D0+oNsMGYAuEJXqnV2+vNzn6lcw5l8gB16fIc4GqE +cHAyg+LJKAS4V+8Mzolaw+OnYdQCfvyZilMBhgEBAsmK43q2MA5kVTAo8kq12Fhvjx+snbo5s3QB +aE5JTN299fg7P/hRu7fo9XE0XQIsyrJVGHHAtAaCPMfmcNweBS47zHHPxooRKqXWzvLuC/nS/Pry +/hc//PrS2uHC1rW1cy92Fq62Zy8u7jzcOH1re+9mqbFSqc798K9//fpbX0QRTRFLktQADEYTSVNv +qWItGtaOH4eBYwVCaOik65ePPec9eTziGkkoKWk9Qa7nC3OSUqb5gqi3ObUpGj3VmQyGBV7OpwuT +7f62pFcKjdWx+aO5rZtz23cn1m7lWjuy3U/GBxcOX9o5c5/i8zRXLtQ3MuU1QZth+fFIxPJ4CGCj +/H4QL9TIs21sETBruAMcX6ownSxOVJqzm2dubx3cObz+0uLWlWJrg5ZqCB4HQoXlChCkBINUJKqx +XLXZ3etPHiWzcxQHJDoXA3knJgNjBYIRB2wptDRzPplZFpQqmFl/kMFJOxBk/AGSYhKy3kjnp0q1 +OfBdNeoUZZXqS63+TrO3kchMZ8uLucqCotcSTuPM2euLGwcwqsVTk/naQjw7rpgdRqgFQhIIDSQm +nj24VSrNgPzl9fKRSDwWS8egdDhqZnOTN2+/MpjcGh1FSTpjpKaTpZXe9NG1e59+8c2P57ceokS2 +XZ87d3iHE1IAY7niytj09eml+5XWBd3uRyEZislXLj2q1tfcPcweErhpCIkDh54sLFZ7+8CqdFpL +k1PbgM9xIsmIZU6u5YtzkwsXat3dRKoPaDOfH8hqZcTt3ot4PBRO5SW1qxv9cFjx+ShRqZRbW5xY +AmqcZFK0kIUQVVXLpcqsKOfGZ88eXH293t/NlGZ5uQiukCLjptU8e/HFtz77jYWVi8BYqVqfpgvh +kBgJUd4ReGTILWg/PEQZ1jiYiOeeGx06GfOMEgEvsAwGyZTB9cdiuqbUQDpGiUR1bHfz8MnZm++M +L14F1qPaWl/fuXv1ztvTs2eu33tzdv1Cqjo9vnQEFFO8vGYlQYq5eeXG06nFI0GtG85EqbmeKy/L +1hSMpf/YbWHoZBRDLRTVQ+5OWgrFbUYocFLJyU4mcoOd/VtX778RL/QLzfnONIjuU5nKWr17bjB7 +I19Zj6EajKq8XCW5vGJ0NGdS1Ce0+BwrtTEsHXHX3WicTOBMPgRZMJ5zS9FSmYDb2iCu6TXYfbJK +PDt4Pt6ZOD+5eKnQ2KS4kiDmehPbmeIAp6xEfnZ2/frRjafb519KluZVu45RKsvaC0uHsp5DCJWV +SyRXdGmTSZGYXSpM2HYT6MaQWxXfbc4CCDMSNeLJQbm6wLDuqQQMA4q9LqoVSS2Vm4tz65czlSUY +s7aXz7z+xmctq4TjVnvsXKt/vlTdMJ1pv/t8BgMW7+a1l9qdtWG3yaxbQ1XWe+nCSqN/ttzeoan4 +vTsvX7l+z+vDQKzlKuvTq7eu3H/v3K1344XVSMzAUPVLH31je/uiPyT+scOIakw6qWWKLg0Pw7Go +2O1tFutrox4iElEg2N1vwEkVOzltxAc8n7l17/XHr33OcboxSBOkqpWYKFSW105dv/7w0/3pI5qr +kmRWlJpBt3l0+PnnPeA2vR4asCtOFIJB/fixYCwiZFITwE6ODgP7wMQgB6TFQFChySzQdWD0ZKNZ +aW02evskV5WVYrt/ujt1AFLG+cO7L7/5fmuwYab7h9c+effJR5tnX11YvfPq02/Or99W9HYpN7t7 +5gU73fUF2VBEBWqNY+KxKBdwuxHJSaveH9viuHQoxEKIxsvlXH2t0t+dXbs6sXykOfXlzaOxuYNc +cy3bWDfSM7zWoMSiYDZztRUjPYjiBsamIXB3Rj9V3YbZaiBiIWSOVRtOdhZnsqxaYdQmzlRYoUoy +RZJ27W0oLIDQIygbo3QA+MXtB4s7D/pzl2q93WxlGUx9PNHaOLhj5waJ/NT8qfu51inZGZP0GnCs +K6uHCCYHgnSmsKSaYwyT0/QmBJnBIEeStmE2GbZ47Fh4yF2bE1k+XayuqUY7EtECPsa2WggCXouG +w1SttXT74Vt3Hjxd3LiczU1pejUSYVBY4rkscFsjbi9gmqQS5dpSuTyfTPb9fvLEiRBwPRDk1jDB +CZPlMjhpkbhWLQ90IzsyEgHafnb9ytbho4nF88n8HE4Vo1GDZeKffOvTc/N7/pA06qHcwjJuewj3 +CQyQcxiqV2tzqlZ5/jk/8KEEnpaUhqi2Ra3rrqpb9ZeevHn/haccB7JnanL2emv8fK68CMjQio/D +cNzrHgFg250dAneGhxEUdli2RlNZArOhmHH8eCToJ8a7yx98+KeeEeQkQJ2XBopCVjtOfCbh9FhS +n5haF6UsyFkkU+e0Po6JlcZia3y3O7nbHNtI5Sc1o1Zvrqzu3VreudCd3MgUZ+MZwCRt4Hkts9Ef +nJLVqruVhc0xdJoiTAAttzJAVAD/Zpmk348H/ARQhqbTnV25ev7mp9b37vdn9pbmt3/y1z+79+Kb +arxjpqfKnb1UcaXY2F7aunvx1lvzG9davc1Hr7+vOP0QZNrZ2XL3dL1/4dThW6cuvjG1dqPT2fz2 +n/3s/a/8IIravqD8rEeeDBNpyRxPZhfrjaXbd17c2L/RmT2YWLnQnT2Trs6Nzx/MLl84f+Xl2y9/ +Oluer7fXbj5898U3vrh38fHY7JGTmWKEEsNVBLkTjABupECYRyHgj9K8UNOMFs3mGbEWihgcX4Zg +yR9EYFfUNSW9LYhVFI2D9CQrhcnZM4pRSWWajeZ0rjSn2VMUVyPJAkmkgfP6YxdpAIlYTEGxeDAo +DA8DK80QeBKGDJDuSTJOUnGKTohKSdGaQJWNerFwhMOAfYOAeRclJWvH2/2p/bmVK6pex0kzhrhn +Op7tuMMi7sYqk6YzmtWFYCMU5AI+FjBtwM/5fVQU+D5Iq7TX51Yvdif37NQ0RmX8AVaVio7dQVEL +wAxFE8DuaWqDIpNhgE8i/sdTWtGQfPJ47MSx0InjQfAjCqs44q6gEYRz/Hl/0E97PQ== + + + uNsecSj6bAmGDvgIjkvhhA4iJZmbSRWWeNbIFSbKjcX2YKfU2jbjfVHMA+eYLU9xksXwimLkBbmQ +Lizla5vA6wXdDa66LNVEqfTsjC3mngEM8zjmhAIsuNmR4Sgwwjhu4oQlKMV4brrW2pieP7u6unf9 +9gvzK/ut/tbu0csrOy+cu/LG9v69anNRtyqW3axVZ48uPTASwC9MTyxcXNm+OTZ7WKgv2umebJXz +2d79h29cu/8qhFlmfEo2+ons4qnzr2+df7VYXZwZX//e9//q9uPXzWS3UFvsTO9MLO7ffPGtL37r +L775F7/47Mffu3j5xY+/+t1PfvqjeH42npvVE9P56ubs8q2jG59Z2XlC8xWByw6m9kEQhSJKKCxi +pAPMoxaf6c9cddJTQNSNjS+JYkHV21Z6XLaaQEwKSqPd3z9z8TVOShtWwXQarFxrj58dn7tupZZh +JI8Rec0eSHoHeDdFzgA8gNwaDmn+gOSuKXgZis6Wa2ucUIjEFKAHppeutyZOK3ZHBCZRKUIITzAm +jMnRGENSOiukOLHAywXFqLJCLhRmOCm7eupquTYHtB8vVaGYCtJHNKIKQi0Wlb1eHJAAgFYEkiku +rTqDYn1XUNo0k+WZBM+61lJRq8GAMDpCUFRCMxosXwb8BmRkBFiMEzG/jwU6BwaIDUkIrPu8JNDV +7s7AAE/iDvjR6yFA7Ix4qGAEqBqb4rIEkzScZqmxBKNO2imls11OTNmJtuGMq0bfsMYy2ZlUbpLl +TUmyVLNAUJZmdozktGR0QBqi6bxjDZLJcZ+XCAdZBFKiUaBJ2OGhyLOaQhE4pgPfhyA6y2cYId/q +bp7au7N/eK/aXeKkpJ2ozy4fpvP9Yrmfzo0xfAaAUFFqqlq37DYI4VxputpaltQixRcQ3MIoW9Hy +llnOFyecVNstAlkFeJsAUTA1d64ztp6OlwetwePHT2aWt3SjODWze+Xeq3dfefvFp597+MZn7r72 +9ODqvfnl7YePXjq6+nh69uylm29OrdycWb2zun13ZvEImFaCiifsxstvfji7djQ0gnq8BM1mRK2V +qe60Jw4ZPi3yyU+++Z5hVIFAiqKWDYxza3vt9KPTF59Ord3mhfTR+Ztvvv1BZ7CN0RlBa+NcheSb +Y5MXzlx+uzE4QDDj9u2XW701X4BzW6IHJAhJEHSx3QM65IKq1ScG2wtrVzvj+9XuOq9VYCzOiiXZ +bFS6G4xUDEdZcF80l+CELEGbwIAQdEqzWxOLFx88/Vp/5owslw1nLOYeEqHcJd2g+7wLWIZ6a53j +86KYTmXGRK1dHzunxacIGlgnQL9VQayDdBYKKQSRtOKdZHbAS2UEc9w2eaOAkaJgolHMARzrHiAa +cTezjbjbCN0Od0DMnzgRg2HL7T81hIQhQ7W7VnpKT/RVsy1prWBI1aQUSVv+IIkSGitkk9nZbHk9 +XQIGsCpK6VS6qVrVSJQ37W61s1dsnKp1Tj8rSunW3/N5UFMp2WDAg9TwcHh4KAxIDHhhEgcJOs2Q +mWZ7DadtQcyYAMntVTXe5ZSCZrWqQLKyTijkbgSiuUomv5IpbahmH0EsGFJ0q0Xz+REvGY0ZNJ0G +0eSk+qJcRlArGGK9XowiLaAKAkF3JwmBqSpvZe1iPtMWhISupJuNqbHJpebYVLbQU62Knmqly1O1 +ztz0yl6xvjg5uXn1wdOZjStgJFW1SJMWAotIlMo6lVM7V0uNeaCfDb2XSkxb9pikNGEMZHxMEZTd +3bMYbtFszUrOVVs7q6cfbJ97OL953UlPSFz8pUev/Ow3f7d9cIvkS5nqRrF7dnLz8e2Xv7RzcK/W +mrOs3Duf+cLu2TuhiATMnWJNZmunupMXDq+/my3OpZzWK6985uaL73oDPLAn4ZjGCdWVrbuX7793 +8dH7Tm6+2Vh4872v11or4bAYiYmiWq139rfOvXTr8Rcm568CY3Xt5ieL5fkTbneemNfLwHACoCJf +mJ9bvizyuZvXH378J3/BC3mSq2vxWfDpRnJh5/CNo7ufq7b34Zhx/+Hb9176VCLdG/USw6Mo+B4O +SyiSYLnmkNtrlTg4ffXWjceAQI4d8x573vvcJ3zHjsXCEcew52FIn13Y741vAFsqaYD3CggWh9CU +PwzmLgNMFo5phlGCIDEG/k0lVLuXKS13B7vLp26Y6XEUVfL5aTs5cHueRmSgGz1e2t0eSVqykIIi +dMgPM6QUCiCBAIEQCZTKADuDExmUSIUinKqWgIRrTu5vnX+0uHOnO38lUVjzB2k4xqtqJQa5j/6e +OX02EpJYJpctzlNsHkREMjEGLikSE8Boe/wccItu+T5Il/lCwN1PwmcLs0DuykKBJhLRsITDKiCf +dLpLMUYgAJOkCQhHMcv9mdMbp2/MrRyadiuVatuJLoabHBuX5SxDORgsM7hGEeAl9MgoCrwVTWZA +yGOoAkNqKMiLbIohLBIzgCUHAc4yWSCYMdygGIem45KcTzn1bmu+3lwAGQFc/PjM+Vp3M5npSEpG +FOO6GrfUuCym3bV7D8nSaRFcMJ1AUS0W5WNhBqSneHKMV9uBoJzIzKaLi7rZmZg5s7B5udJZw3Gj +nG2e3ruSL0ziaDyVmUpkJnS7JSp5VS8CVw6crCAWMNwZedacAmhF05qIJ+dkpcHQcVWwa5V+f7Dm +nlIsryaKq/XBYb1/kCnOOJlJik4SMLe2erB+6oog5oEU1PQ2TgD1FZeEot9L+D2YKRdffvyp1954 +F3gZt7+qh/NHbJwtZ0pr6fyCoWQ/+OhrT15/x+8lTxyP+H0cx9dy1d3+6u1gkA/5SY4G89jAUA2Q +BkhJYPCB9usOtoEQIsHosc7i/OlqbTYckWJRDYhYismAwYGidNAH+0YjUBgRGSEWiUIRlGETpfaO +5kxK2hjFFRnKmB5f29m9nsiOS1rFSQOzvIDguXCYpzBV5BLhIBUJMhhiEqjDUhnT7AJfBsFxEksq +fEHmsu3a3NzCYQTWQFpBUCMSlgKA9v0ETxn5/LjfR48OI24L5lEChjQwJgyTpBkHAMOJNwUpDaOC +FW+WG2uJzJxmjrV7e/HkBAyrndZStTobDrmVSWIQsOrxQNCG4YLA18ElBf2QLiUMreIDvikk/nEF +MBLR3ZP4Uc3vZ1XdjVCCzBhWzzKbJGGHQjyQwRQVR2A1GCAo3N2RiKMqAC0CK+GIPOohQEQQqOz3 +QO7pbD8VDlAMbtBkkuVLKJ4MhehsYZDM92MxYFENScmzXFIWs5aWEzknHCAENp7JtKAYCCscQ2UA +b1kGF5wFt+P3U8EAi+NONKIgsIYiBhglOMJLrMmSJjAUsahU7W5IapUkEySVRGAD6CWOSalylkCU +oB8bGYqA2MRR/eSJ8PDJaMCLUCjDU3LSrJTz0yBOT56MjgzjsVgCp4sYkURRkyQlGpiWate2SidP +xtxzYfZEd+LczNrNicULwGJgAE6YjsA8BvNudoAlcF+8mLGdhuU0AfIVIa7JSYrQwERQOPCkKRTT +MFT1e1EMEpAIjcVIiRUJBONokSJVJ91kpByMGhAk6WJya2Xv8Oi2qgGRlkimp5vtg3hqAcNMOMpE +AnjQh0FhHoUVKMrDUYHADJJMCWKDpbJIVDbEzLntCw+ffBpC1XCUQxA1BogrphII+JIDfsw3ioSB +sPQDNyRGY+qzIg9cJCKydNKyGyRl4phcLE/ny3OJzJSVGOjmGAsoEVIto2ZZDfCfwSzEE+PpzCqG +N2AoHwqK3pFoOADLvClwznG3jEwYABjDMiRRRNBEJKJBkBFP9hk2C4QKBNsgj7u/RGwgjAExugVA +hqLRIAUD7zwKu1URRjAEBRSXxhEdQ0TvaNSQi5nEGAKpcESEoyqBASWgRiNModh3EjW/H6UInecT +NGWxlE2gEhTGIwGEIdRsuhz2h6BQDEdArrFI0gEf5/eRw0NR7ygKpO+J4wHPCAxH5ZCfjoH5gmUk +DNgDwEzojW8qUjYaoinSQREbQw0QEWAePcOR0aFgwIMQsDLqVqiAgD3EIN02iqYGojuDxvTjx4Mg +FZ444WrpZ8dgMb8PEziDZ3UMFbweCLhFhsnKSs00G/FUV1Yqfh8eDoF8GjtxfDQaRFAETBDH0nq1 +PJ7JdDStiCJyJIz7fNFQgCKwLIYYGCJlk5362OawB3BFxDMS8o6ECJjmCNHUUm4lIifHSYmQS/VO +pzZVACqIcxCISycahl4EmQhG9dFRLByko2FOAuZFKqCIBAInFMCjIRKKCoDTfB4SiaqWmq+Xx8vl +PkVIhpamSBNoVPBCJCZAYeH48TCgrFjYvbWhk35fgI/GbIYtK0rbMHuaXoVjLCCfmdldUQFmJA5U +nChV4/GxUmnOtNwnh8EARVEmw1gA6u66mNuAEoOB94f4cAj3joaD3igOcXAEXCrj9wMZY8lyledc +oohEhGcmqwk4h2bqtrPoHnKBtaC70AZ4FR8dDkZCNLA5FJVUlRzLxJ+VVggEPND81Ob+/k0C0/1e +JOwnoCArMnFwU3CUDwWI0aEwCgsMBdhGCAVINMaSMEtjPIEKcAwOev1YFAY/gkjk2AxDp9x1ah8e +CTFgjo4/7/GPoH4PMgpgcMw/cjzkG8WgiMjgpsyngG7JJgoH+1eAyATJLuxnAKtEQ3wsxFGIDuDn +HYFso+lYY3BExkGOCHGeYfjYcz7vKJgXCXziiWMeElM4Jh70k0EfGCIU2DfPcBSLijyZwCEtGmQY +whH52tBw+Phx77Fjo+CWcVRWZSC/ZVuxz569YFpFn58IhzgE1UgqRbNFnEj6vZAuWIenr7775e+H +YuJznxg6ecIfC1EiY6tywrYyEqudP7i4tn0+CnGjI9Fni/LuujyBqyyjSryWsIDCnOLZPElYQOPF +Igz4PQYRLMErfBKOMVAEg0I4iUqOVaUpPRYBIxAQacq2ACaZYAQPhWGQESQuKwvtSEgBmWh4JHri +uAeKiRyXpGkbck2rCkE6BisynyBRORYhFSWbLc9DCPhEPhJy92c++2tKV/M+Pzo0FAJuOhIUKMyB +IoLfh8AQk4pn0qYjkELID/l9MAyLpt0oVOYBokJBBlxRvbkUT/TcrtDDUQAnKMphbgaMS3wJRywA +pLTTyCWbsTAGKJ2nFAIWCESkED4aQkL+CHj/84eHOMKOngx5h6Mnj/mGjwdDPtIt80gZzxaCBSii +x4JYNBD1jvhHh/yRQNSW5ErKruUSuqSWq11BcjyjwEMFR9wphpCIGAmwwyeCx58fPf7caNBL8UyO +o1OxIMPialzPJs28KucCXhQKc2gM5BreC4jlmGfouN87HAn7MI6MozHBPxoFCPd5APJpHLZQyAn5 +uaETwaHjPolLAUAOnwwCHIK0S+GGIeUoWAt5mdGTcDQAIosYORn2jiLRICBPNuCFWJLhSFzm8HLS +6HYbNMtBwCDpyXKxEXfSNCPGojEsFrOBaSy1E6naiROBkaFwNEhrfNyR4yJJGTzdzA== + + + JZaW5uLpXDCMen1INAJyqMJzSsI2cmk7nzLX5/uPHtxtt6dHR8OjI8GRYT+D8xKQR4qkcjwSiVkS +n4sbIgMQ5YkF/RweyzhCNWecPzVzcGZ5Zq1froM3E1QFiA0RCJhnphgFV6LwiqlJqiyYms0QhiLk +KdwCssc/EmVxvpgt15pjipLIZZo0raMwi0FcJEgMnwwfO+Zzn2VhbrkYMHQhHwzUb7PSm5meUQUJ +DmN+L4zCMlAFtlVgOYcgjXJ5XNNyipLjuETAj8fCNMAMifESo7CkjsQ4kLJZOsNSlkSLMknkHdVW +NInlDVHkMIQDICOhfjO5ONfhGcCKBBxhoSCFRQUcUkAiA/AAHEIChRlhooEAFPTHAgGd49sZc67q +7EwWru11Lu+Ov/HK1d3N6ZSukbgIRVmQ+xhEBwB7/hPDJ48HgsBlB5ngaAwPExxKOaJsCpLGiSgI +3iAkMRxHkSTgR5JhMF6kbEPOR8P08En/8eeHTxzzAniA5DgMXOcwcfxY9Nix0MkTEf8oDsAf9kFQ +CE7HczhE41FS5x04BDQ/QaEOT8cDPvjkCa/fAxNAw4TQmN/PYSFHghoZZrplLU6XGjW7kJV6VfNo +tX73wvz2WrtdNlpFO2k5qmShCHfy2IhvJICEIJ1mHRZXsEBWhlZ6iUbFNDRaVznT0EWWSplcvSAt +dfVXb2+8+sLuw6tzL9xcrpZSoyOB0eEwEgWC1VFZ3uQIm4UdDhqU1JV+Yrws5nSoXxBOTaZevbP6 +6t21737u6Lc/fusXv/rwi1+8vbGQT9uUxDMkGYchB46aAqnnHb1T1idbiUE9FZeYnG0KNB8ORGLB +sMnzrXK236+uLc+9+sYb9XYPgpFgAAYXMHQC8BUtK22SzLiP5o6doGE4YxiNfK6YttBYGAlDsRAk +MGK7lLt8eDDW65qGubY2m82mEJiIRHBBcBjGAcqNArwUA0RAg6+c6VTSeZAICyZXVJGdufz5rcFU +I9lOi9uD1IvXlz/5YOsLb557+sLO3csb84NqxjLwCAQF0YgfJ2Fd5LIMJjAwplBoNc6Ml5R+SZ1r +G+fmrAc7+U/fmfny0+2vvnHq73/5td/+/CvvvLB9Zn3QqxU0VsCiOBwmIiGKJm2OMPEwBEx1URVa +CbVsMFMVfXksNdvObM+171xav3ww/fDa0tsv7n/y4eXLe6d75UrWsVSeQsJhoL4iAco7ggA4eUcw +wKgnj3k9w8GYH4b8YZXE84bUq2TiEqfTeD0Tr2bTKc1J62k8Rp847gUBG/GjQGwpaNjCfU0zemZC +efGgdmuv9vCo++FbB998/8oXXl/94FHv99+/9U+/ee8vv/HgvdcOdhZ7eccB9iHoDUa8o0zEl+Ni +k0l4Kh1cKscuzKlXT+UPN7JH69kbe42H55tv3Bq8da//xcdTf/dXr/6n33z2O58/c3cnVdSRsM/v +90ZpXGJwgYjCEhzqGbH9DnU0yT05k/nw5fnP3O+/c6f1xSeTv/juzX/67Wd/8e3Lv/qTo//ys1f+ +x3//+V998+7b9+YvbdcKCRuPgWhlbEHLm2IrzS41lf0JfSYHz5WxXhpf6pir/fh63766XXn/yeYf +fvcnv/r1Nz764P6Tu+t7G+MKjwe8vkgAhWLC8HDwxLGhmNcTZ6MZPlaQoTjji7OBfk6YaxiLXX1v +Un/n0cY7T/Zfvbv51Xcv/OSH7735ytVGyZyb6s/O7Sxv3VW0Ehr0mxSU5OCOiZ4Zlx+fqz/YKx6M +869eqPzi+49//sNXP//C/JceDX73o5f/7T995b/+4Qs/+fLBv/zq5b/55sVzC7ZFReCAW5OQhAQi +hvJQIMkE5/LYvc3E9z6///MfPPqTz5//7IPuNz459aMvH/zhb578zcdHP/5w519+88o//OjqFx6U +H+zndmeyeVspxEGuTBpKRiSZFB/rOdBKib65En/7xsQr50pPzuf+9IPzv/nx0//6n7/z+1+896vv +3f5v//DO//f//t3f//qDJ4fVb7+z9csfvvDe442sIQU9EEiywMayhIyEQjhI+RGvhgcMbHQ2T1xe +TF5azu5NaEfz5ssXO3/21Xsfvr7z4dNLb790NWc7UJQBDCyheFmhplLodp24syh/cLv1vXf3v/vu +3k+/dvM//+Tp//j3v/r9zz/94y8f/N2f3/uvv/vcNz5zdGoqmwUOkhJsNS7guEFCLR1dzEPn+8TN +Ofn1vcR33lz66Tdu/uALZ7/59tpff+ngP//1S//tP77/r7995zc/uPm771/+zZ9ee+PadNV2kyAQ +ISF/FA0jcUGtqNJCinx1S3n3YuLz1/PffXPmt98693/+4a1//Pkrf/mlvd985+iffvbwH390+8cf +bP70w/VffWv/zz+/dX0r28w60QAMh0kqiq2Mlda7zkpdvL6kfeVx/8dfOv3tN2e/+XTh9z959Vff +v/9nn9v94WfW//s/fvA///uP/ulvn/7+e9f+j79/+/sfHmyPAyz4R4dHwgEIcLtJM9M5rmeEu6rv +8jj5aMu8v2W+dqHw4ZPpH3x+61tvL/z0m1f+/T995Xd/+fIffvzKv/3Dl/7mW7cOFsszg36+0EVg +OWs6NUvsJ4jtCnppnPzi3eYvv3742+9c+d5769/59NpPv375X3/37i+/c+37763/h4/P/e+/fuM3 +37jwrUflL97MHIxxgFVEkvUOB08+P4J4fUk6OJWInOsy15eMJ+eL7z+Y+tmf3P7nv33zf/vp47// +0aO///GLP//48Ocf7f7lp6c+dz1/aVoaS+ApEXXLiTIajetxvdCvNVd6qaksNZeGLw7Iz99r/dl7 +Wz/66OAvv7Tzi+9e/MNPX/yHnz355Z9c/uVHm//ww0v/8qsXfv/DK9/+ZO8zF+MvH5QaKRUK0zyb +Yyhb5eRWVm/Y+FgcPTuQ763JL+/on7qYBaPxH//i9q++e/Hn3zj8v/75a//3v/7pdz61/t3Pnnty +a41FKTTKJAQxxeFZLtqzkaUCdjQuvnqm9K03Vn/w2f2ffPHcv//mM//zv/3kH3/8+McfnP7g0eKp +2XxKoVgUx2Fek9KGlLbFuMPSBRGaz3OHU+m7W/mXTid++OnV//V79/7w43e//MryR4963//Uwk+/ +cu4bb288PFs5M1ds5Us6iCk+Q6A68GIMruSMdNWy8wI27uBnxs1zk+bVefOz1+o/+sLer7977wef +P/udT21+6cXlpxc6b+xX7qyl1rpyM8MZAhUNUwKdt7WaSPAlUykoZFnG5ov8w1PFb74+/9cfnPrb +717+7Q/u/uGvXvrnX73zs69f/PmXd//lZy/+2y9f/fVXNr/zJP/yfmquxNNQKByATaWUi3c11jQp +rKnjHSU2bwdvTLOfPMy+fbn8tSfz//77d//ld2///kf3/8uvXvu3v//8T791/RtPV95/cXZpLGHK +GkOa4HZquZbOsimBWG/ZgwQ8l4zst8gH68mnl7ovn23c28h+4Vbv19++9tOPr3/7jdUvvzDxqUu9 +i9OJ+SLIqbCAcySiACUzejJCQ5QAheJEcMzCNlrm/mRudyx1ZTH/0pnK21fG3rkx8/aNmbM97VxX +OegZ8yUrwQkywfA4CzS/yCZ4OqkKWY13qslU2ZBKCrNStc9NZA7HzbcvNb71xuzffuvMP//i5b/5 +8uHXHk9+7WH39W3z0YLyZDO7VhZMLETHEIlPG3qXwGxgA/EowUbDDhFpqOhamT3bJV9Y11/fT330 +sPeHv37h//n3j//p16/99vsPP379zMX58kTBUTglGlOQGIOGwpS7rwvLK0zDpCfS/EpNPZxNX17K +vrBb/urLy19/6/Q7d6dub1emKhpHQZGA3+8JR8JcKt6tV5eTdlemNRUnWnH97EL/6u7MII0dTSiv +nGt95c1Lt0+PXVku3Nos7Qzsfk5JqwwwODRuuuUKYyZOpICRBw46Ha87siXCiEkSRU0qGXzNYpcb +1uFM4dpq89JSeW8yO11MTGUSYBrTCsfiKBTFQyEqEGApPEXActQfgfxBOhI1SWo8m97oFQ6nnTur +zocvDH7wuVMfvzL/ow8v/OgLh997a+27ry1+/MLM+1cbl2e1OBcFpl2gFbf0MeYQqBkChihCVqxE +N2ln6FDfip3uSBcm9RsL5nefrv3rf3z/n3/3mf/wzevfe+/cG9emrm6WFjs28MaymDbNNknYFGkg +MVaitU62mhXpkko0LLYkkXWNm8yag6Qym6IvTCfvbo+dn8r3TLqqCGleVAmWhOign/GMkEMngAJE +FS7BwTgTiYgQnFGUctyuxeMN28xLdIYjCxJbM3mHjAEtmGSFZr4j0DZwJQhQ8pCQzXRxVA8HgNjG +kTAhk1LZKSyOr8y3Bk1DXCooN5YKW1Xh0mzuzCC9XpI2yvJCTpnL6jWFjQBZMBKBIjJDFeEYsIFh +4DS9QwEs6A5sTuSaplAUoMkUvVLkLk+bn7o2/plbs4/3u2f65TRN8xBpyLl4ZqY1OKKJuCIkGVyi +UTAgisYrMi3ovNzM5ysJvWjxRYuLS5Qhspoo05SAYAKw6qOjcCwmC2KGpG1fgIxGBJ6ydMHMOrli +qkxGIgmWasTNShJwmiERnEiwwFDEQiRwUpEQ7fPiHg8OI4lkZiGdX3C3kElZhtQomNWFOB4DaZrU +GGO8NjPdme9VBgnFUihO4xzTtTD4ySGvP0DGkATF1AShqkoVGtdGh3zeYT/w9RpvW1Lcloy8oTYz ++kIrfriQ3+6Z52ayRwvN1UZ6IqP2U2bVNKBg7ORJTyjonm0f9SAnTgaB3yTIXCY9Wy0uFFMdiaRs +Dq0ZdFFECwJ0qpN+9cr2a7fPXFibXqyV05Ig4BgO4zRjw7AJwYY/yKtmr949qDX2c4kJidIXJxau +HN2kYA7MF4tKjpQuOOVqupY1shIhQz4CDkleYEtPRAGoIlErGNSCARmGLIFNRX0QFgK5HvOOwu7j +ryAZDXNITKEwi8ZtHOJC3jASIqMBJhpiWXfFSqfwhOQeZhkLhURge4N+Coc0GjMMtSKLDRA4ZIyR +SbGdqyD+cFxwMmbZ5Ew6SlGQSCKy3600HoIhk8RTPg/53P8ycuy5EeA3cUgyRcuWEyREEVFMIXiH +l92zuGjMIBGDomxWs9hUcBT1uQVhOsXmrh0f142xTv+UlagiKE+QlqrV86WVVH6OpAwMFVTBGevO +eAPw0HDY62dYsaHZE6oxzrqVtdICl+0PTol6zRuSEdw9lIHiyXBERSGdQtWgDxk6GQj6GBxxeK5C +kjlAUzHIiERUns0AWeLzc76A2+oIxeKqVjWthqoUE/EG5275cBfaEMQEf2L5siBWJKWiW23NrAt8 +QpQKMJYIx7QYpEeiOoLFEcQOhQQEVijKlOWcIKRkuZxIjNlOU1eLFMLxlKCBieVTHk84FEBhSJOk +jplaQciMz08ODUVPnAwDYCBYTlI77oFEH+H1Eihq07iDRSksgqmMWswCXtIgWEIxiw== + + + eVYrD4LdgufgtaMgUmBNFEu54grDV0JhMxyWYpBqO/14csI7SoYCYHhtQSzIWjMGO8GQEo3qPFfl +uHLAz3tGaYIoFMobmtkX5RaMJUc9ADmMRMdlPgE8Gs2VrPRMsrRYdjvSTj7rNi6ShNXqbLFu9XLN +MPuJ1Hwmv+pkljwB5cQwfnIYDYc1n4d6/rnRkWFYlNvJ0kamtKaZA4Dek8cjkaDg93LPPx8aHkYw +Iq3o4/HUqmYMQhHDF5CHR9xlKYa0AZiH3KdknuGTkaCPxBBdFUsSm/CORIJeCI8JOCxjYLpDgntk +KSRFESccs57/hMdIzuJsluWT66tHnYlthEpQQgGj0rxclNSqYXY6E3shWAzHRIrN6IkOSmeiSDyG +JgW122jvHV5/q9BYHvKQwSjgiVk7s8mrA5zKR2NqIMSimMkJZYA3CLFhLC0oY5o9BRhRkms8nw+G +lUjMiCEGyRQVs+ekJ0S1juIJy+4Vysu8UFDUGsUVeK2TqZ1KlNbtzJxm9zgh35u6wEv1KKSIaoHi +8orVY6QaQuUxOq/b/XZ/f3nrBkomRrxEMCxRbNHd4EemCdY9wmNq1W5vW9Zbkt6gpSZClnC6zkuD +YBjQjhOOunsC/UEyFhNFsSjIfYIshQJcOMhJYoV9dqJBUJrp0nKmvE5yDZKrx9BEBDJorkBQmVhM +5dhcOKoFAjJKJCm+hFJFT1AdGiYJMh6OsB6PW0gWQhyWr1FMkWFLKJ4m6QLLV1Sj5/ML0ZgNoRmM +LEJoimRKKJEeHsFGhjFFabJ8IRBiQhGR4Io4V8aZkmx0ecndlgmjFkJkvUElEDUgImdlVyRrykwv +GomFk0OEx8PQTIEXi5GYDsEg9hPhSByQM4qlIhF9dJTEqaxpD0xrPAZZbu/RkErxdU7qamoNiooA +lseOhTwjWNBHhUMCjMRD7vlfPRIBiDJ9IyigNQIzdWtMtSckc1wwxjGqcPIESostWqgmUoODc49q +3ZUIqiFUEibiZmLcTE65FcO0FuNutpmwU2MhWPKE2EBEp7h6rXu+NriUb+4SfD4Kq6xYU6wpxZ7B +mCpEZMH461Y/kZlV7TFAL6GIKqrdeHbbSCyzUgcjMxASBxfAyy0INSJRmRUrABWZ0mqxtpUrr8XT +s6n09MbuHU6tkWIl396bWLk1v31veu1WobVTHzsry41Mcmxp+1oY0REyAaClOLPp8la9f1jtnU+X +VxEizggFUW0yfA2n8wCfnN7llcbk5MHG3iNBqQ15sBBkOJnFYvNspnRAsu0oko7ADoQnnu2FE6Mx +cdTtwiy7tX9RBydzUThu2AM7NY1SFoRbYBJpqSuabodlPTEFMBYOK2P9Xd3sgvv1+BlAiQRbIbmm +oA1ooQzBajTCa2pV0duAiqMxQIC2pI056cVkbjmVXfT5RUFqiUqfEzvgs8Kw4wvrQx42Ajl2co6g +8259e8yhhYqg93itTwu1YEQBwFascRhkDbcSWh2lC3pilpXbij1Jy50w5IjaWDyz4A0AWMoAWjhR +4sWOZo2DO4pBTgyyFWMMJGKAwFEPFYkqotJM5pYoruHWbPGQ4KqCYQMw24lj3mPH/MeH8BCUFJWu +Zg0Yvur3MsEAz/MlBoQwbIMvt3gmmpDVLit2ipWtQnVVs7sYnWDEkpEcwFScFYu80gIg5JVmIjNV +624pVisQlXitgZJZGEsRbD6EpmNEDcKLf9zDH4rpMTQuGmN6YqbeP1o89aQ7ey2Gp2DYysX7i4uH +YdT2R61QNI4SZdmYzNR2Ms1d0Wi6jdVyU7RUEfUmJ9c4uS7onUR+0clMkXzWSHRPHb28fOZOfbCb +rqwrzgzAJLiRVnNtefsGGDFerhQbO+XOYXPqUqm7J1rjEJm3U5OzqzcLtfVgSEukZhc3bk4sXOxO +XVjbe6TGpwCJAfxwUpXmcxBmYFRmeunO5ML9+uBGorSNYhkEd0S1yOuNIQ/jD4iAuxRtRrPnncxK +prQC46qoVeP5FSO5CPihPn44vnAtU17T7EkgtCS9E0VMXi4LWldzBiAvCPpkIOoedjOt3vTcEUml +gmEwy5ZmjmVrYAQmOX0CZ2qBkFYqrznxgScgxtBMOOogeE6PLzr5TUGfCkPJdGZy/+y9sFvZjxrx +8oC4WEChlc3lM6+zfP3ipcdf/voPi5XFYQ/nD+u81qvNXJzYvN+cvqLFp4MRLVNcAKHh9YlDwzhM +pKMo4NVGvnraSi75fXIkrPBCCcSUx4sC7hrycN6QwgAIJZbyzYPnj0dHRmAI1sIxMxyxACYhJBkM +WxE4qTkzycIqSNC+AB929UkSJbLx3BqCpTHgsJgCIBPJGNQ65ydWb9NS3k6OZavL5eZ6rbuZKswq +ZhMMpqDVav09MGtu21yxZibmS82zpfZZIz4DbtMflWEyDmgKZFiSK3MqiKwpgm2q1mRn4nxz/BTs +7j0eqHZf1Hu00JCsCT01Len1uYVzm/v3NKeLuFXls0AJN8YPBut39fS8Fe/MzOy89e5XG4P1MGZR +YqvQ2GtNXO7PXS0211DC9vhpgsnidBYiLJzPhTGHU1v9uWsLm48qnX1ObYPU2Rg7y0h1hMqKxkSl +d9bKLIpaH/CVnZ4c9kDBKOFkOslCX4/3olgGpaqyNkjlF9dP3do8fWfYQ/qDAss1uv0rsxsvmtlT +JN+kmfzDl75Yqq6EowZgxZmV6w9f++DhGx8u7j2UnUmgFlSt/fanPjacsREvF0MyijWXqZ7pztxY +3Xm52jmgmEx/cjdfmvEEqDBsUmInXtidW3/cm74wPnMkuIXyCvnqujuJUUPUurI9yaljJNcq1k5P +zF2AkASQyoCiRb0v6G13UytZBJptbfva1Qdvs1IZwdN2ct5OAQM8oIQGQZeAGmH4en3swEkvDI2w +gaCmOeNObi5TWSt3dgAv+T3ApU+NzxwCATw0QoBcr8VXBL0vmQOcraFkZXiUTSV616+/quu15z4x +OjqCokTKTCx1pq/tXnyz1NgKBOUrN57aifFQVAsBdS/2YkA4wQlwL1ZqpTF2dffwndW9x6pWO719 +pd1fB4pLNZp2crLa3mj2T7cmzqSqS7xULFUXK91djMqySoXT6hhTAYmVU7t6YrrQ2Ca5PFBrnNzK +Vfdr49fac9eK/QNWqcbt7vrO/URhEsBAj09mKhtzqzfOX3zl/I23+7NHTmJ8rL/dHd9RjXamtNya +PJ+pbJWbW/Or13eOHqfLg05vY2b+quZMUHwF54solQRKjOabRmKelRqKVu3P7gl6PYo6ujMJkoJo +TnB6vz11aXbzAcCkEZ+KF1fnNq8vn3mx0DsHfFIQsiOQqVqtYns9CDGyVSWFGiv3spWNVGlVMnvg +LkY8BE6mJa0laGVWb3P6jJpYsDNLiewcjLndrArlecWss2LGzgwa02fT1aVMeSlf3ciVlmHMBvRo +p+ftNJjlvpWdBUJaiS9q9nSxccpIDIIRsdbe6Ewdqs6kEZ/k1YZktEm2lEzPAFQzfIGks3PLF669 +8N72hScTq9ervbOG02eY1OnTN+8++kIwasB4wklNdqaO2lNHzcmzjclDINKuXnt1bu4sglgknapP +nJ1avTtYuNkYv9Sbu8uInVGvQDGFKGRYqWkrM6+nZlitBcRPuryeLm4PDTMxKJ7MLVJsdXgUHvFg +QyMkBKfBOAMjoKndYFA4fiIE5Csr1EgXdUWCLgfCOqCyzd0XU5lpoFdhLA6QAJIjTuZBmgaKy0rN +5mvrIJY5LrswvZMrTyCYoaj1IqDczburOw8a/X0z1RfkwthguzN9PgBEHWHJVjtfPdUeXC209nL1 +7WRxUVLqhcqiarb1+CBT207WNiRnnBIqhdL6zNo9MzOBkE6tezpXXhmf3j9z+GBu47qdnpDlyuz0 +mcHMPicWc8W5sxef7B29tnTqwezm3UrvtKpnj87fOTj/AoQBEgb0VZWMLsBAurytxudJtprNTl29 +/zSeG8B4PFNc0ZPzZna1On7+9OU35zbuxBMzO/sPJ1cuM2rFKS7J8QVa6evJpXR5tzZ2yKttUcpd +vfVJwAlh2ILxFM5WCb7OyA2KLRTL6/XW9vrm4eTCOYJrsHIHEHIYiUNEQnN6E0tXXdqknHRhJt9c +T5UWK52deH4JwnIIkcnVN5LFpShis3IlVVkrtM4U2ufaUzeLrTOqNeCE0sVrT/YOX+CVGhBXBF0E +BqHaOZ3ML5nxMaBgaTYzu3hhfuVCMjvQ4l2Adic5UazO7519YXXjOvALitYezB7Obd2xC0ucMfb/ +s/deTZIl2ZnYO4nuqszQV2utVdzQWmZkRGpdlZWlRVd1V7XuGfTMYDALgMAulgAXKw3cNSPX1kgj +X/jAB/4DvvAnkZ9nc5dLPvGBZkxbS+/orIzIiBvX3c/5hMcNP35+Avn6/Y9/NZ9fiEIUJcudwy/m +m9fdwQXSzU1PaKFdqUVRvJLV5vHjH7749T+7+vBXo/2vJnvvR7tfeMl5pZZAx55dfOP5C0mCeW/w +QtOA5klPXH8tiu1iURPEehBuAErFssNyTS849MKjRud5e/gcvoxiAySUovXhGmxnQjaQ5yOMgO5M +ksZxd/SEZEdMlGcQjMN4tzO8RDJG2Qby2A93BrOXcfu0CPLVGgit9fE36+Mf4taJ7o5pIfHc8cHR +V0m2cr0hgO7y1e8x/s+++MunX/z1/uNfB409xWgfXX5rOpA0bZLyyTqp74+n15PFMz9ZGmar3d70 +Buv56qo/e5T3zl3IsGQ8nl42OgcgEddf3NataEpmI2kft4ZPuwRGrjvjE1mrp9nip9/+83c//G1r +8qw7eUq+NN3ci+PF06ffP3nxayAtdP7i4Kf+4v308CdgiAktykXD3vHX3//FfP10u6Ro1gTwMt58 +2R4/RWr3Bxf7mxf/5u//+7/5u3/LSm1B7VneptF/fvHyz9//8b8+fv7nfrT++PF3/81/9z8v1y/g +0Zzk3I4hoS8253/87Ju/w6xJSqMFW9Q7M13E21Czx7o19sP14Bad3n71u8Hk8tHjb5vtUy/ehdcQ +1R4tZBz8ZrTe2XyV5vtp4yDrnNrh4vjsm6unP/fGzwybFE6aLZ72BmcWZq37ZAjtun7fnb0Ks0NM +MWzCYHqjm6Nb0xcCDKPm4/7yY2/+1vLmutnbHL9+8u7XQX1VwhP4xPJ3Jrtf4iW9wVWWbcj+YEY2 +GF2p2qBWC4tlF5xI0ZmqDcfTdzvr74NoM1vcTGYvZKnJsTGkfoWKEGlhctQZvlC1UZQfBNku8g4p +YHlTSHQ32oT5iWJNBbWjWd0wWXBi4seL4fJ5d3zT6l2vDn7YOfnJTtecnHYmj+r9c1bKdHsCm+bC +za3eZvkJnuaGS0XNV/vvVscf+vObtH3qZruK09fcSX/6dLzzGuAAhx6m6yjZDMdX0+WT1uCM5iPH +7bX7R5pd9/1uUl/XW6ezNazlIzgj05sJUjPKjv10jxX9MJv05tfrk68un//++PpnRg== + + + CAVyKf786PKj4U9hncjG4P7u6vCLzem79fF715s6zjTO4L865ZqJLOiOHr949w+gMZrdC5lsTmhW +KBs+2nT6NdoEbuSdw9n8crO5ef/hN6PJmSC3s+ajvH2TNc+DbB+WAfjW7FycP/ru5uUfy3pHVPut +0ZvZ0a+78y+y9lm9e2V4ZMP/569+u9x9CrMsKF3Dmc93Pzx9+1+cXH2/2gN1Pt5dP/37v/8fTs+/ +EfVJZ/ZqvPfVaP3F/PArDLiq967O3v9P/8v/+oe//jcQq/CeYf2sO3493/s0XLzM2ydZffPFuz/5 ++se/tfw5gFR1Zm60V29d+MmRbu8o2rDXOz57/Mn0JrIxlfQJwzdoJvGC2Xz3+dXzn1Sj5bqTKN5t +dS/Or391+fg705lRTFypOmmyfnz9K9uZFgpGpeJ5wWbv5Ifx/K0fH8rqpN06/hf/6t99/c0ftrdF ++AJWGurWqj94Nhw+rdePXLuP7lv+RNZaspKnjT3LnbvJoeosIbMH07fd4cvO6AnGHMqz2T8LyIb8 +u5o9Ua2JHe4Ops/Pn/0u65xUKAvn48VrK5gPFk/RC7CtanTJVm87r7x4AZhqdC96i5eLw2+On/z+ +3Xd/sz77WjF7XjQl4cSGktSEs7DcpWpOITsRorLRaLV34bMYIYUKxYCwYh1vUe88CvMz0587/uj1 +F7+Jsh3LHSFPYQoQ4Y47ns6fP3n3B5GU2BtEydpxZxBv/elVa3guKo3bjZ1XstZkWN8NZ+3uwf7h +i0Z7v1xxihWX5jLVGuetU11v2FY9zXfGO9cXT747vflxsLgW5AwqJakf3e4OYSMvIJVPH/365t0/ +ilrXrNCtVINO56Q9uOCVOkIUXp7hct1aZu3H+eAGWSPJ9cOzj5CIMlkN7klKGwg8nb9c7X2aLD7w +UldU+p3xc4iu21WFuijXBZ7sAvf+018cnH9pWO00P5jtvt2cfGqPriW9D60IPXZw+H42v5GUPKqv +8/41MvHs5reDxVtW7FBU2GoeHJ590K2+ac2C9CBpXtj+ptN/tDn61B1cqWrz5vqb48OXttUWxFgx +OvXO6enNry6f/04zxoLYYLnU0Aa62qfpSBDqNIvnkIpXWb476B+YRrdW8+P68WD2nhdyuuZUy7rI +Ra7Ztv2V5e2o5gQQ3R6cJfXD8fILnxSyOVmf/Ag7lrbOWCERhMRxR5iRrHXsJftxfr4DzXD5q73z +7/xsU6lZrj9Xzb5s9r18T7WHPHjWnfbHjye7byxvFKXL1eGXrdHjvH/RGJ73Fo9AZAgtP1nBxTBc +4ngrWNSIfFNjLetDCB5E+2r9AuZU1LuGtxDkHgRhlMKoHqJrpjfHGR4//omXG6433hx9mK7eQWak ++XFveD1ZvYJD98NZFO8A2GWlE6T7URNIOJa0pma1NLPVbO43Wns0a1KMUaXtUtkSlQE8V2NwbdlD +18gvj19ePvooqnWknhUudW/uRaso2Xf9JcMGUTztjc7qrb127yhuHIrahGLgytvz5eu8e0Kxjqyk +qtpl2MyyFxgulRReDB1n+PbD7xWtXSjILBtLaiepH5xe/Xx89du48Xi75NSYGNNRo73bLWgiRW25 +zjhN9rqD66h+EITT/ujUctqKniFNVHMcpQft3mXWPIWdFKV0PH00Xb3CbAb1Izver7F1WekHwQZP +k+Wm7042Jx9WJx9VYwwtpBkj2DqejZ49+ebo4JnrtMN43B0cz3afHj36BgqNYpJiyaxRoW1MXGuy +vaVVq77tL4Glq8OvssaRIGSViqOo3d7oSdY43toWS0WyQyBOOE03WfNiuvtNY/A27z+1/ZGspo7f +t90hUtJN1qYH9JhyygD9xZDyfNAbPepPXnYHLyBvwICi3mOlFhyrbrQlpQ52Wx582j35LmtdBvF+ +3jlzo4UXjnd2X6yPvpSNlqQ3JaMFt/jm019+8/M/PXn6G7h1XkxhQoFpkt6jmIiXesCuRvvi7Yd/ +cHT+vtE9Pr76xrCnrFBHwECHOMFu1sJpf7l39VvNHLtOb7nzuNneN2yIN0R1w/Z3kuw0y49Ne1iq +GCbIOtwN4fLyQ7A8xUey2prNn4NKikW+WGRrtA0DLqoD2ZqIeh/TamjNbuswThZV2vWTg7hxAbPQ +Gt5IWoeiQ4TW7u5Nf3wsSAFIkxFy1Zi2ehB1V5jWKu1XanajuW/Zo1LZptlU1qdueDSavt1ZfxzN +XoA+NK2zWr/MW/tkJ3AuYvlMd+Zhdmp4O7ozZRjn+OiL+eJGkOowXKLcRgxUa57rzVrt4xrZgFFW +yV5AIx1dNvu83KoypNBPt3/R7V/yQnZ0+d27H/+rwc4rDJRpzxCllYphaPVGY4WY57hENydeuN/u +X3vBnHwnjvMcp3vx6Mvh8MC2ci+a8HLH9nfb/ceev6trwzLZP8Qeji53Ni+BxjQdVCp2oaArcq/Z +ucpbF6KYM7SLXLadsSI1qZqH1A7THZsokxZo3bDGUP6i1JSkVohMz4+jnChSw9vToL6kDBCkaB3I +Nl0f2O5O0oSBfRs3TnkloVhT0eFZFn4wJpXjog0cYrP/GGZwc/aDHa5pLnT9MaBsvn795NXPz979 +tje7NoP5zuG745sf8+GjMu2Y1rQ7eBnEe2njNMjWYbpstY8Ozr4R5SZFe/X22XDn42zzVZgdW/6u +rI9EpWmSOk0jWY5UpRHEB+3+zfHlT+vDT7AGSO1KzbGcBcyX5c1WR19uzn8NeoqyQ4CbpPRoJhLl +nJdSlosanaud42+Xxx93T3/oLd5LxhTWBly5d/wp75wDIrz00A7WUXZyW9MEid8YDo6+/fEv8XuF +DjVrZrpL+KBW76YzfBMkh5AritpP0mPH23X83bRxgSeUa/b2NinatVi9tP2xiGQRG7Lc9oOlbo04 +BAkdiGJ8fvVhNLvgxDiu74+Wb1v9x3F6YtqrSs3f3pZKZc33JsWibJjd7ujR5vS7H/7s3129/gf1 +9glwQ+a93c3LRhtiHvxFNhtB73ghdaBk1E6lapINech+41ml6m8X1Crl4a+G0Qn8nqmHQdDxghGI +j2bInt4PH3IPHtC1qmNopB4WyzkUbWhGh2ZSjm3CjAQRnGOnXDJNvWkajVpVKReUSskybXAo+b6q +orSD6DBvXdvBHi+3OSG3vaVmjQSlDcjyo/3u4Fl/9iZuHdN8UijqgpArGvzyQHfITj6twZWf7OpW +m2M1nlFVNQ6iGXzlgnxG8/v9q59EfQTe1PQ4jQdpCiSHNpvDdG+Ov/nix3+yuvzGSjcQD1Gy8sOx +JKdOsNrZ//j1j//yq+//1ebsd2SjMD7KG/thdqCZQ8SeFx044dFk+WWzcy2rHZ5zkwRgtecGU9wk +tVeu+jSXuMneYu9jo3vlBNPF5mVrcCEoLSCbrA3i+ulo+aEzfoGBiuPxzes/2bv4TrGHZrjy8lMz +3Ljx+uD869nOC8PqNZt7i/13fnKY5Fd+emr5yyjdnc5vDk++NMk3+4a90c1g+qwzvMJoKMYISrhc +sQx9GIc7DGPBr0lARW2Yty8texnFB66/otms3b0MwhVF+aLU0u150rrqTl+Nl+8MewgsxYltjr/0 +oDzJzofzGpOjRxyfqGrbtrrlkhz44073IMmW7d4FzC8pSFEzIn+UJSuISZ7PAN1esGvZU0mGBWiA +98tlPU52bWdRLjtILsgPwyZ1x2S1S1FmtSLk+bLbP6fZ5I/IXn8mwwDxHJ6rs4i0mlsqK+PpxcnF +J9D9wy0FT4DW0rWRpnRZ2sfBt7Y4hg44NlONXrEo3X5sGoF8NWtpuCtIdN1dBdkpfF+N9R1/2Wyf +r/c+7Z39nPavaLFeZRLNmLI82dxVN9vzndcvvvrH67OfvWRTo1Rd9gw9NS3EZD+qb+q9y7AJZjyw +vZlp5YYeampg2u0g2QmSVW/0GIYx6V34rdMwP07yPd0EZqYwy93x5c2L3zx59Yes94zjG4besZ2h +KGfQwM3Oo6R+FmXn7dFLPz7mBPjfIIlIPa9qTRHEyPF2eL6pG6N696LeJns+O25/tnNt2H14YWSN +H+3NNx9Hu18F9RPMexiOJsunUX2XEeKgfrw5//7Rqz8AvnYOP7nBAh5nMYOHvWb4uuPvT1df3bz6 +k7cf//L82W864yeikHRam5vnv5rMrjkhImXpmFBWe3G651gTQ21RNa3RWK8PPjjBjm4BLjBudcvZ +UfUpeoE5hWiZz18uN++D9BD+TjVGNVKBwrXt8XL3paJjJKeINz87UUwC1BD5ZLf8smabLdduWVZz +OH4U54eK3gMG2g4YMC4UVZbLBDGvAjyVtu+vDGuu3O5GGMcrSe5Wa4hnHCpDFLFCA2+qWwPL6bW7 +Z63OJYb0swdsjYow8qWyU61FrNjkJLiGKYxSPT8Aq3JMIstdnsvxs0rKeZiEBaRmnO4LQqPKpQ+2 +xUpFR5BYzggwPpi8fPXhH7/66p+dPPnzrH1FMYFhD0JIpmDuxgdOehLULwbzj+vj35B6Q2KYZLO4 +vtPsX+nBfplvl6pRnhyulm+6g0tRjnWzYTjjMD08AMuMnzC8U6UV8GaYQZCTEkUIad8fz9cvd8+/ +9fIjxRrzUgvdhF6S1CzPd/L2Ud5/gjEHJ9IMZs01LQI4ujXl+NiwRs3es9bgtRue6Ga/UlW2C4wg +Ja6/rlFkt1vTGmOKSb2SfJNlK1XvCGKGIMfsGM7Ujfbbwxfj5Qc/OSdQw7pA+5tnv0GY2cFYNvqs +1OXlrmFPeiPI+x6c74js4Pdx9+DlfPXcS3ZZuQktUa/vj0dXcbKsVA1INSg3WR0ZzgwCabuglcpG +lq4WO095ISJ7GvCJG6wOz74/vvgZgqdSdQ2j9/z1bwCAgFPNnJj2st66yDsXEVmhalarVprvdUeX +otbcLhs0V5f1CRSg6+1qSm5peRKOzx99ShqHNJ9vl2zFGHNSV1AGje41EUUlJYuXk/Gz2+1xvK0t +qVBQBKmtGUNBapRKBjIrb58M569Gi3eWO1O1AYINFA+YNawdik4tc5K0H3XmL8P6IbmOiEtqVReB +5BjTfve0UlHIx9YPJU0ZalqPh+kTEygxEAdDLm6pA/NtdzCYXO/svd45eLN79L45OAf7a/rA/+Wb ++O5wsnxzev2nm9NfTdYfoVigE8iGHl5X0vIgOah3IOwfJY2X8+XXu5tP9eYJw3t4ghfBPLYVYs1G +ktqK0vWjp3/66qt/Ak6pklqNnuP1NXjVYCduXyrWbDh/vzz4znR3YNVXq+t295CTcga2l6vDm5vm +fLb8MFl90q05lAAvhI67AHARj8YlvJhD9HaH1yfXvxGkriK3HXcGqa9ZE3go6AfDmjgu2QCwShlI +LtiN3YP312/+oDs7xYpdpRzD6tTzfcTA7fUYGwTt9eu/unz2pxaprWNASU7m15P5Y0jfZucyblw1 +h6+hNjVzhoQtllRSPyVaVSpmqaTzYlPSRlH9sjt6/8uFRtWqzvO+5w2gWEQpkpQGBA== + + + vGMvHWeFFCBXqoi5AzssNSS5ifxChNSYzDDare6BG4whrlx71Olc9sfPQfGi1Bb4SJWSwB+EYU+W +A9fpI8J7g4v++KkbbmR9vF0walVdkxNdbQBARClXtX4U78XZkSS3wY8PHwqOPZjOHhlGs1jSwHE1 +pm6GR63Z17ODj0m2Zmmz29zd2byCW/zsc75Ytit0IhsLL73Km9cMBe3Hh8H09PTb7S3p8wdMqWRr +5jxrXwhiHVksqw3d7IXJMkkXcKBe0FVIaYxQlvM8P+oOH4fprm52wmSn0T003QH6jpGUFZLObrSj +Wl0vXKWNMz858dNzqE0oB8QDsixI9/LOY0AQ1HLeOXUDUqy2Pbhw4nWFjSuUp2rdvHXkh8t252q6 +/mQG4OKFoPVqLBA415yJYg4rFEh57ccnUAWKOsTgwHZBSiG2EbFQF7WayYkJJ9Sj+Nj1971woxgT +io51YyDI7QodKeYMRB9mZ3BwiDFSZaYiI4Qsuw/gVY2u4a2tYOOnx43BdZXxt0kNRA+mRlTg9Htu +uEaou/58vnrdHT7x45Wq5LBjEPDwZRSblaouy6WAxyA+gd8vldRa1ajRLsvXTWcVZReVWsRwiSg3 +VLKe0KdqOsc6sEVQiY6/A0MEcQtIEeUOHAfsA3Spoo/D5Hi8+ArjD+1xW8bLOTt6P+wfS2LE0D7g +UZYy5fZWq0iG7B6sLv/FP/9vA79fo7waFdBc7gQIoa4okG0oaFpP62vXHVOUh7OtViHMfIgowyBF +samaAYun6RPL27X8jaROy2WD7J9WMzyna9mDB1tipeqljfOwcdYe3gTpaakSfv5AhGazLbJCQlFu +o3kYZ6dAXYYltgvZZJht15s0WscmLK0G6kx+2TlBketBuEzrh83OKdDGC6ZeNBSVpEbK59mGMSLl +Y4K5YXeguBxSonfhp4eS3CP78PirrHV+cPWrkye/z3vXmHrbG2ESBYScnHNii1cGprOTNU6bvbMw +XtXzwyg7YsS6Yo4FQLG7qnefhY1LcBaUiWFNLZdc1EeugaRjWBte6ITk0q9hYZuvlhXHhXIODXMh +ysNKDWeYymofAclJPbzECQ8Md20H+xSfPSyqWyWlRjuWNZTERJUT5KafHsWNMzvaF/VBlfEYPpYh +lZ0J+AsBnNRP28OXre712dXP7d4V9J5v95CGgD5SZRXkYs4b7Uf7xz940QnLNcplk2VDmgnKt5cl +W+5Ktxdx/Syu469RsajStKdoLVlrV2mfl1uwujCYQXyUt65gRQtlsoe8rPQ0ox8mMMtnFVLS1Hf0 +Qb9zYuoNTDdds8nuzZRTKRuVss0xXhoMR93D5fy8ViUbYZH6GmoXlhnDVSoBnWieD5vdK8xmqahq +ahfIAAOr6X2Oq29vi1sPaV3NLXvOcFmtFtCQE3RIwzySmm4ZQrFYNC1zNF8+BxDRjI+7haIjiB3d +mGIuikWr1z34s3/4r9vto4cPpa0tR9EHgpgyrEN2oVHItyFUpYmopmh4xlzTWqrWtN1+GM9df6ob +3ZQUrLyAJCNLLmQHj7qk5JwQsJwvy5mqk2sJOCFTtVaUbLrjm9HiWXfyyI0WqoHx79BsUKNc2GFd +HyraxHAgpzcID0XvkJplHFlFHC2+zHuv651XcePGcPDCriw3NKMLEscvzfbTJL/2ggPc4OVpLiwW +ZIENAw/yOAzCgyS9Mqxd4FuSn8XZBSs0HbuHnBKkliD3dAfBNlKMWZafZ/UzFtGoZKenby13BPlh +uBvNIZXrk3zj+FNehMvTPX+eN89EUv0cwdCnGPggFbymqBlFW6qWg+wUDd0ZIoaLZbdSDRV1lGan +yDuoLIoKJLmDYVH0kaSA4NxSxVWNaXf0otm91PT2l9/8xaNnf6yaM0kZqNaUEZtlinhbRetRBPd8 +ZJxhr6AERC6plM2HW8L2tmZbE2ARQohcoq6Ns/gwjfd0fVAmO/WpNVJxzy0W+XJRAaqIKk5vBGyx +nDnNpNvbys7Oc+Qp6BIWr1iyGSrQlUYSzXCEzx/wDx6KPF8HKpZLTmFbK+MJTN22FmGwA9YuFOVK +xYCagiqD1hXFFk0nHBd323vr9QtRbJZKvunsE6MnNGgu46QWJWTbFaOI0aB925rlrRMvJOYIkoki +tWBMTauDvLqj13n7qWZODXOs6v0q5W8VpEJJZ9hUUjqwyRgNUY7IzkJaW7enqgF7OzadMcXHODiM +jyw1BQFJbclK3SQVsef15jEpT2P0car19kVUP4JAIvufB4skP2h2rlRrVCZFuDyYJrJLktxAKmkq +jM+kRT5H20OQV6s2OqjDJckgyrZhDk1zDE7Msj3DHJB6ZEzaHb9JGo+98CCtH6v6CPTkWb1O55Bi +PFFp1VtXSeMS74VeMHxSqKgQoqo+VpQucAbigaJzimkgVSvVoFjSacZttvc1s7ddVKq1wAkO4hzi +4TxtXMCOlW+3Z+TFBt66VLMgiR1vnXYuZmuyGAIdi3Sup/Nf/fHfnl99Cd8nAbucpWrNRLXrQ2DU +D1k20fVmo3NcrjjlioXcgRCStGmQXmWtm2JRc/Te/u5bUUgRSDUGAiOusXmj/3Rz/G0QLQvbnCpm +kpAhnTHs0N4QV1sFkxN6Uf0CMFgsGjzXQO8wqhgKTW2Qa0qFPGue9cYvKhWHqoW4iTzGeQ/BzLEp +5Fal5sLTQUc9eMBVKq4gNl13AXYzzRFL4hY60zOtOSfCwe0qxhw32ZjWuLRGB2Q52hxDF4lKx7QW +UQKDPIS/kJUG/KkfrAfjV/XWI17qM1ybYlq80CtXgxodQ04IkBN633Zn5IJtvYPjQ12TC1DVdqP7 +yPZXELcc3qWGAFZlOSS0q9Qtfxzl++PFq/bgqUI+XMuBkJbZ6Q9O5zsvmoMnkj7A436w0LU21BFE +qWv1dK1umRkpGSOnEKXkwyatLQhxtWKC2dNk7TpjTWtbzkTSBrzcAwvLeg8nyXChafVxnlG2D7lo +2jMEgGmPwmTNy7AMGTRwa/AsbV8gWjRzeVsCEjDSgcJEBgESbW8fR5O0jhfvVpnw888pAGBWPzHt +CQxguQo00AE7y82Hnb2vELScEDfb5zhDIKFqdCo1B6Ki0T7ZPfxw+vS3MMvo3XDyGiqRFeoUGyNO +AG7FkqXr3Shd1m595W32TQG/vAh155RKmoDIVzulogx1R/N1UYXkWMb5iXpbUxu2woLj5lIgjO1A +La8VZQLBgAg3TbLoVC7pLJ1sbQs0UtKZNftP8t7Nzbt/+N3v/m138PzhQwVohluxoEOYAd+qVYix +0WD0bDR/aZELqp315n0Qrlm2Xq6FZabOK50k3794/MNf/M3/SHY4FNucALE6zRqPLWeFIESyIJAk +pY1eWBbk6wFygeEw+BPLneiknMoUdq9Kp4o+d4NTLzipUgm56IKJOSGBLvKCDTAHWGE4E07MWYEs +oLUHj+wAx8cEgUwzVUW+4JdQkmLLG4b1zfr42zgHQE1Nd6ooDUPNHKtpWiAy8tlNu/+o3jjlhTrH +hY49sswuw1qlEg11yrA+JmW8eAMooNkQ6WaQL+N0GdqGGlGUlheu8+6TuHkOcKhSLiYaocUKkWYN +RLVHdE4GwDkM0z08gVx9ESxag+usdQHmQtJBStnuBt6NZUE0puvtdAYvdXuiGD0r2ClR4YMtnmMC +xxlRlFWtqJWygve1nVlv9CxrnNyWY866w1PHg1JNDeCSMgTXQzAcP/7x6uWfNHuIuunB0UfkDoLc +T/Z1e450VpQB7DzDevDCtjP2/CVUHOIEKo4Xcknpy2oPKujhQ6ZYVEAcpYpTqXmcmJH04TMYgbx9 +JcttyPUwPFK1qUgmN67V7O0tenubY6hQFnuAX1nvt0fPz1/8+fL4+/HqHbRltRo9eABaJF8NgPVj +mciyx0l2NBy/hMEE+8NxQJUdnX6bZofVWsgILad+tTr9/uvf/NPf/Nk/++LL31NcLIgNyDn4GstZ +AGQQVLfVRVeWt1AM8F1YqgYVUjyuDTuM5MI5w76JahvIKdyu29OECtuISU0fQBqxQiJKTXBWSkps +PNfMEcUmqt6rMR7FgigHqjbXjAVyX1KHvIAAaxvkE+06kE3WJ4PZ68HiFTL9tl8xVBzLh8AZTkgZ +DgA1crw9x10BPeDjymVZU5sSqXiLkRwZ8AXNR93RF6raq4LcC5JMeLMhSIlidFR7ZHg7TrBnOguG +D6s1ndSNSvcnq3f95RvNngtKlyx08JGiN2WNXNUGOwkfMVx8NVp8JcitQlGqVCxJbglSStEOlAMv +dU0PAdlTNcxyvLXFVcoqQ76woJMvshmAkRFeaLojP5oJcmq5g3b/RZI/ivNjN5zCAYlaC1Dp+bNm +54RmfY5Po+zEjVYAPY6tV8pOsaRQlK2pLbjCrQc0SN9xZ6Y1o7lmsQLlZhNFx0CWyFvbEoSuorY1 +HbJqRzdnstK+rcoK2PELBblWdRgmrlFkk0OYI1UZ+f4hZsf2l1601kzQULxV1LeLniCNLGecZuDl +nXIZw1i37ZEoN0GphbIj613Ln9veKk6PgD+AL2i5ODuP032yL72S16oWI7Rldaxq4woJIQc3iolc +bwG/A2x0M7JeVKWgkexiGXIr0a0dOzwyvbVuLzERDMSe0EBAsnxWpQLcwHeaQfb4FcSEYV1e9Pnb +JCLfF9O6CEX4cVg5KNvx9O3ly380O/4B8hUCGJEjyXhtRzFalj/rzd+l3Rs7Wkt6HzBbg8yoeRgQ +EB/EsCQNbffYC6/i+pWoEPAvlERN7/UGz5udG9vfY/imoPThghv1A9seQOPBlvZHTzrjV4IypNiM +l1qQ2a3uozDegfDDX11/uX/87eXNb01/TgsxxQe2D1u6A25C7xRtkDav8+4LNzxCthaKYrVmQH0B +ZJAjeDuMpOGsZX0KsefaQ+CMLDfT+mZ18Lo7faZau5zQLVdd2DrTGtwWznZZzvWD1Xj5xXT3w3T1 +npc7CINazQXqIpwARJWyS9OZ488EKauC4Aoy2fJRbopkmz6+WNTLFd92lr3pM4pPCyWtVNEB2hwP +r2Tj+WTZakthbxMfyQ56Zcj6ecewxrd+JK3UQpptiMoga16gp9sFDbax1bludp/5pOxFBH1bLCsV +UqejTVedhw95iopa3YuLZ9/3ZpeiPmaFFsOlLJeH8T6p6is27GDTm7xerr/nRJiXkaRORaVP+L1q +lyoYk1avd73a/3bv/Le92YcKFRVKFjkxNmMBa3JL1Ia2fxTVz+P81HTmwEYiDMp2jYZn7Hr+MaTa +7e76RD2Wq9ZtSZ0QiAdnLWlDSUWOd8JwlTdJsXtQbRAdt7pP/GAXhpQTfNPuJ81DxZmqziztPNq/ ++n3ee0Y+lSvrpLg2F7j2PEnPYCUsf237G8tZev6OKJA9xqs1p1J1gcD11pkX7d5+4D4Q5b7rrWAT +aD5nxY5p74wWHwaztwhCAA7ZcFiHVBtn+W5/+sSOdrvTF4uDj4uDb013jaTG1DSa5w== + + + vfFLxVhy4kA3J7qJXrQ4kZT14QXM/u5o+f7s2Z979VOKIXJClKAHJobdM5x22tpzoiNZJQsjSCsk +V6kMH0fWB8gW6NHMj9deuA8JZJgzQ59UKl6hqFKUz3M5+SmkSEyAv+0tdWNG0THQ6eEDytJ7CiHE +DAkOpdEePB5NXwDQapTGck49363nRw8e8gB/QWpU2YSXYFH7ZGm3eLsHpj52/f0gOsT76iZYoFWt +xo6zgcuuwZpti3gmxooVe6C/GpWWSvb2tiSysWm0yYcaSsfw9yabbw8vf24BBMDgchPyfr55l+SH +IP0yoIBvmc6eFx8BfKq0j0iQpGazedjrnfWGTzC2pUpUpVJgF7ClUNZqbCCovSA9b/SfBPmRas9k +9Jdr3Mr49NZitBQNgLwSlQnLt4oVUucIoKRbw6R5Gjcv09aVaU9lpQWdwAlkFiwXwngXcAQQtuyh +ZrRpPgDkIh/3zr+7fPtXbnKI6C0UtSpZwevpepsh6xgOuCZMTwHFnr8ulWC0VVhyhg1ltW7YA1ZI +gWk+WUeFSZzRTAzY1KyFbs39aCMoPbgty9u3vR24Bt2E4O8ljcPe7Obsyc8nT/447z/hpAHF1qFd +PW/ndiVqYvsHjfZVkB6Ieh+et0ywKw2jnRRSLTsQjQmv9DVzFiV4011ehkvqT3efme6SopMalVTp +RDXmMKcEqLmkVJIEMcqb+2n9yI9BLj2KhqFLeL4RhJsw3KsRQ90I4wMn2MjGiGWbhaJTKJocG9v6 +kKEDUu4Hnq511hs9ibMjiOca44bRajh6EviLzz6rQogGyTrrPPbiC92a0nS0tSVVa16SHlv2jGUj +hkmhJG1ALvjR23fcXcBdpWwJQg7VUQJiUBGvID0HPJdJXCrCO2g9J1g3+jf9+esk29P1kUKopF5v +7C13n7NMAESFGWHFlmLNaly9VPUoLqO5uq4NBDEW5RhMrRsrWdnhuF6NrlfpqFjRRbUj3V6tx0iZ +bI4b/ee7539ozd5B6iCuQD3Iyjg5GU4+uPH57ecvOdAMiQNUvy0xPzO9DaYbWo4gs9KuUV6V8hCW +ij7I2+TL1zSbILsnixfDxZUTDWSjC9CO649ARpKc6XqrRjtVynKcAV4Loq+QheWQrGYLeaNxLBtN +2+3sHr8P6jBcDUntk2+aV9waHbrhjm5DpaQMn0LA2+Emqp8R6cUhL0L02vFGQTxwvJ6otkD6O/s/ +ps0nmPTbUkeu5c1lvcMICStmcfPw+Or7zcnXSbZrGi2oEddbDuavZIMkFMXksDmWtztavM6awAGX +gsDmcgSn4a4Va15jMeBQSrqmd+JkBfujW0ugou0drPZ/COMjCGBJapcrUFl905yJEux2k+NbqrZU +9ZXjbmg6frjFV6qWbowqNR82SlAGnenTfPS6M3qrm/OtbWVrS8bIw3ypxpAWmjgC0iqIT1wQhNqH +KdguKoLUAauq2pBmUic8skKATAc0yjEJMLNacW7V+KBcdktFq0ZBz5DP/SEkZLXJsNF2QYZ/NIyZ +7czJxx8ikDZsNk4EyDzarQlplU0ZoYksVrRFnJwxbKxqXQORoA8qtXi76FaroNRWEB/EzVNJ73Jy +nXx9wF4MJq835z9lvWvoDXIdC5+RWRPrImSV0DGcI9s/N92NakBgJLdrsL0kO98/AyZcQ1RDhpUh +8FjocFhyxFgAJV9vPe+PPwTZHkcuA7M5PpLUrmIOGSEtV3WaS7zowHQXstp6uC2SK46qpIYaGB/U +wKBrQo4ED7Jj2Rpvl0xeaCHvqrVYlNowgCA4WR9nrWtY9ULFAgiHyUFcv4TeCOKV6494MfKcQZZt +yLqEOy9T0XbJKdcCQI1mDinOK1N2XN/sHr49e/LD7fXbTqkCIRp67qLZPufFHI4mig+z/CJtXHjR +HuLnwYMqRbmaAQOb0EJuBcf1zpvB/GvLW5HPrZhwuyDRjI8pU4gKCgrQ0gUFMOt4K9ud02wEhG91 +LuDvtgpGqRpRXHOrZGNqoGyDcM8nV6ecwSAzQkbxnWItLVRiSZl3R68a7RP4C46LwFP7p99dv/qL +Vu8xvNh20dguWhzfALoSs1bxdGv26ut/uTj+SbUXhZJTLJiGOW13nkDl/tF/Xv78AS9Kvc3jP9+7 ++JUf7uI8wTgYB93qI7ArtQhSQdLWzf4X7777+zh7ZLjLGo+TyYEtjAirAt01V4wdZEcY75pOl2JM +zHilGvNs17H3Jot3RrCoMF6arY8vf+TkjqT1RaNbhYYRepBtyFPV6JOq0EIGTdsbfRwvvk8al5C7 +kEACnzrwsMnai3CQbLsChdzzvPNm663jHxdLEJ8+OtgavEyaTwStV2aC8u01IWS0S3KhqPB8FmeX +efcZzrxKe9tFlRhtNoEEhS7VnGXee3pw8aez/e+d+KiKtyiYitwrl73tbfLpCYaUE9tBcnr9+q8n +q48UXJI1bHSv6q0njr+BPSzVnFLN041xSAoxx7APZDVMHdSbl/UWZqRP1mEEggOK3hWUBiviblOQ ++6LcVdQOsUIVm+Hgp6YQ+TQb426lavN8ahgj25mQC4+tkRcfNwcvs9YVWLJAlsSh3n0of4YhWyFB +rhcLKi/kngervob7K1Ugn8Ik3UCcFwq6Ya5Wp78K83PTWqvqBGMS+dNB/4DnnYdbrKhOTfckbb0c +z7+1vHW5Zm9tiWmye379g2bBStifb4nFiuf4+1DLwAqYdMiqiHyv6tANdkpVC/nIigNVn49nH/ZP +f+aE5oPPyeoovIxijSFLHj6UYQEQNqqJ0TuDQatC3g+eYVRn66/D+kWxkvzv/4m0J/9/n8D/V+2+ +I3et3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty +19p9R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et +3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty19p9 +R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et3Xfk +rrX7jty19uR/+0+krYX/RNofqerkw/PxzTc3n53NP1MHi/Qa9w9uvv7mxafP1p+p1/7g0zfjN8++ +efPlh5tPPwpNPBR4USL4By9uvhCMX54p4EnC5tObV28+4MHDZzdfvDAFB09t4f/Pjslxc3Lc4adv +v369d/MNXvLhlweHL/Ca/9vDxvGHDzfvXzwXbh8V8LAQRan5WSAM8P/Z9+SXF599i39CIbj97+xH +3Fnil7d46HshDIRd4fJRIDwnzz/4zM2DPBFuf7wnd+LUq2e/3F/9x/d/+Xf1H57//7x/+/wP/9fb +45+P/+EsQnIWt8M3ffPFi+Yvv9527v8cS8MkZzr7zB+/+O7NsxcHs6Fwtv7sUnBvR/O2I+SX/+h8 +6pEX1+thJjwSoiBEtzJyhNf/b19D/vzvX/fv/82FGGca1m9POhFuj/GZqt6eJ4mBppDFjSj87Gzx +nwkSKVrC8pGsthSto5CqLC2Ga4vKWDWnotzjebI3vyg3HXehm2PV6LNCVmNDvIoTM15qkCrKXKhp +TdMeBvHSDkiFLgWv1Ua6vaLYqFxRymWJpixSWsoe2cGu6a81eymZQ1aqV2nPD6eWO+CE3LSXnr8X +paeyMeH4tmLOBbnLsGmN8nmpLWlDRR/6yR6ntAtlk2ITTmrQbFCtuRyXWfY0To9Nf6mYA4oNOanO +SbFiNKqsI+nNIDuMGo/qvZd2dIiXU3xSY6MwPsj7T6LmeVg/SVvXprcW9X6NC2WtJyoYhKRSc8oV +g+U8XowUtSFrrXLVwHvxQqtKRzUmprhUICXdhqLSVvW+KLc5sVOvX4XxCSf1qkxUqjrlmkuzoeMt +THtSo90a5Wj60DCnpIweRYoaMWxk6ING44zhE44UleqXK/Z2QcFfaTqmGdxSWR3L+kSQh4LcL5Jy +QD4eZLmc43JFHUhyl2YSQWzX6IjsSM2lDJtRdEQxoa6PLHNKSu4wWanqbRUU3Iolo1xGRyJJrMsI +AMqvVi2ODYpFeWubL1X0KuVRTFSjYl7o8HwTR6tUcea+pHZpNi6W5FrNw0kWizrDpKLU54WeLI80 +Y2qYo/H4cdrYpWiT5XPdnHnx2nAmVcqtVkyGTnBASRtzUqdCRZWqpyhd31+5zoxjkyDYUfQezccI +CZbPVGOqmTNZzj13UKkauCE4HW9Ps1aiiuiaIThJQW8pr9VsXsycYJW2L92YlN8UtCElpLzYuHr0 +c3f0iBNTlk8tZ52334TZY1EZ0VxGkULlAcX4pCI97aO/pPavOqS5nObq5apTLJk4bTyB1CbSOoxQ +5+W25a6y5pP+6MXm5CteTWjeN5xZkJ+3xm+i5iPJnEv6GDNyevLTYvOBkfMK5Vnepjf+UO88l/SZ +qE8ZPq9RHoaR5VJShrFqbxfVKhWQEtyUXyhidjSaTQQEvNoVMOBCg+GbNNdkxQ6vtEgZT6mHMUQE +4ml4YY0OEKilskYqrJL6mWGNcisVm6r6NBUgwBBIHFtvZqdZelQoKIVtuVw2C0V1a1vEJKKznNiT +1RknDBiuq2s7hrEsVxxSFoPLRKmDKQMgMBzwYeL6G1ZIHxaEB1ssghOYYlkL05gjWcjRynatRnY0 +f7jFFgsix0SS1JeVgcDXtwsyToNlk1JZr1RNxFKNSgolr1qLKJqUmZLNBQGWqoleFDEIRZVlsyA8 +ieLzMDxVtVE9O/ru+787OH//+YOK6SxJlcX+tWKOyVbiSCKG1M0o12yyN3YNw5va/txyJiIiXGwc +Hn5ygnmF9goVXRRbWeM6ql+JUkMQo0rFuK2PNAfCMEKT4puiOna8TVI/NawJy/iOM663z5x4KRlt +SR9g5DVr5kd7O7tf+NGKE1KEpRceuvGxpE9oJuelDsOTeLvdX1wpo0eMjwTkReROS5SGQDZR7HNC +VqVsUvNEayLmWanhR0fj5XfzvW8Hyxeskkha0w7mVrg0wh3RmATpeX/8Nm9dTmcv6+0TIDDHpY6/ +CuvHhrvDyQNBRRf6HN8AvJAaqmUDUFAqO5zQvq3u62CCSmWT48lm+WXKK9EhhWnlB7w4dsJTXm2X +qjrG2XTXlVpQLFsPtzXgDMMmFA0ECwBTNEN+UjW/XDKKBbVUxFS6VC2wrYmmDRBRhYJaLGi/FEIv +FOUq5XNi27B2FW1H0RaOc2hZ6xqFqOjQpJBRzrCYgiEnDkx7nWRXgtJ+WOCLJYXlSEEwUWpzXB1Q +gNO+rRMbPXzIIbQqFZ1lQkHoszwgNKWoRJJGhj6S5YautZAI2yW7WA6B0hypQN5kxBED0OYTHHa7 +IBKs4+qqOsATBBGU1/f8TW/00k12Pn9Q1Z1hlJEiAzQpo9QBGrB8o3xLBEgrjIAg4Q== + + + gHWaTHHdMcer3TeK3qkxAS/mCqlbMmdFjKQNABGE3LanbrBkuFQ1+4LaEdU+h7xW+reVb504XvfG +N168E6Y7drSQ9L7uzKxghZ+i0uXFVp6f2MGsWNVLVYtlc91YCGIXEwoMITUTaMAX0t8pV70qlcnK +BEOt6qTGEcZWlFqS0tKMvm6PFYNsou9nZ3a0xyvtMD0Kko3mjJ1gpjiDrP14d//H3uQNxh85AjBx +rDEQdbuoIIQse9Vov8DsWM5KN0aC2ATskK33KQ/YVSybiAGGyUBAvACYSsF6FGZW6HHCSFZ3guQJ +Uobmkig6NNzdUtUtlKxCyQZb4SAAPYaLwGKC1EG+16oe0KlacXAjMVZUGfCa0LytFGQUS3al4iIS +HmzxtxXMEkUbVaiwXMGZ+JUqIDRTtCFGG4RIioABGOmAFVqSOsM8AtNkuc2wDvAHgV2jAUcxEJIH +jbLp1pZcLtmlkv7woUBRdVWb8sBboVurJbLUjcId35tuF2WcfKlCuK9aQ2x3VXPPj48dbwfgtrUt +lUoasGtrm9veFkUhbzfPDXvBSt1yzUNG0KxxW1y9jzkynDUrdhmeVJmGGNC0Nk2bHBcKckcx5o63 +74eYyi7HxyDH/vg1w9Ux12ANUhBDI0XScBwkl+3sJI0jqJ3tsg7QA9hq+gSx7fhLy5vX08M//OZf +nj39kZVTRoxlA5JsJ4iPs/yi2XmkGAPSCxyZjjm+q+oryzux3GPD3sPTOL6uKS3bW1boBGRdpRKM +pGnvGPZKtZZJcnRy+v1g/KTKkCrlXnTY6D5t9l80+s+dcBWF65+++ZugtSrWbJqUZethrCAPTHMG +eXOrUhyQi3RbgQ1Hxq1GiAD6p8kKja0CWybVw2KapG27WHartZRmGpY1N6zBVhHYYlWphmrsWe6h +5e4p+uy2qAsEG6bGKpdVUvqppFZqtgBmkXuYQZbJqtWgWgW5qOWyDgIiAqZkbhf0UtkFTiK0wCCA +rCIApCg9eEhBg5VKVqXiU1QEoMAUIGZAi9slpVg1aS5G0BrWSlaRFB0MOzJaEBA5AxwcOAPKKxT0 +QsGoVkOOaVTQi7LDMnGhIALEHm5JoC08n2GiLYKWGgOxR4OPHF7EsDQ4saUaMwyaJA+gwVgG2CXg +hRSFV2XFir5V0reKBno3GrwsVRToUmgGUghFyFmho1vrNL9O649dd6araaO+TvIjSesjwCCbRbXp +ONNGftboXlep0DT7mtGDXCSqQxnL2sy09xqd53EOHVuHLHGDHVHpSASUOm6wSZtn49mLT9/+l8vD +N5ycqdbI8FaGu4Jl+KVYmagOEeQAOuSFqo9sb9dy14o2NawluNJ2d3cWX8x2v6zQaZVOBamnG2PT +muG1ujWP48Ne95HtzRmBFEyWlB50YJie5Z0b09sJk/0PX/1VvXeCgK8xEbBOs+ZQ7EBU6GEgAMWk ++B2UwTIRqWBsToFLhEqEjiD1K1WnQqZbw61cBp4DK4aAzXpOCg4XShrihGFzim2Q6iV8S5SHsjLk ++Q5FZfjrVkEolRVoUYrygEuGPlaVviL3dG1C0Skwigar0lGhaJYrpHReuWwhxkolEzPLC41KzQW7 +bW/zFBUWi9bWFhhTpxmQEXIWItkHcXCgLb6JSBPFDvFfQhthRqZGaMpyF5oZx4R+wzFx/ggtiK4S +9DxwqWQQ9V7StrdVhBOh46L2C1IhfkSxDXqy3RWkGuQ9YgyHxYRyfFYpW9BsOCApl82G2xgEoSHI +bUVDHMalskqKxwIkhQaZC2Mnb73ojN453lpRWqbWXM6fDSZPeCmXtb6i9013Esa7rc6F5c+LZduy +x4Y1gsaLk2M/PPWDc+SsEx6LKuItUOV2q3depV2ocVHqtjrPR/N3s82H6d4XejhVzcFw+irIjqts +/bYiSi9IjpPG47R5rVtLnJJhjUlxUTqmWIBJJ4gPk/rlaPZF1DivMi0OWktsiqQjgNyh7a0sZ0kc +Jd/AwGrGELKfExthcjxZfvDTIyfaNHrnrFgvkRxsQsXBiYB5wSOQ9IoywhuBOApFXZFaUbyB+UVI +YEYg7SxnT1HHVAXZfYs8FRczzpLqRn1ZW+AnhLHANTEOWwW1UDJAWzg33K3VoM0axRIpJVQoYcpk +ivbhwTHXUKqmPs2SU02bVmrw0e6tI2sjPCplmKmgUrXxkmoNZg0eOa7WiNonBYHLkMReFZxYcaH8 +uVu1AHiU1SEmHX4BkWBac/yEQMJdvJFlL0AfIHEwYKVs03RSLJrb2xJwjIi6ogEkpClSWIagYhl2 +DFxsFRFgZRNvxDJ1xBJEHc9mujosVhBRIqJxe0uqkdLxXYhS0G6hrGPQGC4oFNjPP69AwYqQ3FQo +y8DPEUl/e8rLzRoh5dTSB73+Yy/exWEtZwfam1fqst5wvJ6qg7NCslaQHEPx1vNLzVzAGtNco1SL +Ga4JHRsEG9OdlilLkBGZXcuda9ZIc6ac2mPlVpAeTVdfBdkhDXDQx4KKuN1xoyPL39ftXdhtPL8G +ccJniASKjXRr4QQnmr3Hq1MBXkkeQMkAbG+LtTYpJkbyVmoQMy3HPSR1CCkbeAKyRn+huDhSJ7Yj +Kj3XW6f18xob1Rgfsp8mFX0hsMEpJqQFZlBTB2G4SyMNt0Vobxz/1nRHFYifEiY9hLMDgOCnIPYM +60DTd2G9Ba5dIllMCroil7e2YdC4SjVk6DYUMpl0itRjh59FuAKREBi3Yz7g+Fa5GkI7IUgUZQhl +LnCJoXQYxn+4RSMaEVcMk9M0eCoHQTN0asBc1+wHD2tFUk0XiBfwJKGgSxFmtmkuTGuJ2QGHQjMT +nX9b2BCPFAoyThtvQbpAuIzHDQBI1RKazhBvODEIbFA/oc6STmqKlm3INmQEaLedH50ffbNVlD9/ +QONQPJvbUMtOl+VccjIlcLq7XWAffF4sbrOANQoJUjYhI6EwMR2VmgGnD1FtGlPbmpv2BNMK+2zY +c0Frl2saJ4ayUjfMLvAqzE4sb1llfM2e00K9SKo81RFgYXwcpUeaOSpTDuwSK2bgxxobsFIdDk6z +lnnnpZ+c6c6CEbMg3keYYa5JpWh9mjRu2uN3ZrjPq6SELOKKlfIK4+FVTnRhBRcGIkfp1VjEUhAn +R160ge8gPq5qIzHBSjh53MVMIVtBjnCXmjGO8gs7PBBJlXVSgw7OzrSnhrdTYcKtkopHFLWP7MNY +SaT2MqlgL3A53mKLTAGFSYQioilf4FLkI2YcqQ1krlIOhhTRgnlnWaRkhpjZ2paJ8AZq0T4Ydpvo +FgP8QlRTyQSygVXBgLyQ14hnjAnzkkKyiDdYUQgtDXFVo+xSUdZVmKPRLVOjj/bWtlat+JhTuLOH +DyscG0pio0aqhPkFECgBGVuRh7a7B0wmLFwxfqm+S+qCMjG8LWAKofLgYXW7wCHwYHh5DtRmII9g +SAFfBG2k3IVZFlq3qx/CA1JhW0NfeLEOo0SqI7KhqjYqVXW7QG9v1wrbdK3qqErPsacc59FVzXP6 +UJiA3FrNJXpPyssIA86TlRyTBX4ngwNzXTHJ4ps5kfRejbIsdygoOR4hCzUQqBSBjqx5YzhLqIIw +29RYFwNeua0iW4VqFbMw2fPCteWMk9aRZPQFpasYE3jSKiJByPPWk0bvKSuCkTt59yaon6v2Arar +Supz9qL0LG6dA/Sg03R/UWECUvmzTKqugQ3D6ABIiy6Y9ghhAK1C1G/Vp+k48Pfr+YWs92jKbXZO +zWhcqqnFqlVC1xjClcPxq+Hyo2RNWT4Nkw0ngXegRjQoXkwlaCuNjgxjXChJ1arG8/F2gUemY7oR +AKSuKZ9SLChVYrgQLrJGRZDWYKti0S4UMV9tGLRqzaqQG1kWqxD1QuJwa1vBk1V1CpEAx0FzYZV2 +MIkPHxLBU6mAnlRBSGpVSxKSNFlQLIAOriG8hbUeVYuqFSCnVSgIkpiztA/gAmdRVEyTMrYZqVFJ +VnQxPhnevVhWSxWdlF4v4cR0MBTkU7GEXqg0491KLPHhQxY4DIy69QiO68y//PS3ZHFsiymVZMg8 +PIi4BRWWcHAq7HROu70DBFW1zMuCJwsx7OdttPhAKoHPuv1LeDG4UcTtLeIFJVIE2HPs0e3SilYu +uTQVMaSocqqoXbL0JDXG86eK2Xm4LRXhPYkkDmRt0Ow8UY2xY8/Ob35drCpkjYuFj66LYkPTewgt +y5l2mkcn1z/q3qR4GxiAaFHs+sHRYv1ja/iSk9qq1vezA0pIqkwI5pIh4/1No/ssbJyl0e6LV7+L +musH29wtPpPa4EhG09oVlSHsfHdwA/1cKJjQDLiLv9rOEjaZlHPnG/PVG9mqP9yqAitIAXmprujd +2erdbO+j5sxca7y797rCWA+3altbrCDmpNim3PW9XRAW0kSQUpYLb+lJrBBIIb4Y0c6LCc3YXgTc +Dn5Z6N7ahteDw23r0GA8hFBsO2NJaT14yD58yMCng0duSaeu6UuR6IeY4oJiWb7FEw2YA7cFhESm +Q2659jDOlsWqfrssBqMBgRcRkipatYojCblrTxmEkJCqag+2DkBKalaDyEDcbNztXohyDuxCRiAU +WaZRvU06iHNElCzGlokYQ2hJAORSEaKLvBC0Dke5f/yxTBmlgigwIQwIsGtri5x8uQJyydP6oRfM +igVWYG1Z9BkKzgI+xRKlpmlNAHeKPoJMKoFMy2ahAP9iM5gIKdeNHiAdFFwpeywiRExIYpJozKNg +rz+5kbU2QJ4lq39I8PBWMGc0WS+dnF7/VGFsUazr+kCSWsAxQWpyQsYJcbd1ePPmT914p0zkaIrc +MfSp66/rnUvFHFVu2VyxB0XKktRmlh9yUouBERYasj6cTW9+94f/erJ8gveVxTYPTKM8hKgkz23v +2HTWUeMRIw9gxywDCg1IC35P8L7QsZoy8MLdKuNghHUinNoU49KcB+zllQYv1f8Pkt7DS5LizBf9 +Bx7MtClflZXe+8zKqizvva/uau/99HhvYJjBDt4LFoQTkkAeOYSQQGZlkbcgIYFAaLUrIbfS7n17 +3z33vC9b5+TpM6YrMyK+7/uZiMioQnLqppvfGwjLIyPBMKLqZhOQFmI0Oga1I4BUU7QaWB7AnBCi +BoNSCDGAFODO0HFNru8cvyOAglsn9takNPgZCllAfwA1utFYWrm2WF0HThkZCbhcGGQCkMvoOA3Y +CzEiqDSAA+g64FNAG9DG42PY6CgKio5nSopcI5nkmIcFxgSc3D+KAYMAKdNEgiaSPJtXlBoajhha +3ecXAXb27w94oeOOTragTk2rR9L2P2HQ7ab27CHt+ESg75Am8ElRyO59FzdIRCdzIMFAEMIFAYIB +HBkNgaMRuQrA49VXuUZH4OZgBjMAtuAawEKOjWFeR0pR8Gj4czBgAnbtLSJwQQS0rrh/FAWMAmYM +hy0EnHgoAm5ldMxJ4HEHuGgkrCOIwdDZqDVk5TqIfOc7NoOq31kRE0KoCUlF0hlOLA== + + + g4Wk2FwIjSpaS4sNMBLMe4Kk0yhhE1RC1WoEkx7zAp2JjuT2is6XDANDeVngYopOwzjD/YNYDCOT +AIbjHrh5TFJaieySlV0RjD5Cpjx+GYDXMeNedtzLYWQK3CiKZ0m2EUQzijpUtD6IK4+fh3hBC2Hc +3B5wW4YjlX2K2wcJg4yMBuBnGNqpDyL2MBJt2okOiBxQOCyE0hUaHQvCX2EoeL5B0mWcAr+pg1QO +hlS3l3aqCfwvk4ZENYwpO7c87iw5MVBQY2MwyFDd6Pg45vVyNJcT1DrJ5J3Zp4DocZMuFw6BgOgH +nRkz2+MzQOTjeFFWZxEs4VhCLyguCAcHwt7jdebucKpkRBfATThMvfcN86MAEeNU0Cf4PEI4ZJp6 +C5LB61UBk0NB4EfO55XBj3j9zroYwxTgd/aDzB4l4Ll+v/PdyKOOdCQctws46aza4IA8LJ1xPIhz +EXB5fRKKpSFJALJCQXCjIpQeeOTRMcqxqD6nMQxVBKJ3j7M8ld8/gl51Fegu5+u1HXHiBurHHAh1 +JjRooOMA9BTLAmwCeDqTHuOQWqbzBc5+SCQVqNbhGqFK07kAKBZEZ/ksSkR9QT0QjvlDiRCa082F +eGZbj8+DYcGJBNAowAjkMEA0kKA3YPqDFrA2PDQcirBM1huUKDrBMBmaLevWrKxPIEQcLDxodQwc +NBYNoRavzmn2pmAMQ+AWg5EQmgw78wyWJ8D6QRwSmXhqg5c7oXDKGzCgtMOYDdgC5Q/9CgZBxZVx +55ve425ngohxPLiHA6Ql2BRCRMJkDEHBkdmOrvY7xRhCdAQzfQHITx2cBThWBEsBCzuriuEokDVI +TejRnrXPkEwFCSfRcML5uvuRkNcDw4iPjPiAPb0BDfRkAImhju6SAFIgoEAQ42OEQ0PgE/1wwxSK +Q+7FvIEYiuUoMh8ISk567E2WQoyCYTsMTwfliSYEvukFwTOGhwJqCESji/a6gZLywZAdDEZ8PlCb +kDAgmC3IWwQFAZ+TxKbAlQEifB7Z7XK+MPmqq8ZBRI07mofYPwKF5kyluh3za4Ld8Dleg9k3ggKK +ulyiywXNlnWtAQGCrA4H9KDfWUgFMISOwKeA2tBQOqJMgdkcGQHBRoE1vnpfEADc65WcCTpgWzCP +PsDSOEUVAFKA+l3jPHwQwxIeZyqDcDs4YxB4TpJaMMLQAIpMWtFeCDOciXfEJpmGpM5E4+uc3AYj +BqNhmH1671uLIdwkmeS4Esc3CDILZDHuYiksFY1MeAIA0Qxwsah2M6VdPToL+eP1a4LSI9mqU48+ +WbWWRGMaIdIQrDCWFNW+EpmhGVDCUU4qoniSE+sBxHS+IjgETj9BMYUQAgNFgt4DYePxRTx+y+3T +3V5gNJskQf9kIE+gKBDCImhQVpUA+LuAOj5Oelw84yChOToeBhJkhBLFF7wBwCtnwpAX25LS9znI +KQSc1UCg3QS4+1Ao5nJLoJMRqCAfNzIaBP/lfH069BRYA4bOp4VDQAqW2y3t3xeC8gf5DWpkzJn1 +Ag7SKKauKDOi1Hdmiqh8GIUGoI7L8/KA6qgjqJK8UPf7hFBApHB7bBQZAe82SpFYGT4CjOnUPqhf +nwJiIxA0QDsBN/l9Jook4CcSsKHQrr7aDew2PuasTu7bF7zqKv+Y4zoBOlQAk3HAlqAFfL1vP4Yg +iWAQRi8eCiVVtUXToGktiasEA/o/paN7nIGsCwUi4FnCoejICOZ2nCYO8OVxC5I8gFHam75goZAh +zVzOQgPwsuh2wmQGAqBUI6PQyDEamAii7HY7ixEgxjyg96iSoLSdzSdeHiPSGJEJhCNgSUbGccBD +qB3N7AHNeZ2NJWYgBBwKyQm8wKNojCJzHFthBVD1WBCRIMokl8EYZ6mIBgEv1hmxEXAmi0DbAIAI +cNtxNw2ECIIWZ8phqugP2O3CVmdw0A3E5xEgk4HCOGcvEPCpNu70iLejfbezkKcgaI5mK6izkJrG +8Lw/ZMH4L8xfmF08Bx4NZNXoODhxCQtHCCweUVpo2Ag4Rj4OfL1/HBl1UTiZlZSOHpnhxRaoLJKy +SToxOo7vdyjAdHAjZDlXQHO24gR1goD/pZxVfr8MHh8kH0UUkFDS49GgZkMB3e0iwZqBKYNW7e0K +cGa3Rl3gB007Ms0yMbcb8FNxe6Fh9LgLqBZ+mUGCKoNHBSYD9OQGwQ+eCFLUBVQLmgdzNDACA1gE +YAHLGfBpOJIiAFrJAoakvR5h3z7fPiexScgE+INrjANTACLKD3YexjBgUnQVaMXtkeGnB2DQJY2M +g80U9xYgMpLYAtoCvwk9gsvZhwNgtR9xWgISDvrutAeSX4fSG3MIV0Sdr3YHKuFhNMA/4gRIDmfO +H7AFbgtmGfrudWIERIyNg8L3iHtTFlBu0tgYBWTnd75SHjIWcaadIQd88CkFwC0EDhRLEnQBdM74 +OBoKQQOAxCNBeNzeQjxoTsPoUXxm/zgGLMBwRYbNQ554fBqUs9en+xygJpCgROARaLDbpwDCUEyV +F5uJzLpiT4LogvxhuDIoB2ceBsp5DIMGIOEoiiXdHiWExIOh6BgkPETHzfn9OoJGNbNfbmxlS0vg +CJCQM+0DpA8ZFQoaIF/xsEWiMZbJwIAA7DhTsiDVPE5ic3yR5/IUk4Ec3pPB7N70vgmZD6QAUgqG +CBIGkAo0oSSWwU/BYPqhO85EujrqfJs6xEXx+eQ9smBhnPddHdh3tX98jPT7dCAOEug+oPg8PE1B +IHDHAgC9emC4BFDOXjcPYd2jdWZ0NLTvag9kKfyjzyNhoShNZ/ckGU8RCZCOwM7gbcGcwiMgnUZG +cHiEs2rgkCA81z2yD25O4GEdQ4xAIOIL2N4A9LEyMk7tB+72gJePQPKTZFaU6pxY8wedFQ1nknkU +vfpqF1BtwCf5vcLoKKQ3dA0sIYxDaG92NBoKRwIBxYFEPwiDKIbbzv6okOP7IMfA8wacuVzdmQFz +ChDIVxofZ6HSof2QqCEkEkQjLp8IAwj5Bh+BYMGfQVUqajMSm1T0XsCZfpRAtoH99AXYQAj8kQn5 +z4JG1UDwp9x++DhrRYck7UwHOftYAEKdVWAImQqWUBCAtmJ78/MgXUDgZRE07sx/4glnx51XRlAb +kAriC/AISt5JJAc0ZChYii4Cc0EcQe1AQKEQwDxiVFrS24JcR8JpgizCZ0GBjEHyA+DgyUBAh/SA +MQEk8QaiIIkhjsEADJRB02lnFRtJEEQBR5M+ZxUAGk8C3eytNdNgf0C1evwqjKQd6xWrq/sA2Tyg +e6N7e6Uo4KmxcVD+0t7qkgpBGRuF8ifgp7OiN4Lv34+5gMu8MuQJcByAQwC0rocBLQeFDBQG4fM5 +G8AgtYCGQLrgI/t9I/shOQnw8mNOT5WoOYUTxtVXj+272uV1ObkEDQNYAMZ07a0ngnaC/wLTAX+A +m8BTEGfDSYViSiDVAMb3jZLgkR37s+cdgOygtb4A0LodRhKgVQD90JAV8In794EFxh2JCFnk00A4 +kbSzCwWnUiB1QmErjKf3VoqdxTuaz/NqnZWrLseKgmTVHSWJJ+BywuSGvNVC8CnHiCneoOIoecTR +OYyzhTKFhC2KSotiXpSLLF8O4xmCyhLOTFQhjOmqXtOMLhjkcDgKYRr3CuNeHvR5rX6I4dLg0ENh +fczD7Xe6JnlALTgL+nlnJyeZCTvbNrT9Y+zIGBtEHKUE3grQG5g0jKdorhQm7P2jIfDO4y4aMBNo +GsUzoJbDaBaS2eMFB0EBg4fxZK54IF/cZdgmhjtriFA4zhYUj7N0srfVk9nbaxcLhZNglMCwA/RB +ZXkc9FD8gRhNVTgW6CMCiedMO+xttnFmsEfw8TFntyd0TRDLnFyFGO3NZMqOTx8lfGAMfVGvDxyK +s9XE48yCymNj7P79KLDYnh6G1GLdoHwCzhRoGIkwZNrvY1zjAGsG8Ck4OOAaf8DZUIphMfc4fvVV +kEKesVEMEBjyH7QfhuXBfzmGYjRIhJ3tDUBernFmb+ew6nXWwaGPGHR5b3GKAK3id0xoJBCKOp3y +Ods/3M48P3XVVd59V/mdVjkUFkHCcdTZvWbDHwhIibAOaTnqlI/wz9QKBG1WqOnRCVlvS1pNi3YJ +Blx8kRZqrFhTIwPDnrVSSyE8G3Q2loABBCOcg+A6a68IVH0SQQHNZAeOsCjkJyuAT89CrCG+rACE +VaOYlCiVZLVFMiWKKeLOonmGF6rl8k46syxIFTDyzuxTEBxZHLQQiGRwQySVAdvuCYLwYKH2IXNC +aJzmy6zUYMQ6mDVQ43trvuLeTtccSqS8oJDRhKT1rcQ8xjiz3ECdnj3cG3VxYCdZscUIXWDYEWfS +EpBN46QKK5ahteNuMGJmEHH2rzJ8CVgV3CUgOWQXgHDA2d4DBqQJfQ+iNiQbqB2WzRBkLoymIWnB +5fkRSBJwARG3M1ntYIJDiEDcSAQjUiFosN/0hQyP39nAADozCE7ZB6Vqu31GmMhwQg1Uq8erOXOM +XmFv7wEJqglkLRhPBIkReIrEk5BX0B6vs4bu8I6ztBSG+MbBibsc2wucCzACcoX0esGdaYCKGArw +Avwek8SC20MB8FJ0UjO7UAiAn5CWBJ0Duet3zFGU5zPO3mavBIGGCGJkIUxk/c4G2siog3iQPM6y +IxCKAyMhA4BC1vu62TciPQg3OGi/z0lXZyk2YEIcKQ5GuJoqzmt2D9yQGunSYpWAlFDr0eRsprpj +JudpvuIs8iKaEe1RXAnwAXdmBpIQHUGpUnxONpoEleKlim4PGNHZnscIVS06kcguxlJTstnFmQJQ +mKJ2NJBVTJ6kC3u/U+Llciq/yIjFAGpBR0iuzkpdXu3RYjMMsSNTnFgx4xMARHp02ogvklwlhCdI +tkxAotI5AIS9dcloIGyipA0XJ5UkraVZQ8UY0FyFJPMYngHq9DlTFinE2bgog64OgLbEILLAy6Au +TGcZBUvADeEiGfiIszfeHwKcESk6BQkcQqMUWwIfStI5zejIYMb5IkFlSDYfxGwX8BpkIJaQ9K6g +NsNEwomRX3XWQPE4BrdlgAIastEh2DxOZ6CdGBUDFYHgMU4qi2oTSg+agZIpeBDQKySw3y+HgkoY +ARulUmSGonIUDBoBww4gnIIeQbp6QZH6VfgI/BX+V5GbQBYA9W6f6myw8enA4OBWGCan6nUr2dei +TcWslNrraqTv7P8JRgm6SDJVjMwxXM7Uq6bRxKiUPxyByPqcbWA83B+645AaAnqJCwRFWSsiqE7R +MZbPgYQGHweGXRD7zsY5HkYvDpoEuC8UjhFOgGpmcoJVaorVN+OTvFoVVMCutGRU0uXFdHVV1BuQ +A7JarHcP8EoNBX0olKHk1UhPMlqsXOYUx+ulMrOl5gbF5YIAQXxFjw4gr6KpKSs1RwkNimsC1eJk +BCUgyhbgg251Vasj6k3IFh8S4ZQGxedJLseIVV7tqrFZ3Z6NJOZlcyBK5XrniG5Pew== + + + QybBFIzYrGHDvw9lo08wmTARg1TBnb3xOrAtzSQTmdlsedVOzyQyc7LWAVTxBgxGqJBMLuDsYDT2 +tkYoYN9AbO8t/grOyx1olCBTDFsyIkNeqdNCnpdLmtWhhWwIMxmxBF2GS9Q7MFDxzIKVmFJjXZzL +joJ5RyyazXNSTdS78NPpoFjWrX61fcDOz3N6M5KctlKzEWcLdzuen48kepBdDJ9M5iZzlaVIYrC3 +sv/PzfYpgs1IcgXFgQ15IL69NwJygtICNnEIxeo7WUpnMBrwHAYTPpiStXaxupmvbVJ8GaAGozLg +0J0l+5CC4TFZr6cqS9n6emPy8Pz2pXR1k+RLtAhaKO/yghDK01xZ0zulymYyvwwdZMWKb29CIBw2 +SSYN6oh0dvAWrPhEIjcXSUwoWtl5YQeDTKgTVD7kbFHLKmbXiA84Bfil5rySQyYJJi3odV5rS0bP +sCfT5ZVCc102y5JRjCR7RqKvJ/pWZkqONKPpoWi2WKXCSEVAEorLMGJeUGvwqWRmaWLm7MT86URu +VrW6jFyDWKhmU7PaifxyJL2Wrx+DMcEIcB+AHhGCTipGA+hYj0/TUoMSa8nihmp2JK3KSpDYRS02 +LZkTgtbjlU48MTmYPa1YPXdAhcBFE/N6bJpXWrzShCSHX6b4gmx0Q5jhCwqQvapZ1WONWNrpi5Wa +AcWIMxlRa/gRI+xArkPZgACQY4BaNFfwO2/ExDEiEQrDvxix5HymvJ4sLSfyC3DBcEE3oYIwOk2J +BclsS2YnXVyNZxcgWJLR8AZkFLNoGsDEZviqZk5Ahcaz86Xm7tzGjdn6BgxvND2nx4YQ+sb08cbM +8XR1WbXa0Xi7N32gP3e00t2EVAEkFLQmq1ThEVqkxYmFbHYGIBRSS1QbcHGSQyXV7sF8fdO0B5Xm +SjTVC4QNlEwoRjuRnU9X1zOQXWI5iMaMaAejbbeXImjbtAGy2unSSnfu7NzOjcnyWqY4v7J9rWb2 +/MGkZEwpkaEamUxllxsTpyLJBcjVcTeDIAaBRyW1bGdnjMRULLPQmDyRb+xAHGPJfqO1SvOlYAi0 +GWjsNMs3DXsuWdoutY4pZj9bWIQCAUNHMlndnknkN2rdEyu7dxw98y+Lq+eXt89HUgMl0sxUlzO1 +1UhqMlNZnpg/N79zk5WZJrkMwSYYPm3EugBQpfaBWv9gLD29untzY3iQlAskn9WtZjTZz9TWzMxy +rLguxyflaC9TXUNJ0xfkGD5jp2dL3WOlwYlC72ihe9TOLPZnjidyA9WqJIqLRnwakMpMzGTLK43h +EfigpEGudvxhDaPjDERZa2iRbiQxlavtlNtHaCHHilnNrKKkzghxWa8k8ouF1nahud3oHZ6YOQMS +TtSagtoCvIXuW4mZRHah1Nitdo8l8xuAtMCVYTwmyNVocjpZWjLik4rV1exBPDcnmk1CKAhGW4p0 +NHsyVVyFEW5MHhPVGoabFGWjCBgBlaSLkeh0Z+ZEbWK33NltTp/OVVc3Dl4HIwPsKaj1Ymd7ZvPi +yuEb1o/cOLt0yoq3VaOWLS/TfJGVqpRQUaxBb/ZCfXCk0NicnD8HhR8MG6xcABQ1E1PFxnZv7lRn +7mRjsHvw9G3d6UNatIXTCc55q2XGzi9VJ49ma1vxzHxj4hhKJ1BMicVbgpTz+hhOzBYbm3MHbprb +vrx76rYH3vc5IzpQzenB0g2ZyjbJVmi+rliTjNgIO9uWdECqIKICFUaTHTs7lSoBPmxHkjM4ky1W +lp795Ndi2Vm3j49EO4Pp0xEb4gXAeCSWXQHg3TpwAynkvQFFAmWVmi23Dlc7xzszZ6u93SMnbjt1 +/b+IRjOVWxwuXZjbuDi7fqEzc2xm6/LS4VunZs88/OTzxTbAbyaRHpRaB+qDY63h8Ymlc7PbN7SG +B5fWTm2fvhWItT9zcPHA5UL7kJ6c6c6dWT5yV2V4zrRbqVJfiVZw2ha0lpGYjpdW48Wlcne3Ojhk +pfutqY1sc0WLdsz4gFWKkUQ/lh7GUsPJhcu56jbJJwS9mMhNCxooq5qDw/YwkphJFtZq3WP1wdFo +shVLdhSzYaWG2epqurRcbm22Jw7snrhlaesioKWoVvKNjfbkkeHS2dbEkUr7YLa2oxi96enTs6vX +oITFihlIiVr/aKm1k6muT69cXFy//vKVx7pTR8NUCnLeSi1A2sezS0ZiOZbdbU5ekJU6jts0l2fF +fKY0ZyYHqdKClZpM5GaqnR3F7ACLWclpWa+mC7PVzla2vKRHaiyfBjbsTJ3So/10cQFaK2r1TGmx +1N6083OUWDeTk43Bdr62KGnFQnMtEu9kSzPdmaOFxrqdGdZ6m3c88EG4lazXhotnFnZu7MyfLba3 +U4UFUe2AoK01dg4evydfWcRI1bCqje7G9OqZ2c1zg6UL8zu3aNYgEpvl5arby4A8iGZWJldu7M9f +zFQPZBq7aUdUTFXqS43OCoJpwbAJSluOThgOuc8kc4sOuuqlVm8rXZgDe65Gp+KlDSu7lGtsJPKz +/rDqD0qgvmg2phoNKz6dLq0W2zu1wYly/zj4vqg9TORn7Gyn2FzI1ZaTpXk7M5gZ7jz7iS/VB9so +admpwczyzTPLt0wtX57dvJwoLbba648+/IFHPvIFUCmTi6cXDtwysXxdY+r09PrlmY3rI4npi9fc +856nPmEX+m6/KGkdO71QbO0MV85tHb+9NXVkbv7o+5/9dKW3BTnQ7O+WWpuQcuuHrpy/4bHDF55M +5jamh7uLK2chPRSjbsYhqaazlY3e/Pn14/ceuua97ekzW9sXFleO8WrRSg5imRkt2jNi/UxpYePY +XZun7wdeiCUmIfFYMQd3kPQG2E+UKoTJfCq32p05QbFRTkqbdgdCDNJCt0GC9ruDQ3fd/8zUwnFa +zHdmL9YmThca2zMbl6rDc3pyVY/PsXwhkZynuCxOxRKpiWx5cXH74trhmwZLZwVQL0K51zt0+70f +EtV8Oj/Zmz7emzmrxgbQtkxpJVNeBVGayEzb6ckgqpJMDMAZOpUqri2sX3v+xkcBzLe3LmzvXiNr +pVRusthcK7cPTC2fP3Xdfbc/+H7AkM31k/c+/P6p1TPgiQg2C2YB/HKhdqI1fV17+kI0PrG9ffrc ++ZtS6SYFgbY6amwmkl5KFdYWtu+I51YwMm4lBsCnUAJaBBi/Hcst6dFevrJ0891P7p64PkxEQHRR +bLHUOZJrHjDiUxRbVtTW2bN33vvAM9FYT1SqkFHp+la+eWhq9XpWKoXxCMUkwriJ4bputmIpKLED +EKZy/1S8sEHT2cmJYxG7hhCCqGVyleVGb7c7PNAerE8vHJGMkjfI65FKtblbaR3OV7eAxTS7XWut +nr3mno3jNxJMvNzeLHYOpCqrnblz+c6ulZ6FKJ8/d8cNdzwSSTZdPlE1AZFmzMQAkrY7ewIGbWn5 +5Bde/tbE3DHNqK5uXjx27cPzB6+sHLrlyLn75ravqEbv2rO3X3/TozSfM2MDeGildaBQ26x2DwwW +zzWnjqvRzukzV9a2znJyvtBYK/d247nFZH6p3ju8cezuwfLlWGpufuk8KxfH3DRgvmqCrWszUhO8 +hmxMFKor+cKg2V6huIQGhJ6eBk6UzXYyu9CbPWUm+6yU78yd12JdTgYV0WaUmitkedG4oHYyxa0Q +FgE9mcoMI3anN3N4uHw6VVlhQEwyxVpt45a7njbsWqE2P7t+TXvqRDQ7r5h1NdKghAItlaEX8fQM +TluKWTLtrgVVE5+IJnvF6jIIp8WFo8urp0D5tAYHplfPTS6dm1w8NbV0rDe5Zdudhx966uvf/cnW +kesD4QjFZnmpCmmTqx3O1mDM5xg2c+WW93z0Ey9WqtMg4RoTJ6E0GsOzE8s3Ta9fARHI8qC9zpea +6z7nnWKdkyvlzqFcdX0we+rORz6xcfTGeLpfba0iqMlIZdnqsVIF6Kbc2D547NbNA5cVtdLsrhUa +i4yUI5gcLzWjiZlC/UCxtoWTth1tJ1KTJJuEoYukHHcmmxO8WLbjfYw0/CFWkJPp4tTE7NHNo7cU +O1vgLzx+yRvgSdaiuagZa2WKq/nGbnPq8Nz6xZ3Td8WAsORCtb2mRauKVdk5df/izk2V7m65udno +7wKehEkw9YZuT1B8muaSycI8pEF35tjk0sn+/GE90aLYiJ1qZyvzpe52c+pEZXBEjQ0pNp1K95KZ +SfACqtGMxSckMU8QlmW1W8Mj1cHBaGayPjhUaG7ySj6Vn4ZkEPWqZDQls0nxySBqYHj0zOnbnbd7 +xkmCTEK5OTpHBKVRIpgsxaWTmX69sw4UUGmsrRy8rTN9bSy9PjV3sTF1Qov36u3Ni7c9yWulf77Z +QTIFUe3Gcpv16esT+VVfSGX4VLm+Ch6qUF/vzZ8eLl+3uXv7+vbNldbBbHlN10snTt/andwOohrB +Z0k2w8mAvYtWehEAIZqe4aXU4SPXlctzFPhErZUtLcfSC8Bc0dR8qXUwmZyYXz6bry1D6gLkcmIO +QNIwGvXmaru/wcs5gkpQTBLSO2JPRNPzqjXIVdZSublMdjaVHEhSfmLqaKV3UItPSkZ7b1opjpEZ +WesurF9v2F0EjwI/atF+Z3iyPXW8PTzWmzqhGJ1iae7Cpft5PiHprUL7IBRFc3hy9fidC1sX8yAU +2ezlmx+cXz4SdAxpMppYEpQiydlBTANvpRktSamAIhXUshKdyFY3yt1DULDORk0yLsnFeKLlC7AI +qjrvU6tt1RoyfEuQQdK0fQGBpHTLrtrZbiwzyNZWwRZpsX62tBRLTupGqVlfXN29LlWZF7SKoFYV +sxWJDfXolJ1dyTd3OaUIdFyqrjQGB+uD3frkESHSwtjEXrrOYrSRy/WPnr3v4NkHa4PjmtXFKRiN +OHhz562fkOFykcGAIIg5oOZYZtJMDez8DMEnAVUm589ANHm5mC4stKdOAypW2+tmrM5JyWBY9fqE +YEj1+Eivn4vFB53Jo7Xe0db0NbHiMnhhlDT0SKPS2IkmZimuAqKdUwokl2j1t9rDgwhpQgPs+AzN +pgkqxmt1RmsDBjrzFZGWYXUQzKy2dhc2b8qW1su15f7U4URuAQIXi9RPnbo1nW37ECleWCq2Dvfm +Ls4s3xBNzrNyg+SyulE9c+q2fH6IE3axujK/ek17cDhbWsuWNjmpmk5PDadPkFQikZxc3719Yv5i +MrNoRvqR6ICXa9DTQnVJ1vIQKZZLJbIzsdRUf+r4/MYlUakH/EJEyz3wnqej0XYYi7JiUdEbit5K +5VYGs+cW1i6BYi8WJhc2rxH1WhjXMFyl6BiKRhHEIvAkSThzmytr12QrqyEMPLUeJqIIFg2G47zU +ko2+2yvu24+A1zYiw3EX7uxtC6ugPGWjKchlVSrubF1KVWcRSsdZm2CSkNVGdNKw+iyX8Hpohk5F +4kMlOkjmoXAWCLoAFBxCdJZNymqOF+xsfmgm+mqsZ+cXGxOH7eQgneofOnhpYf00Jw== + + + J2guni3OTs6enF48X3TsxrQS6RBsCsazWF4CQhcV4IuDi5s3T86fPXD0zs3Dt8lGoVaeOHrqlmJj +Eegm5CwdOhNrifRCJg+evRBEIrxQwMhIMMiLcrbaOzC3eXkwewLs1cETD8wsXcxmp7Y2r52YPSXp +VU4uwIDAfVDSNo1JgS8HnQVNiROSulUDRR3JzONciRbLYNihBEStitMxXio0u0fTeQeHRcVREf6A +iBOWqla9bnx8POSgRGJYqm/VOgfSIL/ZNMkkm92DE7NnoBBoPgUyoFDfSReXneNTxHQYhzFPJ3JT +olZmxcKe+K/Y6fl6Z3c4e06Uq2HUoKi4He9BLUO9i0oFtAqY5Uh8RhAqGBpl+YxiNGmhRAsV0x52 +hicW1m+YXb2+3NwBLvD6WSQshcICRpiskLdSU7nyMoyDoVciVt3t4eAfoXwA1WWtxrA5lssLQglD +tOnB+oXr7scoY3Q0EPQzDBk1QSbZfRyP+by8IuVe/tfvLy8d8ngIAtftFNxhOZ5ayZe28+VN57AI +D5NITICOcntoGFgUhBbUnZyTjbIVrW9unS125xBKZqR4NN01k205AhHJQwexsJ5KDq14H7iMZOMw +5ghmkHSc4bKKXhedQUsdPHy50l4xE21OK1FiiuZsPVIqgt2zagShmXqp3l6rNpaMaB2jIp6AAPAL +5i5T2khkZqBSNKtdbB6YXj4LQqXUWDTjDYzWJiaXj567WY0UxtwUK9TlyKQZm9KMBoxPELVAsuYr +m7KZRxBW03P1/vbEwqnl7eumls+1J3djyW4q1T5//uYT5293+3mKzcl6VzX68dSsJFYwzEIhiHSM +ZmyIAuS2HO2JxkCxhoX64Ur7OMXn/CHBtEqp7FBSs9Bf0KWCWBSEosAVsHDEM44GvDhJGLyYNaNd +cGqgLhA0omgNM9pXzUYAkXOV+Wx9LZab5ZQcmCYMj0SsRrO7C/bQ42W8XpYXS1C86dx8rbmTSM3s +vQLD0kyyWFlxeyhBzsaS/Xp/V4n2GLEQCmvBkAw8SDA2SsbMxFR35txw8UJ/+mS+ss4K1RBqw8hA +e0IIj2IKJ2Ti2Zn57Rt6M+fi6QVBKcPNcTrKq3lBzUlqyYz0MrmFXH5ZBQXFJWU55/KQrnEs5Gcw +RGTpeDAgOZsJfbyuls+eujmfbLnHcY5JmvZAkCuSVOW4LEUnvV4BQ61CfpHni4Jc9AfZMAY1G49n +HMvfW9gs9WaL3enOzPLqoZNbp85NbR42MjXByMfTE5FIOx6f4PiML8ihmMyylqbno/GmnW7rsbIR +r+RrE5dufmD54Nl8c8iqKV7PJXKt1tRqvD6FEAr8frk0jCebPj8piIA8oHzUYnWtPnHCyi6QQko1 +0vnG0Mq2rGydNzMoF+G0RDRf7K2sFCcXaC1Bi3FnelzMhFBl3BUMIgIkdqa40Bkelc00wyqSFo+k +6pxiq1bWTFZFMxfPtqYW1hcPHIkWmjhnmXYvmpjae09BHRtDxsfCSEjOF+fTORA5UD4RKORsbS2S +mgGXRIk5jIlTgp0sNBUrEyKlMK0Jer7W22G4vM8nuMbCRFgR2bjApUjSQsJqAFEw0tLMhpWZoaUi +EAfFRA+fvLR++Hws1/SEyACmGPYglpqmucz4OOZy4V4fS5BRik74/M5JCIGgJilAqROp/GIsMaXq +lSOnLm8cPF1sTTNSwhtiQSEYyZYYKSOkysvxYnNZ1Cq8UoaUBo6muXJ34uzM4iXL7vkCDKSWIGWS +uaEaKclGVTXqulkzYrVqb7U6WLMzrUxhMltcKlTWk+lZr5vdd7V3ZATh+Kwd6yJBfnTEPz6GBv2q +ptbrjc1iaY0Xyh4P53aRJBWR9OLIeHjUFR53E7xUz5cPZrJrAlcKBlTTamh6tlLpra0f2j14+prL +V+5/5L2PPfPMx1/49De+860333z7r//5j3f+/U+v/PBnt9/7WG96F9rm2dsDxtLJEmjdUr/dmOlN +rMzMrmwdOHL+2ssPPPLeOx969Mb7Hzhz0y2Xbrvr9ve89+57Hvnii1/+3Je+tH3o5O6h87XWHCgB +iokZ0VrEbgpKKhLJNZqTC0vrWzsHz1xz/ua773jP4+996mMfvfGBhy7edt9dDz/54U9/8uWvf/Vr +3/3Bl7/5nfd/9NMbh85okTxJm0hYYCgjYTcy2bZuxjP56tTsyvqBE4ubh/qzC3NrW0s7Rw+fvubJ +pz/4s1d//pvfvv3SN75x4+33Ts/tZHM9BFGQgIYiJkPFs5lho7HGsnG/n1Pk9OTMVndqrdyay9WG +5c7coVM33HzXe+5/5PHPvfTSfY8+cfuD773r0SetZBOkFMBdKCAqYkFVarrRVrUKw9qJdDNX6tSa +/e7E0tLasdPXXHnsfc88+fTT3/zu9375xptf/ua3Lt9619Lq8UZzQVaLKGaFUR0gSBAzoGbhhsGg +QlGJdHamNdjOliez5f7Z6256/8c//sSHP3Tnex584L1P3XHvQ1fuvv/Bx9/35W9/90PPPXf3fQ+c +uXybpBXDYQUJiTwfN61WMjWta/VsbjIarWYyvW5v5eCxC/OLC2fOX3vtDbfcfPudL3zhi7//45// +/d0///HdP73x1ltPP/uxWm163EW5XBwUXSIxVypt+n2Kz8vgqKIqBY4vYHgMx02OTwhiqlDoHT16 +/vItd569dOWO+x9+4gPPnDxz/dTi6c7kIVUrOXtZr0Jk3p7szO1sHL5w+sKVG294/1PvffmlF3/5 ++q/e/t1vX/vVL954443/+vvff/v7f/vyv37tmY98bPf4tfXeARSP42g0Ca5cz+YShQmwEEfOXbz2 ++puv3PrEE0986atf+8o3v/2pL7z47HMf/9q3vvXqr3/z4stf+e63X/n73//+0tdeef9HPnPmutuy +hWGltjgxs1NpzVl2qVRsrC4vXX/p3MMP3v3hD7//U5/9xDe/+80333nnu6/+7MuvvPK9n/78T3/6 +8//5v//3z/8JLfn9d3/ykwefeHowuxNP9QAwWUZL2fl2Y7C1tQ3X4SNHr9x++wc+9MzzL37mo5/9 +5DOf+uTzL73441d/+qtf//IP//G7//nf//Pmb9959iMfv3zjneXKtCZVBaaYiE+Va5sEaZOYZpt5 +AO6jR47fceddjzz+xCNPf+Dhp55+6avf+NHPX/3Ja6/++W9//st//uPXv/ntb3/3u5e+/PUjx28s +lhdluRa1JiS5Es8M7WSn31taXz948tS5B95z/+NPv+/Dz33qhZdf/vFrv/jlb9589Y03fv32W3/6 +y7v/6//9H6jWH/3sV5/7/NdKtXl/UARODIXkgLND0mS5jBmplUsTuweP3//wQ/c/9vBHP/vcT17/ +xWtv/Prr3//Oy9/46pvvvPXW797++euv/vFPf/z//s///u07b3/qhecv3XBrvtgXBNDbVCDA4Lim +SOlGbX5+dvvUiWvuvufBRx5//Itfeemnv/zFd378g69951u/++Mf/vZf//XWO2+9+dbrf//vv//8 +1798z6OPTUxtVRrrZrQXCjmbnz1uWuISiphM2PVmcwE0yeRw8djp8/f/y8Ofef4zr77+y7d///uv +fvubv3jj1//rf/7nT3/722de/PyjTzx2+5332XZXkhoiE5npzx9YP3jtqbO33XTdfXff9NRj933j +q5//j3//LWT0m2/96he/+OHnv/DxW2+9vLW1Vax04+kBScYxVBfYqMJHbCPWLtePHzpyz133PPTw +ex559OGPf/TZH/34hz/40Q+/9NWXX3nlW3/6y19++svXXnjxc5//4udvuu2eta3TvYl1wyimE61K +bVgsdXK5+vL8xu7WzrHdzXtvufSvX/r817720re/87U33/r1H//6t1d//carv/rlO+/85j//8dd3 +/uOdb3zv6w88eu/a9qFktqMZRVXPGmq8We0sL26cP3fxzOkzp48fu+eOKy+99LnXX//ZG2//5oev +vvqN73z9l2/87N9+/9Zbb7/+27ehWF77wksvXrntrlZviaFthrKjViudnePYtMTbSavQqbaPHNh8 +8l8e/OqXvvjK977z/Bc/99NXf/Lun//0t3/8/fU3f/buH3/32us/feGFjz//wqdOnLtkxRsghwCs +jEg9nuomU62Z6eWl+eUzp06//+nHP/mpj332hU9//ovP//TnP/7P//6vf3v3j6/+6tXvff+rf3r3 +97/9/TsvfeVLTz7xVG+wgRNRMG4BH48EFRyLKHKh1ViqVSaOHT765Pue+MRnP/HpL7zwk9d+9u5f +//Tu3/7649d+8sZbr7/7p//49z/87tVf/Og3v3n1569+/+n3P37LrbflC11FTSFhBlIrYpXtWCWd +aGyuHnjowYe+/JWv/OTVn373B99+59/eevcv7771ztu/+s0bf/3bn+E+P/jhN37801d+/toPn376 +qfOXbt06doNiVF0uOhzSwyGJwuWQn+IofTixeO01F9/z0IOf++LnP/8yRPOzP/7J9/7x3//43R9+ +/xMou5//GAL1qec/duON1x/YPhpP9OqNnZiW6TUm2vVOrVCanRuub64uLkwdOrB41x3nH3nkljtu +P3/DpVP1Wi4aUXlWwHGexJWAjwn46FCAZgk1ZWTqmfpEczA9MThycOfwoa215eE153ceuO+aRx+6 +6dYr1992x20XLl83s7AYT+Q1vRRPgfauoYiIh0WGlDlKBOFy5vjFgwePlbK5fjl/fGfppksnH7z/ +5iefvOvbX//CLwBu3njtrd/+4rnPPHPd9WdnF+didsaKljmwroRGkromx08du+bixSud3myj0V2Y +nNhdmbvu7MHnPvwv33nlS2+8+fo7//bmd773pa+8/Kkvfu5DH/vg/Y8/eOPJwwf7/blYooEgEsPE +UNzw+MDXUH4/Gw5xpmjWMqljm6uP3nnTl1547uWvfO6lF5/52Y//9c9//v1nP/OB2y4fP3VwZbLb +q9VaNC0FAxTPxeAiKRMujjVFVknFst16f2dp7cqFE08/ft8nPvLYv7783Ouv/+jf//D2X/76h9d+ +9tWPPfvwLTef7rSqFCmSRIRlkgE/SBpni7LHRTC4kbIqGauwMD23sbp87typm2647o4rN9x/580v +fubZb3/r5S+88Innn/vAJz/82Bef/+hj99564ejhUr7J8ZEwJmKYQlOWICYLhWHUKjKElLFzR7YP +3XPn3c999EMffOq999x267NPPf7D77/yyrdffu99lz708B3PPnbf9RdPH95en+oNi8WJwdQRO953 +uymvh6PIBBpWQn6aRIVSunZ0a+eeW2/8woufeunlzz37wceefuKB55975off/8EnP/rRe6/csrux +1ay3JN6kSAMJ60E/H/ThWJgjMYGlZMsq5XK9QX9xaXmblzWcAG0phlERQQQC1xgmGgxyoyNev4cg +UZ2hIgSqcKTBO5ci8loqXrKjOQKlcJQgMFrkVUEwZKOI4KbXT4eCAuW8p2D5Q/S4Cw== + + + XC1JEyoeFihc0U0wKXFJMiOqyRGkyvHFVLJWLsxND4+fPL2+tZnJZCCO/gDl9ZNgOkAqh0KKPyAE +gryqZmOxqijGaVqXRStpJcCOJq1oMZPKZ7LVWnNmbikei+cSyWGn0y4VY5JOoSK4ZoqKCkLaTk1w +Ym7/SADUTkSv6VLB1tLdUr2eyeejVtaK7q6tT3XKjUJyut/JpquSaEqizXE5Arf8XsbnIbxu1ONC +3C7snydZCXzWUMqN0kwhWatnyndduencsUOtfHqm3eyUq0sTveVBs5KtEigzNupxjSE+DzU2Ehgb +DXk9FGAXjho8HTe1YgJsVqqYy5RVKUKECU00s3Y1pmcqufp0b36uP2fKSj6ejalJjlSDAX7cw4x7 +2FDY1LSaYVQFIY5jEoFC5SaSiRYUtSoXOt0DK5uXZ+dPG1qKRMJxzSjEs5YSpQkATBqySNVr3cnT +keik18td/f+4QIjSVAIJSRxpSoyRNJOFRC4bTxXTFZDvEsEotBRRcpZetq1a3O6GQlApejzZV43m +/qv9kCouFxrwM3hYYtm0LBdrldmjp29DcD2EgLbMiVJZVqrgKxkmGUYNGAESd+bKRkf9cI27UI+b +IjGdZ1NWpKWqFVnIcnzKOUgqwPoCFEZGMTwBYy5yOYqIerx4COEQVAFhw5A6GhaCQZ7hM4JW0iJV +wyihKIuhLMdoFKlwnKXqBZwywfvTTBpKab/zcl8YtC6GRSgqRjMWx9vBkBAI8Ciq+nxUKMQGgwxD +WeCRNbXM8xlRKpBkJKKnFdUeG/eNjyIYYvBcGmidE8pWfI5hC243DRoYQ2WPG/eMh0NeLOAJBzwI +EeajRkkRYyylslQ0FNLBfXt9/D9fLQ/4FYqMo4jqc1NB500lxRdQESwWCOnAcSxrV8qTRw+fLWSq +fndAoQ2VTSiszUF3AKNGQ24XQRMJtwvfd7XLNY7SZMzvF+CCkg9jJrRHhMxPTBBEBFoVsRqF0rJl +teORKkeYGCJiIX52YkfkbIA7uBXJlhipKSot3WhSTDKE6mGo6L3Db41IPxKfzZZ2irWt3vQ5KzHt +9QLHKdXCJIHp+/d5Pc6JFrpldmdmz3YHJxg2PzoS9oyjlfw0RcZGRsMQzUBAJPGooTfzhaV0ajbo +412jIRoD0lT8Pg5FdAyNklQaXDM8zooNx8bwcRficofcHsTjDmPgW9mM6Excz7JsJpsCLTQnKUVB +LBKETVJJ1tnWHsHJBIJF9u/3jo4G4KE+L8+QcYnPS1IR0q9WXmm0D4yNY+PjCASdE/N6ZEI1OnBb +HDMUId7tLAty3uXC3G7U68UxTM/kV6OpWS3SFoRMNtuMxcthVILP+v0AmFEUTypat1g5QkAg3ASK +gJHuwa38Ac7royDrMCKqaFVVaXidg9FYgDKStAAhCSIKIxYKqQydtqIdVky73Gg4bBpG14y0WS4X +xuMMX/EHdbeHgfQLBNj9zpsLAZ8b87qxgI9iqBiUG4FHACSDQW3f3nEfCGKgaBxBnDMHWDaH4bbf +B1LBQvGoc5Kem3P7ZBgrOzHIFKYIyoKeelwYR9qQgaP7A6POu+o0mHc0HElEZ7Cw7XaTcHm99Ngo +4vVxMMLOBgM6HbVnYslFJGwKQsKy24yQhdwOeLhxZ387TuPRVnVT5JPucZRnE7xUC4WjgZAZdE6L +KpqxaS3SR7EoTcfApDT7x1P5FYrO0Ww+ENRdLtxUi1PDkyQeG9kfpNk0x+UVsWgZNQKPgnof2ecP ++ejl+eMMk3J7OIbN4FSS4QqGOZEvbSlKy+vmfB6WwE0oDdd4GAsrHJuR1Lakdg1rKMk15whK3FC1 +lKClXR7c5xedU0CVuhbtxFPTnckjufI8L2UkrSJIZTPWN2KTrFhB8ERg7/1WKHYkvPeO/yjBUCmK +SuFETFUqeqQ9No47aYBrFJcy7AlGLvsRFf6aTTXWN08rZsMNY4jqJAWpHgNPBKEJhSTgx2OHzy2u +HYHUwgHWmCzPlzmuJCtNVe9DtktCKhato6g0NoZALAjCZPmMrLfjmUXTmqGpdD43G7Xb0BeHghGZ +JGMALLJchUrEMIunYs3aMifkIIJuF+lx82E0HgrbIcSyk1MgukZGQ+BQWKB+PxsKcjimeyDozhGR +UY4rAAiEEGhVhiRSYTQ67sZ9ARGn85HYZL60ICqlQFB1zjdDbQSNgrzn+AxUh8vNSmKVZ3P7r/aO +7gf9YZnmUJabaDjmnL3sYsFNSGIG2oOF9UBQDu5tRAmjEedIExJGJjG/eKrVXyPoGLRc4Esck+WY +HMvkwmELPgWsioXlYBBg09mMjRLpTGFrdefeevdoCLVgECSlQFLOgWk4lnFesLLasWhDV+uqUmfo +ZDDg7EH1OYkdGB9D3ePE2KjDRGFEsawGQcYhVyW56AP5EQCKUZxXz/bDb5IYFsWx6NVXuaABNGHQ +lO32SC6PMu6W9o8SI2MUyMjDu9ctbl8z7mO8QZmTW3p8IVXZLjQPRDOzklqZ7m+dvXwfwSd9iOQL +KWE8RVA5Se5G7GVfyARMwMLmnqEweD4v8HmahgFJEXQakITmLF5JMVKe5DO8WlWtBs1nOLls2FOp +/IaitwC6RTmL086LYAZIHbNKsTGMsoB5GcbBqNGx0OhY2B8QIf0EIa8pFY4DtqWBUwCigccB20No +FKPyrNCS1JaqNTSjBd1MJFpIWPJ6SbgVYAjNZFkub0dbh3avk+TcuAv3eEgCj7NsURCqglijuRwM +Hdje06duzhUmndT1kBiigqaSlTqUYRjRAVQ1s8FwiTEX6nITPj+LoBrNZY1oF6digpRf2rygx9r7 +RkL79gVDQY2kEjSdjlidVHo6FFQ94zhLWryYHRnF9i4cLgxLWlY/mZiQlaKqVRFUd3lof1AMhTWa +ycGja+2DcxuXBBlyTOtP7NTbB3A85vHyLhfj9fBoWOOYGDDm+FiYYVOZ/HIqv0zQGef1q3BEMtvl +ztGJhXOqUQewYvkqjDkvFoJBAQmJfi+396KfBfw+DqrPxzkvmIRUkojhqBkKyB7n3AkhjEXXNy6Z +emnfPp/LRQGKmnqfoQo0lUMQoEssGJDghqMjPr+PBq0CRYGglmS0QaLkcsNIoukGf0RYBJehpWI0 +O8+pVYrPmFbrwM715295hOASJBPXrU48MZdMzGWzS7o9HPOwApuanzqu6fWREYARDjKZprLR2OTM +4nX1zm463T519oqgVzmlmC7NF5pbpfZOtXe4MjihRidoPp1Ndp54/EMzqyegJDFMQzEDI2xBqiXT +y4rWCTqnwVsAGphzeE6eYooEXWS5qhUdWvHJUFh1ucKksyPIeTsDJWyKzsAlCCVVq5Wra6paitvN +WGICJ21ZrRv2pGy2CS4XwqxQOAKtBdW09xJuRJAqdmIocDkQilasgpMGgRscm4C8CvglnLAZNg3y +iWJTrFgQ1TJQMFSxz8eCevd6aJ7LCmI+Yvfbc+dIseDyOqdkAEgSpAXaDNIvFDaAcXhQmySUNrVv +PzI6hkN6hBGLZauK0gZ9omgtWW1wYpFk07xcAnEbdg6eSohyWTGboaCsCMlbbn5Q0wsAGi4XgaIm +0DHPZRgmDlorGJQkMS+KWZZNQGMyhbl8Y12N92O5OVGt0mwqGutSVMI1Tno9AobaNJ2XpY6qDBDE +9nglmownk5OgfEBLQ7/Gx7CxUQyaxzDlaHwqV1gGi+EF2+K8TSbjaNR5KcynhjFb0ZuJzAxoWk3J +RayMz4/5AnQgKDkHyBDOwivQVhDVRL1KS7kwFYtl5/T4MJld6A9P92cvZKorkpTL5abi2SHLQSVa +BGUCbo97Gbhnu7Wt6M45OQQe45zRS2tatdrcTOamS6XZcxfvEYyyaJZqgwOdmZPduZPl7oF8Y5uT +K5yYnhqsv/SFb5y5/m4EUynSUpSqqrUzuY1S9ZAoN02z7RQpmXBeBKYKkjYw44uZ0uH25LXx3DIK +fpM0Y7E2Tsb9IdUHDpRJKnodNBsnliLxyWZz9cqtj86vXRtEwPtU7ey8lV6QrclIfD6eWgFlgqAG +J5X2TtGJO+84INGgzzk6AA0bucyUplUgt71egWOSVqQhyGVZb+nRXr1zoFDbIOh4CAFUpH1eFnSd +HmmmyyvF7lFOa0pGS7cmQL/5/YyzVmj34IOJ9HwmuwipMuoc507AUwAB/H6wKhVJrotyjZecA20E +taFE+qLegkL27R2GTzFZ6JERacTt9uz0DkUZkM8AVqoCUiEPCeZyk2NjYUUuyVIOnujzkgIXz+Yn +k/khp5SsxJSg1AWxHI31eSHvnGTlnJqbxYnE3mkAlt85RC5jaI1Cfh54AQ3rOB4JAI+Pkxybp5k8 +JxQB9gHTgFaQsHb11e4x56QdEFd5Wa5oRh36DoSbTPTBl4+N+Xw+YAoNghIEzKdS4JXi6YXmxKlo +chjPzSjRjh4fGMnJZHFRiw5AXcy0Nh64++np1VOgz8G84GBSsIiqNyKxvmn1fQEeCfA0nQqGNLeb +DaMKCPVEdiZfXc9WVlghblql1vCAs9lYLzvvGqSmirX13sSRuaVzh0/dJappjFRisa5zbqragFbh +kDZMwk5NpcpLQdRwuelEaqk7faE3fy5ZWuGkKkZnEBywqFqqrmhWi5UKvFyQVJCvbTPeBR6PpLqp +4kRnciNVmqFps9vfntu4oTl1VtS7stGDyx/SpyYO3HrX+4qVGY+PA/1JUnWKqmWz66XqsXRuxVFx +ctGMtkDGeECIBng7M7ewcvHcpUfrvcMkk9zaOreweBJqXFbypdZ6bfJofXhydu3GjSMPVVonQIVy +fFw1K7SQAhUHvEnzZb9z8IXmDwjO6+FuCkWB+mNI2HmFk2DzUqSfbuzGChsEWyBoy7Qasl4DHOOl +oqJXDbtbbKxbiT5oGMAWsGY+n4A4OxwEDDNQLOL20D4fuGPT7yUQ8NRsAlg+lppJ5JY4uc6KVSM6 +1eifLFQO+APq2BhGkGlBqtNsQVHrpCOV05wAqdIAJOS4tM/rrGY6J/agYO4KoliJ2QMwsFdf7fK6 +SY+LcI/jAGXgLEQJnHhBECsskw76gaNVv4PnJMg8TizIWj1fXc1V1uZmT91+1wfi6YGgFMvtg6kC +BK4/GJ4czpwpNnf8qO52Uxyf5YA3ybiq1Dih4KSTB1K6WKwu0lwK+qsoxUi8b2dmsrV1KzltmvXZ +6UNX7vsggukwRLnKRtUp/LVqd7fS2U3kFnDS0nWgpL7PD9aeo5kUJFg6v7p66Nb+wlmMigf8PMMl +EdzyBWW3jwWQUcxevnZwdee2RHoYT03ma0sUH3f7SJKxY6nB0s61t9z31DW3PDq5dEYyyoV08/Cx +G81E1+XjSS6TLS/mqiuyOchX1qfmD5nRSgiJFOuH7dQiy5c1vasYbQQzgXBrjbV2/wC0Cgw4SHTd +ahvRjqRX/YgWxszhwvFSczlM6XaqN7l4cnbrQm/ucH1wMFVckoyqKKY+8vGXLt18Hw== + + + yVogDu3Ucm3ibLl3Qo8MvT4JYjTZ39w9fMu+/WBao6o1me8c6q5cHKxeTlQ2ESoZjTWe+ejnDx25 +5PFy4GpjyZnm5OnDZx/qT19wDo4bC6pSiuez427K4+MhYwW5Jet9cGdgE5AgzzIxjk+juAVVXO0f +7cydWzly98aJBwZz50WpMjKCTw6PxuKTfueoVQoeASMANDGYv5gprCLO6R8q6FVZAu9jgrMAPeZH +bBC0OOWcwg3qfRT0j4uiCRvHIiyTAZlN4EngSgwFPR8D8GSYCIQyAMmJ6hQXB4+TzM3VupsUn5C0 +aq1/tNg6lCys9Yan4pkF5zhcH0+TpqYXMQJGXg86B3hqXq8cDiciYDnVKgCmKv3/JL33l1zXde/5 +D4xJdO7KVTfnfG/dUDnn0FXV1TnnRqMbaDSARgaISIIgSJCimEVSokRRlCxawZKt4CBL1lO0pLEs +h3nPHj/bs+bNm7VmvTdrfpt9obV6caEBdte99+z93d/PPefsk7OcOoIrYVR+sgwsW6xv9ZevTG/c +4LlUr7dTaW2gtAXuK55bMJMzrFQr1rabk4d2cgpcCi+U0rklJzEVS06byT6nNCJYnOchc5ODw5GB +YSQcMTK5pVR+LVnctFPzJJ0AscpXlyWjEkYNSa1BAaq31w+Pn738zCvL21cYKTPRWn724dvpvNvZ +u1DdPbz02oNPfzK7+4Jsz2J0AoaGpbO5wqrH7fNGoG6fQMsfVHAyYdh9tz+A25GbR1EnEJQimI3R +acVs28m5bHVdt5utzsrhhXu62SSZGEqoJJ8lhDyvFov11TOXH2eKM+7rEcxs9o+hjKrmhNeveP0C +gmi59FS3dwrKIoY5jFhkpQIjljV7RotPpStL/aXzNx6+11s4GhqhUCIejU0rRodis8BQw8MMSIoq +lyQp9/QJnzcgKuZ0LL2lmtOaOQV2CFibZlypRHFz5/DutQdvbZ29P7163UotgNQPjwL7sHef/zBf +XgGriaJxw+ohaIJhi5nCCrAt5FE4JBQK07KYAWx8GhhwlKbFhpPfThS2U/lNAs9GwqamtdCINTTg +HxkmnjRBpYAlwRT5/e4OoN70DrhZuDb3ZvEoxIYen5ctd2EwhJZsNUl3iVpW0nu8CjpWJXGHZ2I0 +ZUMIESChWIamKvCFYjkUz4DM+nx8rbyaKU67XfXGMGBhQa6XW3vN6aN8Y8UyCjeuv7K0fhzC1GR+ +YXnn3tz6nerE4fTi1amVa4o1MTpO6dE2oC4KBRdV4JGSTFlWexAPgloeAhF2z75xolab5nM4k2aE +Ek5nRdXdHcmIeVYsWLFJlk9LYqrZ3ZqYPWzNnik2V5Y3Ls8sndeiDSvWaXT3m729zuwpIzkVxBJu +2+eAFLM6+cLKyBg1PELwYkWzplSjC35JkBogyMGATFGJiNuCkmCFUiy90Fu8XOueTeYWNK24f3D5 +tfc+hroJzxDDLVnvVVr7py+8dO259zuLFyF0/SEhnulGE/0QYjw5bIgc8/Io5gCYIKgdDIq8mEfc +vsRkIGTwciuZXzl14cELb3zl6vOfT5Q3xv0yJxbgUYSQKIwUVDECz0hSQxAbADiDQ2GQJjO+QLud +4RWAIBg7KNYqmHbSAQWYmtvvTe+mcjN2aoGVJyihwohVKCXd+RsYlfF4JcOZkY2G213BwwdDhtvf +fghDUKNYXkUiysDTIyeeGg3AE3A3Qc/yShPBY4PDrD9kAVWNjrhvwHxeye9X/QEVGArDYm4bbSKW +ra4xhJPLThGkPe6l4RYShS0jsayY/WR5C/IIqq3svqdqkWwe7g48P0il3yf4fWIooAC2wGMP+iXw +pRDqT9oSCqbZ9rvtqsIwEOM+Hq6EFYuye2RGLRZvNie2o2aT5zMzS8dzG1frkyf1WIPh4zjtRDAr +HNY1rUbiZsDPgTNU9Jls8XStfTyzfAd1mz+zLJOK2hNgjXwBHvA8Asig9wyrD+6XlwqdyZ1We5Om +TAJVCqX51ZO3z1x95ejq43uPP6z3DiSp+szFhy+98p6o5hHcRMgkC8iQW+9MHS+sPIPh2RODkSHQ +EDJtOFMaJDIWh+z2jDFgtoHFgu6ZR7IandCtjgrujkkTZEIS84Xy4vTWVVosBYN6ubLTmriQza/M +Lx8vbl7l5JI/IEaN0qPXv6DHJoeH6VDY4iXw5H2aKwdCGlh9KB9WrAcE5/WzgliKpxdSheXe3OGF +m4/XT93i1JppTly89AC4LxjWdLOTzCxk86vp3Dovtt3zsLw0Q8fAaEFdGxoG/xzNlNbr/YN0aRUc +GoYbiWTHH+C9fg5CC5Jg+9zj6Y07jZkLFF88MYASaOz8lVdpMQMVAQI+EHbCSErRp/LlU4XKwZD7 +jssX8FMUHRsaRp4c7iaFgNbZsuHMC3ILPtE7jqOoApjs9XAIFqNY4Nnm4ta147tvBeGOuDSCRBHE +Xb2mWROa0zfTK1Z2neByJBErFZdYHtBbFUDnhYIkV0QRlCoTCirA/oOD3qGh4OBgcNTtdk49aVkm +hQI6iccJLBrwM6JYUM1mIjebKCxUOqfMxBSwcCwxacVrJKvTnEGzlihmBSmvGy3HmQmDrQ0ILGVj +eNTnZ8Cg8lyWot0Wf5GIxTF5IGtgIkj2UFgB8YSCNTbOQWnmhXI6u6CbDRzXKUKP2kXdKSTK/dbc +qanlC+XaWrG4tLV9rVibp9i4k+jna7uiMRHLLGYrO5o1H4mkECSmKBVBzIG58gEbergn5iHKUBng +C4Yp4ZgN7npoxH9i0BMOK6bViyWWSrX9lVPPgQfTtdLO3jNWahrkyx8Qwk82dzBMzolNVlpbw2PM +6AglcBVQRY+PGxwOw5cvIPBiMWr3MAj1iAipR9PxQEAEIxdEtbC7CjQ/0T0zv3wBmEuS863uPsNm +Q0HZO86OP2nu7fXQDBPz+xmcNEORKM3kTacvw8XYHU6u8Gp1or8vSAWOT7a7W43Jk/A3GJMLotEQ +ostq3U4AcW+5jYYAAI22nViyYkupwpqstT1eHWLP62E7rdX5uZNum7hRPBjWBa2RqmxWO2fUaHdw +CLWi9Xy+OzoSHjjhAzUAY+DEe7JahETwedhQyIAvQSzwcpHhUsBlmcp2qrjVnr6cKW8bsW4YU4xo +rdU5UI0Gisf8gShAq989LI8eHyfHxojRMfz35zL8vhseiaexiEOhTjxaXVo+S3JxTsq0584c3Xjz +3O13OstXtfgMzaVMLbe2eGp5+ZKi1YJhyR8UEXe20caxqGPVcUwLBChdzalyDoAFJ1IRNO316U8C +mPC5c3bU8DBoIw4qCnQjSk1BqANHRDCdF1KN7urc8t7ayctbh3e2D27tn39ubvVStrGNM/FqZf7k +7jVeTIYioqgUFa3NcHVFm8SwVCikQy0GuI6ENCRiYVgSQ2IhsFhhBR4yz2ZFpczycVXLo7hOUDGS +yRBMRtBqhtVoNNcuXHpB1iuSXACyYPm8olfjiTld7zBsHsxwzGlWy8tetw92yOMVwhFLkuu8WOaF +Ikk4plkD1YV/BR8FSJ7KrU5Mn+stnN85eAB/htzvdDY2d6//vrkciui4uxSHQcIyxyUITC/XFkQ5 +ByIGgQfpJumNRGmttXh189TziWR/a+Pcn/3wl068P+5RGK4BTFGsbl6/+/bl25+Ro5MDgxhkjSiW +4FMgrUbcHoOs12uo2mTUnla1GhJRwTgF/HwgIHj9vCcgjHjEUfcgD80wJ0Ql7wswANFeLzU+jo+7 +a894zF3OAXU/QTJ5UQMyqgFw5aursfxMorBYbO/Z2SXJ6oBDnuic2t57XrdaHrcFt9v8hGNyOB4P +h3QoiFAl3c7k7uFojHvvQSMcUAnEcKxyp79uxpr11ury3vV8YynfWI0XVzhtAqfTdrS6u3l5beMu +9uQQjUCQp6iUIFYZLivLZYpOylKuUJghSRNYOwzqwdY4vkGzBe+T5s/uKHhoyHEoK09mw6VwxGT4 +lKgVYXwbzdUPPvzmN773k9mVI/gbkM14dr4zfVhtbk319pcXDw0jb+glTa8pak0zJkiq4PUoQ4Pu +EUsjwwiElt/Hj7lzWOGhwcDYKOYZIwjMikbbvcn95fWLHj8LrgZxD+azJKOWKa7nyltatEWQVq+3 +XamthNwu/QJBgCN1p8AAzPPZfrk4OzIUGR3GCDwGfIcixtgY7fdDTmkclzHtFgSG+3qQSstqOZ6Z +1qyWIJV4sQrS3etuTc/sezwcXAZDx6GSBv0CGlFo0kYRNZ5oc8DIwyEMAc9jC3JJtdoGCIhSJnA9 +n2lcvfocyCMnNAqlg2Jl3zS76fR0PDlJMjkw4YqQL+VnIa0Gh4JPzixIi9LU8toLS1sPZK01MkIC +MkBlDwW4p094TriHaAg+v0mSeQAunIkhhBEMiQMDvt+LGyvkksVlgD5g7URh3UkvM3wxnZuzku0w +pWqxZqW715k5t3vm4eVb7zzz4IP98485McsLGbAZCALUGR0bJ4eGQqMjSDAAisrSTNrv9snhoJSE +AgKF6zihSUam3ds4f/Xh9OqZMHwLxbGwVmkdgupqRt2OdSSt4Q8pFJcm6FgE0UHSGa4kSvVa81Sr +C6jeGfcIOFQWFlS9StGFYCg67tPG/dqTA/5kgnQgVQMBDvIlFBbseGt169LWqRuV1urq5vn987d1 +p8IJSTs5aTjtte3L3ekzOBlDUFnXMxsbF3K5SfgpIOhQKOq+S0QSLJNBwnokpIyOoGNuozy32SPc +49goCpYgFu+nMnPJ9LQkZ3Z2n2l39zDGEaL1Su+oPXs5VVwzzPby2qVaYw1kCh5IIjWbSMxKYgmK +o9fHjIxEnn7KE/ByGOJq8uCQd2QEi4R1BNHBL3ndGRORIhI+l1UjERTqaQZ8QrGyHo26s1dwPTQZ +19WS28NtKAxyGgqIBGaSuDvHPT6G+r0ETVg+Hwg7PjJGgJ2QhZTEO7KU4rhULNG9/ezbp87cC4V1 +gkiJYhVqera4Bg6WxGSOMZ90fiZIMuG+DuXKAleybPDhKe84JYtxx6yAw3nqaU8o4pY5cD6j7klY ++LiHCoQkqDsjw2GPhwCjAioHRBMKa4xLW0mCTrBiCVKvUNswrOL+0a2lzSu1xmZv+mBx60p/+ThZ +WOKEbC4/rUVLT1bmaPAEhgbdFUck5nYGMwzAlny9uYvg9ugoEg6JDJfOVpb3zj84f+v1ztTBnTuv +3nv0vp3qE3SKYnIknRGVupNcqHUu9pbvWOk5Xkg3WycLja1orKMYTTDSHq/b31jX+0AfJwYDJwYC +Q6Mkxdd5bZJgik/a9Mkcm8sWV2g2Bn4ynZ08PLr11ntfOnf1Qaa2Ek1O81J5a+/u2slnFLOMkrrp +9HrTpyu1Vctq5nI9WU7CcAD50kwG/IzX554x6p6eEzLc7g04gKE+OOCqVsDHKnLJiPYYrkKQGcep +rW+eS2UmaN5xMv25revbZ5/rLl6s9M7JZjcQVArpmUs3XsYZc8yDB93FyYD5bgM97w== + + + GIeGDFXIL8zub+/eGBgIDJzwwO+HIhiNTcMDIcgkaFe1sri5cx1YGEFNmoV0TjBMgkCNaBRUPQEy +ztO2JOf8Psbnc1fOjI8S8CnhkIyElZFhP4qIPJ8AGoJIK5ZnVrYvLKwdJ/LL9fZJUCpeyC5vXmOY +rN8vu/3/PZzPI0QQW1SbDJuGnBodiYASQtxGQjJF2CQG/oeADx0dRsAG81zixNPjJ54effqp0cEB +L0Q11GhVzHGUVa8tJgEcvKSm5EIRlRPzUrRlJcBpr7WnjxudkyvTW3/2lz/fP3cHmFHR6+niQiw9 +Czdu2LMUnw1FZJ6Jr69dQXF7eMg3Nur3+3CflwYlBFcJblaS06KcxYkYL5aiiW6ju9mbPVWpzj97 +/8XbD161ki1aKKRyG8n0ar19Zm3v4dzK9an5C1G7m4p3Tx/ekqOpIAZo6SBYBuqUZvQktROKmF6/ +CFAGhDLmU8bcg8AIQCTgrFhyyYrPAaydOXhmcmpHMUpWcjJX3W70zs2v3To499LVBx/U+/vNifXz +V56z03Om09aMBstlgYvBFYMeaupEKKJ4vG7GRRBLkbuGMQWAj6KO1+P2ZObZ/Pg4iEwETCaCpNz+ +mRHdnR4SC1GnxckZhk/As4pgccVoLa9fnZ49DbFRrc9SnC3KKcusB9xBVIPBqN+nhPwGjccbldVe +9+Tgk5dIGKaCH8DIBCtXWbkCqdef2pudOxClvCBAoawaZk1Wiiyb0KJuZySKjFWLMzCOXi/hGcch +okgMEsEKB2XPKAma5liVdMrdjyMwTm9m5+DC3YOLj6z0EsWVESy5sXHpT7//o2K2DwbS62FYJi2L +dVmeEOVmMKSAzdDU4uTckRNr+bwkhJNnhAh4GTQs4xHVULI0bYKw82xubNTtsjs4CDTBYxEj6JXQ +cBRKfyLeffDobX+AJWmHlXKy2bKzc5nKWq40t7p46q13v9Kb3oVC3+ycgrIYz8xDaLESFC+wEHzM +qHzq1T+UrdrTTw8PDY4PDwXH4I68HFQWgY1PNuaOrzyrWdUIuAK5yKt5OzmRLk63Z7bLEyu0kIxn +p0rNXVlrWk7fik9zUkGPNiS56tiTteaaEk0n803ZaAZCBhQFjLS8AQXIl2HystICwsWp9JhPGhhC +wHSFMUczu6xQEIXc7va1Xn9bM6uxzGy1c9BbuLi2e/vc5Ucz68fx3MzC0pkvfePP9VgX3BFImahU +nWTfsGZkZVLVexhhqVq50T4pKWX3LY1f+31HUPiiqBzHV0bd6WxqeCQCMRYMqXAZgtJI5lZak2fV +KIxLZnpqr1RZZflst78zNXdKBEqKqAQVBwKSpaLXI4AbhF8bCpnhYDTsE6HKg1yMDJOGUVe1gheq +2DirRDvdxcuF5q7hdBEiFkHNZnvDSTRw0iHptBOfyhaX7di0LEF9tCGi/D6Woe2An/W7E212JKx5 +3OUQKvNk5xrUSkUuwC93Ut2FzWubB/d2Du7vn32wf/TsdH+ZpQBLowyddNd2htwzm0gy7a7WIOO2 +NVEsrdhmze+hsLBKolbAwxCITqJGyM+Mj2IMnXec+TCUPCbqHiA1gAR9ks8L/iQDxlWSyvFYEycM +mokRlCnK+UR+dmblwt7R3b2jBzNb13DGldyZpYuiUSchU9gcQaUZLs/zGfDn07M7QI4nnh7zj9OR +oBHwwW1ywQCPhPlqobl39hqrpkJYNJ5f0p0J+M3NuTPZ9klOrchy9tLxve29a+CsMAx0oxhLzM0t +XFhdu5JIzUlqtVWd+uznPm5PnX76Ke+4hwyCkqCxWHyq2T4w7KlwRNvdu2UnOwPD4TEPHYYqQ7g9 +62S9nshMVyrzW1vnFtbORwhdMuCRdsxYQ44Wq621w+PnL919m5Wh6C8XGtsUX0QwG6eSIcQORtx5 +7WxhOVdaDiPy0DDCMGnbcpkRQxLBoDk8wo6M0uGIMjQa9AcZnLDM2HSiuF5s7pVae0DN+XT/jTc/ +Pn/tcSAoG3Yjnpu20tOG0wPdRlAjHJZVpdrpneX48ugo7b6vdt8N8oODERxLRqPdmand+w/e4IQS +OEnNbEtGO0JkwGfmKtsbB8+b8fbi0uk7z745MbkXCGru8siI4zbex2MU5c73RUICQ1pgpP0Bt0X2 +8Ajl9SthNBZ15ir13WSqMz1zcvP0nbM3Xjl74+W9C8+aiV4Q0XkxW2lsTEyfhgDQjDLQLkmlcMIV +au847/eKfg8LMlXKzhta7cRT4yPDkVBQCLrzxXwwCM5Q4bj8zv6tQFD9gz/wjYxQ4JMVrWM60zBe +J06EA0EBwTSU0GgurljVSvfkwu6tifnLotkXo7V4bq48sUtQCcvqJbPL8exiKr+mOR2Mtse8bkPU +gE8MByTvOA2qODgUgkhAMQPBzUBE9YUE1axo8RopOMnizOzGtVJru9TYaE3u19oAU0Xwz6i7gaUo +AH1TCYpOcEJaUnKdiZXrN1+wYu3BAT9JOobZkpQKgjlPuvYlCDqezs2wUgYExOMFAwmFyZG1CkQv +mMByobO7e7Y3s4niWqG2vrx7b//8yyfPPDe7cq6/cBjL9FPx9gcff+vhm192DxfDY43Owcrm/XL1 +sFw9E7X7oYg2No6lki1JzsMYDQy6TZ7HxpVAyCHoQioze/Pu4/uP3gJo9fiFAKKjVFLS642J7Vbn +sNo5T/AFiLpMZQm0GqfjFJMlqFQEBe01O9PnlWhz3MdhhAM8/sTFGRDDIIBgWSnKzBWnwFYFAoqk +10rN7Ympo61TtxbWLoHnVJX0vduPvvW9H0z0Vj1ekePKoKKCUMPwOAyrPyCJQp6iYmNA2SFRfPKs +eLlabu+vHzxfKC9vrx9+8aM/Wts6Xjl5Y+v8C52V6xOLl1f3H+ycvr135la5uVGtLX3/r3756ptf +JPCorpRVtQkKxtEp22wbSj0Sig4MYECsYISGh1xePvGUZ2gg7IIkmlKjPVlrFIpLql7hpKJiTohG +S7F6Rnw2EJIlrZApzk7091SzWmxuTi5fXDp5a2nv3szW7Xx7X4v1U4npS8cv7p99lpUKnFgpNnay +lS05uiBIU+GwMz5OA0b5fJAv7OiTZWxhGDUqDsSXLs6nSjPV1uLu2Tsnj+4e33xx9eS1UnuHU+s4 +lQCjIohFFNUDATYciQpirdU905+9mMotsSJYdBGBuoNoAFaQjBSopdyO2sup7Lqs12BkfQGeYmL+ +AO/zMyyf1MxmpjBXri/Bfw2rwbJOubHW7u+3ejvJ7HyuspqvruhmPRlvnj13c3XnCCOiifRsob6S +yE3pdoeX6/6gCqmBI8q5o9vl8gLUL49HCocTCJJB0EwoYufys7fuvDw9e3JsjGC4rJWeT5U3evMX +b9z/zAuvf7J88gFB5yYaS+eP74pyGmIsX9qYnL85v/ZstX3JjPUjqIYi2rUrD2uNLXcN8zgDNI3i +CSD0VHG11jsEVOm012bn9kDPKTrFKxVRqxdKS7Mrl+rdg2S6D7JZKExrRnXUPb0XHx9nKbagGl3T +6odCutfLKnq10j4pKmVw4wyf5uQcihuGUSlXFxUtP7V47uj6q43+Qba8KGkluEKWSdhO69zlF978 +7NdWNi4DWBnRPscVQ0ElHGQ9o9josNvQfmSYtZwpGIinnhobHkLGx2i/B5DBYvgKXD+CmFG9DuWY +oJO1yYPd48fnbr0ztXod0KPW3t7ev3f97lvzi2dv3n99cftSujY/tXYRHFOisuWkoMTcuvbMG3Or +F2WjYcVnyq3tfGVdc+YwMvP70xaGhyIk4RCEGXRX0rIEFePloqiW47nZZH56//D29WdfSxT7xdZy +Zx6y+1S2utXonp9efKZQ3UaIKEYYklZjxIJudaLxWcWciSaWBHWCJDNhd96No5gkxReCqINRebcV +LZv1u0cbJKJmHXPfrNJPNp5PdWYuzK5eKTZ3WbEsK/nezF62NE2xTrKwuLh98+Izb+xdeDFVXjZi +DZI1BCG2snasmXmcNgStzIglVzb5NEPGysWZWKwFvjHodsV3D2cBwQxHrERqulJb4QV3VwJJgmNv +KEZVNcqV1urS9tVsdQ0jnb31s6++9lnHKVOUMzF5vt2/UK7t2PF5n/t+hgTEu3XjxYnO1oh7yKzb +Q1Uze5niRrN/rjKxz7GJ+3dfunbzvsdLQq7lq9vzm7evPfv++dvvJoqbYcQiCeNLH39tb++yL6j8 +/oQRw5qNp9dZrjwygiERpdvbLTW2xsbpcFhHMXe9gahWY6l5KzEtSdnb91999KnPxeNdBI3Kas1J +zhSr61unbt588Jn+/EVOrDFMTlFbAffw6NDTT4/DbXrGOVBXii4GAubAiQASlrPpGcDJsRHABx5B +41AW/QGdY3Lg6+DpaVar2t5t9g4ZsabppYn+6e7cEZSMC8f3Xnr9g/b0jp3pH9/49L3HH++ee2Vl +8+4rb3x9efuObk6U84sHZ5+PZbregBAMG+DWRD6BRES/exqRlnIa/cmTopgJBgUUj0paJd/YqvYP +Freuz6xfjMYb67sXJ5eO8q2tXHPbyixI0SarlGS7la9vWJnpCGWRQgaFu7P66doeJtT8YQdn8oLR +jOcWKT4nGFXeaFF8VZBrDF9iOBdvgyEZUo9mYyRrQsCv7j23uv9cf+lKvXeQq67D0CeS7Z2ju7H8 +dLIwt3zq2Xz7lBafVM06EOvG5jFOav4Aly2uGfYkz+ejZgtF7UBAZJiYZbd4oXTiRGjYnZtTBClT +qm0Z1kQ4HPV7+ZjTxnH4WSIUYuvttTsP3rz73BurO1dz+bmoWQuHeQJTJTEHtDXqngXMMWyyUl+r +VJZTqb7PxwwOBoF6UNTtYULRtiBmKcZhqGitMm1audHRMHj7xe1rJ48fzqxeSBWWKLYUiVgCn/j0 +m59ZWj7jC6pj46zbWMY9HsJ9AwN2jiTMWn3JiFaffsoHHEpTGVVvKsaEEu26s+pO48XHrz/7/Bui +CNUzPbt4sz11IV9ZBTF0ElMYlvC4WwCEic4+TcVHRnACiwtCnWNzNBlDEWtgIBzw0VPd9Q8/+pPx +UXwIos7DgaPQjE48sZCM9wTGnJnbVtQc1CyGb4jRPkUq1eZqe+qgO3vQmtxJF2ajVr3R2tg8c3t9 +/1J3didbWkxkQUkmgHkdu9mfPqUZNXcpi5DnuQxL2xBabmeAiAx/FviUz0f5fTQ4QzveXdy4fuHW +29tnnu0vnFlb3vvRX/3k/guvG4mOnZmrdM6kSxul5t7ayXuXb7+5vHOj3dt9+OoHerwfRO1YbrHS +Pd3oXzp1/Oapy6/NbT3T6ex+809/8sFXvhchYt6A9uSMPA2jM6o9lcqtNpprd+6+sHP4TGfxaGbj +UnfxbKa2NLV8tLh+6cK1l+689JlcZbkxsXXrwbsvvPbFM5cfTS5ejGfneLnMi1VZ6wTCoI0spHkE +BT7KSHI9arU5ocAr9WDYEqUKiqm+AI65pq6lmhOyUiOIBJQnTS/OLp7VrWo622q25g== + + + 8+WlaGyOFesMU2ToDJDX70+RhpBAEJ0gE4GAPDICKM3TVApDLSj3DJNg2ATLJRW9rEdb4MrGPGQo +LJKAbyjAu6LquVhioj93uLRxzTAbFGMjuLun48mKOzLsLqyyOS4bdbooZgUDot8rgNL6faLPy0aA ++9BodWJ7afNyd/ZMLD1PslmfXzDUUjzWIQgHwowgkoB7UaPJMqkQxCed+P0urUhQGxpABk8EBwcC +8C2BGRTuzqDRdHzgaV/Ax3nGKfd4xOHIkykYzu+lRTFN0SZkSiq/kC6uSYKVL85UmqsT0/vl9p6d +6CtKAcgxV5kTVYeXdN0qyFoxU1wr1HeB9QLuAldTU+uKWn6yx5Z09wCGJIqMB/0C3OzoSARAmKJs +inZkvZTIz9fbO/PL5zY3z9y88/zyxmG7f/Lg4ksb+8+fv/ba3uH9WmvVdKpOrFWvLV688pyVBF6Y +n1m5vLF3a3LxuNhYjWV6mlMp5HrPPnjtxrOvoKRjJ+Y0q5/MrZ668OrJC6+UaqsLU9vf+e5f3nn0 +qp3qFuurnfn9mdXDWy+8+cVv/PnX//xnn/3kO5evvvDJH37705/5OFFYTOQXzeR8oba7uH774jPv +bew/5qSqLOam5w4hiYJhPRhSSCYO8BhNLPQXrsczc2DqJqfWFKVomBNOZkpzWmAmZb050T88e/lT +opqxnKIdbwpafWLq3NTSTSe9juEFki5EY9Oq2QF207UsxAPU1lAw6vOr7pyCh2e5XKW+JcrFMKKD +H5hfu9meOa3HOgpAol5CcYnmbYzUIgjPsKYgp0WlKGlF3aoJcj4Y4kU1t3nqeqW+BN5PUmsoYkD5 +iIQNWa4jEc3joUAEILTCqMaKGSM+XWocyPoEx+ckPikJLlrqRi3gl8dGaZZNRq2mIFVA38BGhgEx +BhGfVwCfg0HEBlUcM70eBny1uzLQLzFUHL71jNOQO6PjbCAMribGijmaT1nxVrm5hhHxTLycyXVF +JR1LTljxKcPqW85kNreQzs8Kkq2qjmEXadaJ2h0rNa9aHShDHFeIO9Op1JTXQ4cCAo7qkQh4EmFk +OPykp1AYQ0zgPhw3BSnLy4V2d/fUmbuHx/dr3TVRTcWSjcX140yhX6r0M/lJXspCEOp63TAaTmwC +Ujhfnq+111WjxEpFnHJINqZHC45dKZRm4ukJtwlkDeJtBrJgbul8Z3I7k6hMt6cfPXq8sH7StEpz +CwfX7r9y7+W3Xnjjcw9ee+/ep944un5/eX3vwcMXL15/NL947sqt1+c2bi1s3t3cu7ewehGglWYT +yVjzpdc/Wty6ODxKjHtoTsgq0Xa2tj8xc8xLGUVKffr19y2rBgYpQjgxAOf23tbph6cvvzG3dUeS +Mxcv3Hr9rQ8703skl5WjE5RYZaTW5Oyls1ffak4f4aR1585L7d6W1y+6R6L7VRRP0lxpogc+5JIR +bcxM761sXe9MHda621K0ipEJQSlrdrPa3eHVUigiwH1xYlKUczRnA4DQXDoaa8+sXn7uja/2F85q +WsWKTyLuJhHWndINuO+7ABka7W1RKihKJp2dVKITjcnz0cQczQE6gfzWZKUB5SwY1Gk65SQ6qdy0 +pFZwMu4ekzcGihSBgSbIOGisu4Fo1F3MNuouI3RPuAMzPziIYJjjnj81jIdQy4h1ncycmewb9oQa +bQeCRlRNM5zjCzAEHRXkXCq3mKtsZ8oAgDVFzaQzLcOphSOSHevWOmdKzVP1zuknTSnd/nveccLW +yzF44AF2ZCQ0MhwCEQMWZigo0BmeybYmtiguJitZGyJ5YtNIdEW9GHXaNbCsQjwYdBcCcWI1W9jI +lncMu4/jDobqptPmpMKoh4kgFsdlIJvi6b6iVXDCCQQFj4dkGQdcgT/griShScOQnFysVMhOyHLS +1DOt5tzk7Fprci5X7BlO1Uy3M5W5emdpfuNMqbE6O7t7/bk3FnauwZM0jBLHODim4BE2F6+e2r9e +bi6Df7bMXjo578QmVb2FkVDxSV3WDw7OkZTDCXUntVRr72+efm7v/IPl3ZvxzIwqJl58+PJPfvV3 +e0e3Gamcre2Uuudmdx/deelL+0f36+0lx8m/894XDs7dDYZVgDvdmc3VT3VnLx3ffDdXWkrH2y+/ +/N6tF971+CXAkxASFeXaxsl7V599//LDD+L55VZz5fX3/6je3giFlDCiKEat0Tk8ef7F24++MLt8 +HcDqxq1PlyrLg+7pPIjHw2NYEqKiUFxeWr+qSPlbNx988sd/LskFRmxEE4vw6VZqZf/4tYv3Pleb +OMQQ69kHb91/8e1kpjfmoUfGCPhvKKQSeFIQW8PuWav00enrt595BAJy4oTnxNOep/7Ae+IEEgrH +rdgyhpqLK4e9qR3AUjUKulfEyQRKpH0hGLssQBZFRi2rjKIKAn9mk0asly2vd6cP1k89Y2emCEIv +FOZjqWn3zNOwBr5x3MO5yyMZR5PTaJgL+jCeUYN+3O+ncTpJsFnAGYrOEnQ6GBYNowwWrjV7ePLC +w9X9u93la8nili/AYYhkGFUEdV/9PSF9IRxUBT6fKy2zQgEyIpWchEsKIzI87XGfCLTotu9DTU0q ++t31JFKuuAh2V5OLHJ2MhFQKM0B8Mpkuy1t+P8YwNgiOblf6C6d3Tj+ztHFsx9rp9EQs2SUpWxQS +mpbj2TiJaTwVZWn4EW50jAC24pgspDxJ6BhqBAOSIqR52mFIC5AcElzgc2CYScpi+TjHJVStkI43 +uu3lRmsFKgJc/NTChXp3N5XtqHpWURKmkXCMhKZk3Ln7cUbgMgpcMJckiCgSkZAQD+UpkZqUjAl/ +QEtmFzOlVdPuzCycXdm9Wu1sUZRVybVOn7lWKM5SRCKdnUtmZ8xYW9ELhlkCKgeSlZUiScVHnxxO +AV7RdmYSqSVNb/JcwpBj9Wq/P73l7lKsbCZLm43p40b/KFtaiGdnWS5FY+LW5tH2qWuyUgArGDUn +KBrcV0KVSz4P7Rsnba300qO3P/Xau8Ay7vmq46IvHKOESra8lSmsWHruw4+/+vjVd3weZnAg7POK +olTP1w76m3cCASnoY0QOxrFJElEQDShJ8PDB+3Wn98AIMfD0hPjq8ulafTEUVpFIFEwsy2fh4aAR +LuDFvGNhNIQrvIyEI2iY4IVkeWI/Gp9Vo5OsWOJZa35qa//gZjI3pUar8QzA8gpO5UMhiSUNRUyG +Amw4wJO4TRNxgc3adhe4DMUSDJnSpaIm5ibqS0srx2EsCmUFJ6xwSPWD7PtoibUKhSmflxsbwd0j +mMdoDI3CM+H5FMfHITDiiZasZjBCdhKtSnMrmV2K2pMTvTOJ1AyGGZ32Wq22GAq6nUkQFFA94Q/E +MKwoSw24pIAPNdWkFa16gZuCyu9nAMNh092JH4n6fIJhuhlKM1nL6Tl2i6FjwaAENphlEzhmBPw0 +S7krEinCgKDFMT0U1sbGacgImtB846i7O9vHhvwsT1kckxKkMkGlgkEuV5xOFfoIAohqqXpBEFOa +knOieUWMh/y0LCSy2TaKQFpRJKFBeGsaXHAObsfnYwN+gaLikbCOY1ECt+ApYWFJFWyBsQEokIha +6+6oRo1hkgybwjEL/JLIpw0tR+N6wEeODochNynCHBoMjQxF/B6cJXiJ1VJ2tVKYhzwdGoqMjlAI +kqS4EkmnCMJmGJUDaKl1Y055aAhx94XFZroz5xe2bs2sXgLEICGcSBPHJBKT3OqAqXBfkpKNxZtO +vAWRr8uJqJZi6SgMBEsBk6YJMkoShs9DkKiMhzkSYVRBoXFS5BSWMeKZFq/mMcJCUdVUUic3zhxf +vGNEwaQlU5n51sRRIr1CkjYW4cN+KuAl0ZBEYDoakbCITJMWw6RlpSmwOTyiWUr2/N6lB48/gxJG +KCLiuIGAcCEGjcOX5veR3jE8BMbSBzSkRBDjSZMHMRxWBC7lxJoMa1OkVqrMFypLyeyck5w27UkB +JBE1HKvuOE34n2EUEsmpTHaTpJoYWggGFM9oJOTHNMmWxfiA20YmBAFMklmGLuFEMhyOoqiVSPV5 +IQdGBcViUMfdv8RjYIxBGN0GIMORSIDFgJ3HMLcrwiiJEyBxGQo3SVzxjEUsrZRNTuKogYUVLGLQ +JDgBIxLmi6V+PFn3+QiWNiUpybGOwMZoQkVDVNiP87SRy1RCviAaRCgcao3DMHH4OJ+XGRmOeMYI +sL6DA/7xUQyLaEEfh8B4YRoeAvWAMJN7U7u6mosEOZaJE3iMJCzICBjH8ZHw2HDAP47TmD7mdqhA +AQ9J1IxZJTsK2Z0lEHNgIAClcHDQ9dJPtsGSPi8pi5YkmCQhe8ZRoEWez2l63babiXRX06s+LxUK +Qj1FBgfGIgGcwGGARIEza5WpbLYTjZYIXAuHKK83EvSzNJkjcYvE1Vyq05jcHRkHrQiPjwY9o0Ea +40RasaNptxNRPC+qyaAr9fFOfa4ILkiM46iYSTYtswSVCCPMsTEyFOAiIVEFeFGLBK5C4gT9VCTI +oBEZNM07zuARwzEKjcpUpdJnadWKZljGBo8KP4gjMhqSBwZCIFlIyL214SGf1y9FkBgvVHR9wrJ7 +UbOGIQKIz8LigaIDjCTAxSlqLZGYLJeXbMd9cxjwsyxr87wDoe7Oi7kHUJIYsD8qhYKUZywU8EQo +VMTCcKm8zwc2xtG0miS6QhEOy08gqwWaw/GNWHzV3eSCRQPuRBvoKjU2EggHOcAclk0Zel7gE09a +K/j94+jy3O7h4S2aNH0ePOSj0YCg8Am4KSwiBf302HCIwGSeBbWRg36GQAQGEzhSogkZQ7CAx0dG +MPgWMlEUsjyXduepvVQ4yMMYDTw97hslfOP4GITBCd/oQNA7RqJhhadsTUqDb8kli0eH18BkQrEL ++XhQlUhQQoIii5sQfp5RNGa14s4kFtYoqBFBcXwEO/GU1zMG46LCJw6eGGdIXeQTAR8T8MIjIgDf +xkciZESRmCSFRiMBnqfjilQfHgkNDHhOnBiDW6YIzdDAfmsxPXbu3CXbKXl9dCgo4kSUYdOcUKLo +lM+DmrJzfPr6u1/+bhBRnvqD4aFBHxJkFT5maMmYk1WF6IWjy1t7FyKoODYaeTIp787L05Qh8IYq +RZMOOMw5SSgwtAMeDwnz8PckSgu0pEspDOHRMIkGKYZQ406NY00kDE/Ar3BszIGY5ANhKhjCoCKo +Yk6TJ8JBHSrRyGhkcGAcRRRRTHFcDHWh1UBRk8R0TUoyhIaEGV3P5SrLKA6fKIWD7vrMJ/+aNo2C +10cMDweBpsMBmSXjaFj2eXEM5dOJbMaOy4wc9KE+L4Zhih1rFqvLEFHBAA9X1GitJZI991TokQiE +ExoRSbcCJlSpTOEOBFIm3synWkiIBEmXWJ3GZBpXWFyKBPGgLwy//8LxMYULY0NBz0hk6IR3ZCAQ +9DJum0fWejIRLKNhEwmQEX/EM+obG/aF/ZGYqlXTsXo+aapGpdaV1fj4GDBUYNQdYg== + + + FA8rYb8wMhgYeHps4KmxgIeV+LzIpZEAL1BGwsyl7IKh5f0eAg2JBAK1RvKAsJwYHx7weUbCIS8p +MgkCkX1jEYhw7zhEPkdhDoHGgz5xeDAwPOBVxTQE5MhQAOIQyi5LWZaaZ7Fo0MOPDWERP2QWPToU +8ozhkQCIp+D3oALDiwyliVQlZXW7TU4QUQAkM1UpNRPxDMcrSAQhESQG0FieSKbrg4P+0eFQJMBF +pURcSygMa0lcK59cW1tKZPKBEOHx4pEw1FBdEvVkzMpnYoW0vb3cf/jcvYmJ+bGx0NhoYHTEx1OS +CvZIVw1RwsOIo0r5hKXwEFHjSMAnUkg2Ltfy1oVTC0dn1xe2+pUG/DLZ0MFsKGBgnkAxAVeiS7od +VQ1NtqMxnrZ0ucBSDtge32hEoKRSrlJvTep6Mp9tcZxJYAKJiuEAPTIUOnHC677LIt12MfDogl4M +3G+r2luYXzBkFQuRPg9GYBq4gphTFMQ4zViVylQ0mtf1vCgm/T4KCXEQMwwpqbwuMCaOiFCyBS4r +sI7KKRpDF+JGTI+qgmQpikjiIgQZg/ZbqdWljsSDKtJYWEADLBmRKVSHQgbhARrCgMMM8xG/Hw34 +EL/fFKWJrL1Ui+/PFm+c6Vw9mHrt5esHu/NpM8pQChoRoPbxuAkB9vQfjAwN+ANA2QE+MIZQIVok +2Lii2bIaFRUCkjeAqrwosgwD+sjwPCkpbMzSCpEQNzLkG3h6ZPCEB8IDiuMIUOcIPXAicuJEcGgw +7BujIPhDXhQNYplEnkI5KsKYUhwLguenWSIucQm/Fxsa9PjGMRo8TJBAfD6RDMZVtJnl59vO6ny5 +WY8Vc2qvZl/cbNy7tLy3NTFRsdqlWMqJG6pD4OLQiVHvqB8PoiYnxAVKJ/05Dd3oJZtV24pypiHa +lqkIbNoWG0V1rWu+cmfnlecPHlxfev7Weq2cHhv1j42E8AgY1rghSLZIxwQsLqLTZWOjn5yqKHkT +7RflU7PpV+5uvnJv69ufu/jrH775s1989MUv3tlZKWRirCrxDJPA0DgWsWXGLMTNTsWcbSenG+mE +yudjtsxJIX8YCYRsSWpXcv1+bWt96ZXXXmtM9FAMD/gxuIDhQdArTtMnGCbrvpo7MchhWNaymoV8 +KeMQSAgPoUgQlXllopy/enw02evalr21tZjLpXGMDocpWY7zfBycGwu6hIAQcPCVt+PVTAEKYdEW +Swa+v1S4cHJ6rpmayCh70+kXbq5/+rmTX3j9/BvP79+7urM8Xcs6FhVG0QAR9lEMZipijidlHiN1 +lqgl+Kmy3i8bSxPW+SXnuf3CZ+4ufPmNvT987dTf//yrv/7pV955fu/s9nSvXowKMhmhsBAdDrIc +ExNpmwqhANUlQ24njYrFz1XN9cn04kR2b2ni7pXtq0fzD26svfXC4acfXL165nSvUs3FHUNi8VAI +3FfYz3pGcQgnzygJijp0wjM+EkB8GOoLGQxVsNReNZtQRZOjGtlELZdJR+MZM0Mh3OCABxI27CPA +bOlEyKG8LTtydkZ/4ah++0z9wcXuR28eff2Da194dfPDh73ffvf2P//q/b/42nPvf+pof7VXiMcB +HwKeQNgzxoe9eRGZTWFzmcBaBbm0ZFw/VTjeyV3czj1zpvngQuu129Nv3u9/8dHc3/3lK//0q89+ +6/Nn7+2nSyYe8vp8nghHqTwl0xFMxYI9CznssBdnxcdnsx+9tPzes/137ra/+Hj2Z9++9c+//uzP +vnn1F3988b/85OX/8d9/+pdfv/fW/eUre/ViMkYhkK18TI4WbKWdEdZa+uGMuZDHlipkL0OtdezN +fmK7H7u+V/3g8e7vfvPHv/jl1z7+8NnH97bP7EzpEuX3eMN+AkXkkZHA4IlhxDOeECJZCSlqaIL3 +JgR/Py8vNa3Vrnlm1nzn4c47jw9fubf7h+9e+tH333/95evNsr00119c2l8/eU+PlomAz2bRlIh1 +bOLslPbofOO5M6WjKemVS9WffffRT7//yuefX/7Sw+nf/OClf/+nr/zX333hR18++tdfvPTXX798 +fiXmsGHM7/YkZFCZRggJ9af4wFKBvL+b/M7nD3/6vYd//PkLn32u+7VPz/3gy0e/++vHf/3JxR9+ +tP+vv3r5H35w/QvPVZ47zB8s5AoxvZiAWpmy9KzC8GkJ6cXRjTJ3ayPx1jMzL58vP76Q/5MPL/zq +h2/81//8rd/+7P1ffOfOf/uHd/6///fv/v6XHz4+rn3znZM///7z7z/ayVlqYByFIgsYK9AaHgxS +UPLDnijlt8ixxQJ9dTV1ZT13ZiZ6cdl+6XLnT//w/kev7n/0xpW3Xryej8XRCA8KrBJURWfn0sRe +g767qn14p/2ddw+//e6ZH3/11n/+0Rv/4z/+8rc//cwPv3z0d392/7/+5nNfe+/iqblcDgiSlWNG +QqYoi0HbJrFaQC/06VtL2qtnkt96fe3HX7v1vS+c+/pbW3/1paP//Fcv/re//eDffv3Or7536zff +vfqrP7nx2o35WswtgmBCgr4IEcITslE11JU088pJ/d3Lyc/fLHz79YVff+P8//m7N//xpy//xZfO +/OpbF//5Jw/+8Qd3fvjh7o8/2v7FNw7/7PMnb57MtXLxiB/DQgwbITcmy9vd+EZDubkW/cqj/g+/ +dPqbry9+/Y2V3/7olV9899k//dzB99/b/u//+OH//O8/+Oe/eeO337nxf/z9W9/96GhvCmLBNzYy +GvKjoO02x8/nxZ4V6hreq1PMw5P2syftT10qfvR4/nufP/mNt1Z+/PVr//FPX/nNX7z0ux++/O// +8KW//sbto9XKwnS/UOzimJaz43VH6SfpvSpxZYr54r3Wz//o+Nffuvad97e/9ZmtH//R1X/7zbs/ +/9aN776//Z8+Of+///K1X33t0jceVr54K3s0KYKqKIzgGQkMPT2Ke7wpLjCXDJ/v8jfXrMcXSh88 +N/eTP77zL3/z+v/240d//4OHf//DF376yfFPPz74i8/Mfe5m4cq8Opmk0grhthPloxxlJsxiv97a +6KXncuxSBrs8zXz+fvtP3z/5g4+P/uJL+z/79uXf/fiFf/jJ45//8dWff7z7D9+/8q+/eP6337/2 +zU/33ruceOmo3EwbaIiThDzPxgxRa+fMZoyaTBDnprX7W9pL++bbl3PwNP72z+/84tuXf/q14//r +X776f//bn3zr7e1vf/b849tbAsESET4pK2mRyomRXgxfK5IXp5RXzpa/8drm9z57+KMvnv+PX733 +P//bj/7xh49++OHpDx+unlospHVWICgKk6JqxlIzMSURF7iigi4XxOO5zL2ThRdPJ7//mc3/9Tv3 +f/fDd7/88vrHD3vffXvlx185/7W3dh6cq55dKrULZRNySsrShAksxlN63srUnFhBJqfi1Nkp+/ys +fX3Z/uyNxg++cOaX377/vc+f+9bbu196Yf2NS53XDqt3t9JbXa2VFS2ZjYRYmSvEonWFlsq2XtSZ +ikYul6QHp0pff3X5rz489Tffvvrr79373V+++C+/eOcnf3T5p18++NefvPDvP3/ll1/Z/dbjwkuH +6aWyxKHBkB+z9XI+0Y0Kts2SLZPq6MhyLPDMvPDp49xbVytffbz8H799919/89Zvf/Dsf/nFp/79 +7z//42/c/NobGx+8sLg2mbS1KM/YcDv1fNsUhLRMb7dj00lsKRU+bDPPbafeuNJ96Vzz/k7uC7d7 +v/zmjR9/cvObr21++fmZt6/0Ls8nl0tQUzGZEhlcByczNhTmUFZGgwk6MOmQO237cDZ/MJm+tlp4 +8Wz1rWuT7zyz8NYzC+d60fNd/ahnLZedpChrNC9RAnh+RUhKXMqQc1EpXkulK5Za1vmNWuz8TPZ4 +yn7rSvMbry3+zTfO/svPXvrrLx9/9dHsVx90X92zH67oj3dzWxXZJoMcgqtSxjK7NBkDDKQitBAJ +xelw0yC2KsK5LvP8tvnqYfrjB73f/dXz/89/fPLPv/zUr7/74JNXz15erswU47qoRxAdR3giGGLd +dV1kQeebNjeTkTbqxvFi5upa7vmDyh++tP5Hb55+597cnb3qXDUqsmjY7/ONh8IhMZ3oNmrrqVhX +46IGRbcT5rmV/vWDhekMeXFGf/l8+yuvX7lzevLaevH2bnl/OtbP6xmDB8DhKNttV4jYFJ0GkAeC +ziQacc1RMNxm6FJULVtS3RHWm87xQvHGZuvKWuXMbG6+lJzLJmEYM7ooUAQaoYJB1u8XWCpNY1rE +F0Z9AS4csRl2KpfZ6RWP5+N3N+MfPT/9vc+d+uTl5R98dOkHXzj+zptb3/7U6ifPL3xwvXl1MZoQ +IwDtMqe7rY/JOE3YQQCiMFN1kt1ULMsF+w5yuqNemjWfWbG//cbWv/3tB//ym/f+09dvfuf986/d +mLu+W17txICNNSVj2xMMHWMZC0cElYt2crWcwpUNuukIZZVpRMXZnD2d0hfT3KX51L29yQtzhZ7N +1XQ5IykGLTAoF/Dx46PM8CA4QEIXkyJG8eGwgmJZXa8kYvVEohmzCyqXFZmiKtRtKc4g4AVTgtwq +dGQuBlSCg5NH5Vy2SxFmyA9mm8JDtMaolXhxdWpjuT3dspS1ov7MWvFkTb6ymD87ndkuqzsVbSWv +L+XMui6EwRaMhtGwxrMlDAEMDAFpeob9ZMB9sHlFbNlySUZn09xGSbw6b799Y+q924uPDrtn+5UM +x0koY2n5RHahPX2RoxO6nOIplSPggehRSdc42ZS0VqFQTZolRyo5YkJlLUWIKhrHyjgpA6qPjWEI +oslKluFiXj8TCcsS65iynYvnS+kKEw4nBbaZsKsp0DRLpUWFFgAokCADJBUOcl4PNT5OYXgylV3J +FFbcJWRqjmeiLCaYcoJCoEwzUd6aqi/Md5Z71emk7uisGBXjtosw1NCwx+dnEDzJ8nVZrhlqlaOi +Y8Nez4gPuD4qxRw1EVOtgmW0suZKO3G8Utjr2ecXchdXWpvNzEzW6Kftmm2hAWRoaDwYcPe2j43j +g0MB4E2ayWczi7XSSindURk2JhJ1iyspRFFGT3Uyr1zb+9Sds5e25lfrlYwqyxRJYRTHxzDMRjHL +F5AMu9foHtWbh/nkjMqaqzMr1y7eYjERxksg1LiaKcYrtUw9Z+VUWkO9NBZUPYClgxEIqnDECQSi +Ab+GoY4spCNelAxCrSc9Y5j7+ivAREIijugs6XBUjELFoCeEB5mIn48EBcGdsTJZKqm6m1kmg0EF +sDfgYyk0ypGWZVQ1pQmJwyC8xigT+SruCyXkeNau2KLNRVgWVRhc87mdxoMYajNU2jvOPPW/jJ54 +ahR4k0JVW3FiWpJBWTpC6rQUlzR3Ly6BWAxusWxMiDpCOjBGeN2GMJ1S6yCWmDKtyU7/lJOs4YRE +M44RbRTKG+nCEsNaJCEbcnyyu+DxY8MjIY+PF5RmNDZjWFOC21krI4u5/vQpxax7gg== + + + Gk65mzIIKhUKGwRqsoQR8OLDQ/6Al6fwuCRWGSYPMoWgVjhsSEIWbInXJ3r97lFHBJkwojXbaRp6 +KZloiu6SD3eiDcdt+CdBqshKVdWrpjMRtRuylFTUIkYmQ0gUQc1wxMTJBI7HgkEZx3SWtTUtL8tp +Taskk5OxeMs0SiwuSqwchYGV0uPjoaCfwNCoqnbs9AbOZL0+Zng4MjgUgsDAybxqdNwNif8/e+/R +JEmWpIndganKzAjnbpxzzs2cc+7hHh4enGSw5KwyszKrqot2T1fz3ukdTrAjAFYGu4IVCPaAAy44 +44KfBKhFY/Yylz1ABCEj8dorOyPSzN30PdVPv8/8mWpJLBZFjksUocKTMk/wnur124BLPs3YHB+r +N7XyaCYteA7n5iFSGN+yBp3+lWqMMDzCcZuivaSyrtb3i3kJQ2B6E9PqOf6cYioo5pJkYOhjXR8i +ZaOQV0Sx1xs+8aO15WwxfD1fAM9RbaXqGDXQaIo+iJvH9cH5MO1Ie3DTbdySxHhr+UxLq5f7YbSu +Nc5a3etK66KAuBtZYTPL4bhfKsj3Ps3nsozlLOqDJ63BIz/aA+/dfEAQqFku6vfuYdksy4tNN9it +Nq79cA8jwhLiZHPp11KqlIAzZ9K7ZIXsJoGWJJ4NPGtga7VijkCLtECZAuPwsNyYmT6yhNkkW8Gp ++N4nhbB+Imhtzag/vv5iuf+clWuy2ePlpuH0bW8cRsvl/huMsXDKkrVWUFtySotkqxRXN73t2eLN +x+//rje7zBQklAScOElaTw1vT5C7JOUhmMbxkW4Owd9oNmH4punu+MkhIKLtTAyji+IuQYUUG0pq +341Wlea+5U05oRYnq97w0jB7rjeR9Z7hL1uTF7XB46R16icr3eyuDr807ClJu5bXk/WuG69Ue8LK +XV7pBsl6sf7s8tkPnFTLFUUUt2Wtn27wk5qilj7CE/nj7dVzJ9iyg5liz1lpIChTw95DcYCdCk6m +ewLLqERRlmX1TWctSgMM0XFUt62RdvNEg+nOm4PL1vCxpM8kfUpxNYIOFb0nyi2K8nStg5M+gjic +WJeNASf3C6iXyUqiVMUJrVBIC8nSbEUzJrLaV7UBJzQlpacZIy9clcomSSU01+KlPs01JHXAic1s +js9lededa0YPwVSMsES9L+hDQR044bZhp9syGS5mxXYRdREypMVO3L6y48OoeR7WHm5mxEJBVdSe +YfUJKqAZiP0aTlQBnDm+QRBBPi8JcjtK9qJ4l6LjtPco5snGVLe3fW9Ckxa45f37WCHHoyUZx0yG +rWLp878BQYBHRaUcB7Am8lEQ73jJvh3tmuEuL/c2NzjF2lLMca2x9+7z3062rwjOZ+U6I1aj2m5U +P0wrhvlbarrZZj9p7GCMXcA0hAhkfTrZ/jDZ+0l3/ko0uiTjadbEjQ/d5JhXx7TYhvkP4nWtdeIl +OwAvGOFZ3na1/TysXWr2kpdaNFuFCzCcLZoLCdLRrBF4RWtw3Z886wwfVZsnjebRk1c/172JZI26 +izf7Vz87e/6Lo0c/6229nO68d5xZq75z8fw7nA1YqQau5VZOmsNn0/XH8epDc3jNilXV7FneXDUm +gtIF/9SDbcOdHRy8e/Lmt6Y7yRR4jA4rrfP+/H1r8E7SFiTbJJgKLdRu9sJZJGXl0y7MTlr7l6sI +UodkqmGylzSOODmmhRgWUbG3rSjtsBzUDsHHcNzdWb8Kom2wt1BWARJFbSTpc9PfU8whzXgkYfje +2A0WAMUkBQCY2P5OpXle71w22uelsmXaW5a71q0lfBbOVEp4kCloBF1J6qei0k3r2/MVxRyZwcrw +14o5QQkXHNuNdxnIGmkltCmn9ILaieYs3ORAcZY4XbH8nWrrYREBt3TAtQRxYFhLP94Fiyi6QtGJ +G+5AIgYPzBdkgnQtd17vXMj6LK3ZUpDgqlA8BGTbuF+8f7/8ICNgdN1yt/14TzXG5aKKIoZhDFQI +YSaBV1o8k6s53rZmLfujZ73xtZ9s80pNtQZhfY+Rq5rVN9wtcELDnddah5PtZ268hZC24c84qc3w +DVHrYlyTEie00P/jHn6MCiiuaoU7Qe14uv7i/MUftk++o4QGw8Sd6vr8/CPOJWUyxsgqJw6d8KA1 +edmav7LCedpYrXOo2CMrmOvORHemZrCsdc8rrUPJaIe17Rdf/Nnl259P9141R4/dyjH4JBiyNX90 ++fwHmDHDGfVnL4fLj/PDnwy231jxLi11k8bByfVPe5PHKObXGifnT366//Cr7cMvH735rVc9BBAD +/9HtsWJ0aD7k5dbRxc8PHv5yuvdDbfCc41usULG8vhHMMgW1jFiAXa5/7CdnldZVa3DFCJ7lj6vd +q7B+Dvgw3f24+/C71vCRnxwA0bKDJclGhjM0/W2/sgd5wQwOEDJ92C2KV0enX0hyA8VhlWM/2mlP +YAYO9GBfUCcI5g+GjyrVvQJiUVwLJyus0Amq55XuUzM4xOl6s3Xw2ftf4GllPzlXNAC4NIDQ0dPL +t3+pGdOvfvL7//Sf/4/+6Dxb0Mt4YPiryfFX+09/OT/6xq8eoYTf6j+E0CiWrExWYMQmyQGuzrrj +13H9olxyCNw1zAHEVKHIAXZlCnoRc1VwodpFd/7u3gMyl2NoxsepCCdi8EmaraN4TDB1v3Jc711D +gi4hBp7ykzontqudRyzf5EFhqT0AEzvcmyw/7F//qWJ3k/pOe3w5nD+ebD9t9E7caA6TafqTyfoN +rFraNteaRLWzwfz9YPE+rB6DmWXSYaQqwBRkWEkf6h5E1qGozb34YLn/Yb77gkn3Hu95ydoKVoo5 +s+P9oHFkB9PTh58//ewXfmWbTavKt4EJz3bf7T3+MWiexdXl8fHLv/vH/2W29xjnY9na6s3ebO1/ +vT79tj9/xIlJoayIaltQ2rQYC0YH5yu6t7U+/e7h09+Olp/p3gJS52znvWpPWblthfuj1fu4dW75 +a8CrpHmQLdAoKVZay3pvHVRXJN/i5LHj7zW6549f/Ozp659nC1IZNTV9tr3+5uTJ76L2C8mYK2r3 +1//mPwzGVzgZAioeX33/67/4n3791//x/M2vncoBsAXPX/z9P/yvYWUnV9QptuXGp63x2+3jH65f +/tl4+U5WW+uDV93BcQGRcSaSrWW19+r08e9XR1/uHn9hpoXyet3x43QRydDyt53kQPd2JH2rP3m9 +f/olzdaAKgNEW8HaDBbpplapD5zt0fPvvv3V32v2kBWaSf0saYAA3pPNmagMgI2oxnS6867SfJjJ +aQjq+5XdSue0NXo0XL4EXCoXQKUf7h5/BAKcyYmQ6/3qlRms7WhP0CacNMrmtUZt9f33fx4Ek08/ +yedzHCc2otrF8ui7V1/9zWD2DEGdb37426S2i5E+BuzeWlFAnJga2BI3rmY73776+N9dv/m9509e +P/9msX4MjMsL50n9YLx4Ml+/3tp/2xhfGHZ/MD4fbb/i5bbmjnR/yqsjSKy6tx3Ujnqz55LeBbam +O1ud8WeT3e8Wp9/11+80d1xNth+//GWtdwBuEFQPWqMnp9c/fPjq33744e/XJ19Uars76+fbuy+9 +cNEaXG4dfGiNng3nz86uv3/5xe+bw73l6snx2bd+ZV82RoLR5+Q6MDHFmIe1M82euf54ffLGDKYk +VwkqB5AUrGhfD9aLw5+cPP0V+GRYPaz2r0+ffn/59ne91eegk1A6IejIi7f6i8corTrxWDInmrNq +j540Btd2tAIrcgVRkJq2v2X6Qy1Y6MGxV3uYtC5q7VOGT7tZ9YZnbjTVrFbS2psdvW+OL1rDi+74 +SWdwyfAJwGPSPEuasMrruH0CRNqtnvvJUX/2IqztoYQ1WTxZHn70Kgdh9cDwZna4kLRBvXkMXq0a +PUlpn15++d1v/vvnX/5h//r78ep9WFmrauP165/++Nt/QsmQEWqVxsHy8IvF4Rfzg/ezg49A0r79 +7s9PT9+zbCwpjen++8PrH/ce/nS2+5PV6Y+qtcwXTVntkXQYN47i1lnQONb8LSA/zeHjZv95JqtS +dLXeOZe1cTbP5Ap8JifRTBPmGYSA722jqPlgAwP6qpkTKfW6vqgMETwAKHv66neN1hHwVYavgidA +chSkLqRpYFxx46Q7eQyxrOvth0cvO8N9lg9db9oHyH364/XLX83Wn0WNten0dvaeL48+IEDqxNiJ +F93xi8Xet72tN53p83r/3HanvdG5Fy2C6l5r8rw+eWJXdmVz1Bs8Pn70i6i1z0qVyfbrzvBq9+iz +tx9/dfrk+6S57zijk6O3e8ef6Va/0z99/9Uf3nzxFxcvfnXy9MfR6rUXtL/48PN3H35D8wDCAF9j +O9wGH2gOn3vVM0kbt9uH3/7yb6udPUaotvpXQf0sal+Pdz+8/vpvTp/8vFo7fvnZrw+uvla9UaV/ +4VQfKu46qF80h68mOx8Nb2HZnW9/9leACTgTM0JD0MaiMVWdmaz1+sPH063nj59+PHj4uajPNGcJ +gIyzVVqs+ZXV/sW3KWzKlWbvuDt/3Bicj5Yvq90Lmu+wYqszfVLvX5BsojmjxuhRb+ttb/H54vCn +/a23Xrynm4OvvvvDm4+/MdwJkCtR6YNAGC9f17sXUXUHGKyitU7Ovzy7+rLe3vOr2+Dtlfp+f3z2 +5v1vrp98D3rB9Rd7Jx9Pn/086V3o4Y4e7AB9/fzjr/v9fZKwLGc4Wj7rzx5VG/sQbqq7UyaSfNGy +7DHNRqvjD8+++qvDF79ubb3qzJ+3Js80Zy9fdIDH7u6/1fQBRYF4D3EiEoDzuDuqPiXJJJPhCNI3 +zBmAUianoFikGUvN3A4rF0nzAnRZCTUgoBiuDqpBVjppAXncghnglY4Trqqt0zQ67JR5GkbbtCeV +5gEEo+XNgB7r5qjRu7KTdQaSLxeCa01Xb6erD3a8w6vtMuFoanux/crxxqrWBKA7uP4B5v/82a8e +Pvvd1vFXRjhnhGT74J2oAKVJ0pB3po6/1e6edAbnujMUxDhJZrXGtD8+rPeOgtqeCjTMabe7B2Fl +AUlE1Qc3fSsiSgydZBU3H1ZTGDmptHdozne9wRff/vXTD3+IO+fVzsP0oelobtuDhw8/P738CpAW +eP5g8UV98Ly7/AIwRAQuilnN2uqzz3/Rnz7cyDKc1AF4ac9eJu2HENr1xv7W7PIf/+E//tlf/HuU +Sgi2JmmzsH6xf/Xj85/8u9XFj7o1ff36u//hP/xvw+klaDTF2ZNtoND7s72fnL/9C1g1igljkEW1 +XVEFf2tycpuX2ro5bdyg05NX3zU6B0fH76JkrdkT0BokWysTHgZ605qOZq/cYMsNF15lLZuD1e7b +w4df19rngpw2TuoNHtYauxKsWvW0Cdx1+rzauza9JSwxyIRG94wXWzeizwQwtKLj+vB1rf9E0vq8 +WJutHp0+/crwx1k4AHckfdSZvIRTao1Dz5ul9cEEr9E6ZLlGsWhmcirkxFLZY7lmuw== + + + +3Q0/dywZr3BWad3SVMRhtpA9fMlCzzNdLYrzUuWa1nBwvAmEHcQApLWBYquWjMz2GGkLsFWOKlq +OgOMdHR70BxeVNtnce1kvPgw2vlCdqcY7VY6R359D6U8Xu6ATFNBzY2feMEOHKaaQ4YNxltPx6sX +9f6Zm6xVb8IodU7t1LsP26NHAA6g0E13ajmzZvuwOzyNG7tl3FLUWlLf5mRf16uOP/XjdW8K0vII +lJGo9QgqsryV7s5RUje9Tq1/Mt15dXDxw+rka4QwiXQrfn/74LWgd0E6pYXB9cl4+Wy2fjpdPVe1 +rqJ0bQ/0VyVXFCEKqq3jy6d/Chwjqu7TaXFCMV+SQUeLSr1YFgE3gsqy1z+Yzc6ev/im1dkl6MSL +joLkzIv2DG8LJAPgW1TZ3zt6f3b1E5qvkGw9bj3ubX9V7T/zkl2/eihoacH/i+tvh5OHIJYJpioo +/f7kxcMnv9w5/Hw8h9R5PJk+/Id/+J/Xe29JvlPpXbfnr1rTZ/3lK5hwlq8d7j7/z//7//mz3/0j +kFXQnqa/W20/6s/fNAdXQbLj+bNnT7//7OMfJL0PQMoqPdWa+/G+7mzz8ojhmrXaavf4jah1aKFL +8R0ED8uIoxm9/uTi8OILVohVtWPZk7i6v3fy5cHxe1HplRA7X1BcZ3p88qWsdDc3hXxe04zZfOdD +u/9Et5c020ni1d/83T999vZnGxsk6AKUavLSuN44bzYf+v62KtfBfEnv0FxMM4EbziW1rzpLVhkC +zW50n1SbV5XWKcw5MM+ovmukBfknnNxhpY5sThrdi73z77zKTr4kwfVo9lQy+o3BQ7ACsi0rVNNS +b6NrzR4ATIXV/drgarB8uzr94en7P5vufsaINc3qpu6EmhQVgbKQ1CErdoF2govSQhgnE9BZCOEC +C4UJQUkfPsKvHJnBrqj3Fb316Nk3ljeS1BbEKYgC8HBFbXf7F6dPf0amLfYaljNV1B6Qt3r3MG7u +kUx4U9h5THMRguqq2Uuqi63lZZhs5fJKJq+WMY+V2kG85vlQlnw3GLVHJ/un79dnHxuDE4L2gKU4 +/vZNdQgZ4gKo8vroq7Onv7XiE5So5gtGpbKTNPZxxgcXBS2PYAEvDb3kOGicQdRQtL/cfQ0UkU7v +BtcoJgEE7vavxvM3ncELnKqSTL3SvgDSdXNXwSdpn8DTKnDP3/xisfdSkBI3WPQmT2Y7b5LWCcXX +gSsCH1ssn/f6ZxQTWP40qJ9AJO6efdsYPEHJSqlkxtFiufuCl+qi1DPchRPty/qsUj+abb+pNg5Z +Njo7ebtaXslSQpA2I1T8ynp99uXBxXec0CbIEMVcgWvwbL1ctgjCL6NwTNrxygsmjfpCFKrFom77 +q0bvOU4E5aJSyPEkZqliIutjSRuxYgcgOmnsOv6yPXymp41sdqY7H0GOufEuSjgE4ShqC1bEi1ea +s2UHeyPgDAdfzvfe694sX5RUvc+KdVqsa8GclZs45Fm1W28fdyaPJa1lucPx8mXcOg7q+2FzrzY4 +gkQGrqU7Y1AxCOYo2hgkqpU+qTGl+SYQHvD28fQSxCnJVwVtQNA1IISWC0J1CaaJWh+ucHX8BU6H +qtaebb/ojp8CzXCDVa150hlfg0LXzZ5ljwDYaaZiuFtWBEjYpriIk2JOjKNoK4znZVQsIUKhLGdz +Esk0QHOFjRNJbqpCcLC6Ojh6TbI+hJ5kDnmtr1ljy9lS9SGCGpbdrbV2/Xie1LbtcElynRICqjzp +Dx8F1Z0SqtCMy7JVBPUkeQDTxaaNF01FaT558QPDJZubNIraFFtx/MX68OvV4bd2eLyRVYqIDctR +LGs3JWgsho1Vpe0682rjxPIXhtmtt9aSkjC8B2HCim3LXSS1Ay9ag5wkKbfdPeqOr2E1DX9btreK +qE8zdcOYwWE0HelqZ7bzYrzzmhXawIU4oQWyDket89O324tzVUlMu11trHqTh9tHb4GhlRAnkxWL +JVMWOqrU2XjAFQq6rA8BS8fLV164TRBePq8wbLXWOvXC1YMNMptJKwTCBbvuzIv2u5O3YeNJUH8o +6y2adRW9LqtNCEnVmYoaoEcXYxpgL0wpjhu11lG9c1VtXAK9gQxI8jWUikGx8kJCMT5kt+HizWTn +vRcfGPZWUNlVrYFmtkeTy+n2S1qIKT6ihBjU4uM3v3r79V/uPPwG1DpOuiBCAdMovlZCLJyqAXaF +yf6TF3+6vfc8rK5Wh28FuYsSPjgM8BDFmHgxXPbL+eG3nNhWldpwdBwlW4IM5A28OpT1keOtvWAl +ys1sXhAhWZsTE1ResIQsX8Itmo17/QtIJZkMnsmgxbIMApxkG7TUIfk6LKvARdV4aTuDQlnVnYUd +7oNYiJtnFFcplU1wrcnkrN5eEZQBSRMhAlboxjUgdYewrIWyni/KYbQlya1sTi6jLs13VXO71X0y +mr5u9S4hfXBcZTy9CuKttBI4ZqG4xyt901sL2ohXugiirLaf9QdnBOWD4CLpBHygUNRUrRcnq2Ja +gJFm01pALR5MFus4HReQtNFPtb5frR/ghLd98P7px3/bGF3DRIlyD7w0nxcEzg/DMfg8hjm82NHM +raR+ohn99Jk4TFOU6v7Ry2ZzIUuBZnVwuiLrk6R+rOkTnmvm0vohcrN1MJpdARqXy0Y+L29u8gxd +iyqHQbxPkgFSViGWZaXNUFGpqEFom+5ITplJDGldkNrA/EkqoqjYhEgPVlaQMlJBm3PAvigPIIjh +KkDbeL4hqyMnAgH7xA7XOOOUUJHhQbMMdKOddo6zZqAQo/oxiMHZ7gfZnJYxU9XbAGX96aPT66/P +n35b652IRn+0fLo6+xg0j3JlRZS61caVYc/dcG14U9Mdxsn2YvctSUelsuYnu83R697slemtJH1C +8y2SicS0T1OLpi2WCQ17kdTPVgdfTJdvQBpAaOeLiqQMQHxJWm+8/XK29xWkJ8tbArhRTK2MWCQd +4JSLYlZYORyt3g1XryfrD7XBc0rogrSBXDlfvQkqewARmruUjanl7dz0NIHAD5uN7XcffwV/z5dN +TuqJ6hB0UFw7qzQfG84S6ArD1h13pWgTRZ+44T4ckCvKGxtp067B+ErW2yQECxnSdKIbQ15qYeAk +ZYMk7b3DF63ePkbatr/VGj6J68e2uyPK43xR39igsjlO1zqZDC2I1WrraLZ+/+Hn/3T46E/9ZAdw +g8a1yewqTIDMQ/5Ki42AdTjhKsBk2Eq+IKYFedJ6416+oG9ssoWSBv8qCBVDr4m8aRgVzWhB4isj +aU3v+/exe/fKxYIicGk/LBRTSmWBEyplxMXQCMSIYYFyrOSyoshHohAWC0xuk8lnJVGGHJo+r8ow +iWEtg/hENuY4nWBEIGtDTmoRTAKQpVtb1cZ5vffYjldl3NnM8AQRMBzo5QavpJV84sah7kx4KcFQ +DkdYlrUNqwe6cpB+R/PD1uEXJN+CvMnxtms3XBeQHLhZH0T3bPX22cc/Hx+8ldwZkAfLGetmm6Jd +xRiPtl5/9vFvX33+d7Pd79JCYbgVhFumt+DEJvieZi0Uc7szfBlVTmi2gmOq4wBYzVWjCy+KreUK +ehlzVGc+mL8Oq4eK0R3MruLGPsHEgGw017D9dWv4otK+hImy7fbZo+/n++8ZuSmaYy1Yi+ZMtaeL +vc96o0tBqkXRfLD1VHeWTnCou2tJH1rupNs/W+68FNMn+5q11lmje15pHsJsMEILmHAuLwl80zZH +CCKBXqMAFblmkBxI8tCyF6o+LqNeUj0wzHGppJNUzMt9Jz6sdq/bw6eC3AQshQubrV5qwDzTyof9 +IhKARRjusGwiS9Vcljb0dqW6cLxhUtsH8Zs2pCgKlt7ynDGQSRz3ALo1YyLJXYoGCRBC3s/leNuZ +yMogl1MguIB+CHLad4xmq6WSWMgTQTCs1vfKqPMnaa0/EUEA8RQc81HwtKKazTHt7v7O/htI9/cf +MHAAcC2ea3FMFS3r8OYPHmBI2cBQjxVqmQx187WpBcmXk4aCOgaKzqtjw1uD7iuiuqIPo2RvOn8z +3/3arR+WSb+AOJzQRfG0uCsvJv3Ro8tXv5/ufq05s2KJ5WlN4F1RAp+sW/7Mrx2YEWTGhaz1RCkQ +eJNjDVFODGdkOONa6xgEo1Pb1+O1GaycYM6LgJkuiOVq++Ds8pvT6595tXMMDwW+IitNkvaAA0eV +I8fftby9pHWl2yuMAP1rOFbaz6tQZAjSUrQRjke80PKr+36S1nxW1HpvdCLIddDCEDW6Ne/PXrcm +rwx/B9bdNFud4UPLnyCEbfir2d7nR9c/A/gaLd+oxgA0zqAHGvYEwX1F3+qOX51df//k9a/2zr+p +tE9JwqnEs7OLLzu9E4yw0rZ0iEmzNdudK1JHYONSkQvD6XTxQjFGvARwAfPmS8qI5btgBawpkJZ+ +/2o4e264S9B3rNAqph0oVFluDydXDA8z2QV/070dRkyBGkh+Wi0/x8lirMqxJEXN9pEdLBm+Bhgo +K5AB7c0Mi2IeQQYFAE8m0fWxIPWZm2qEtj2m6GqhCP4Mb+WBF6FECB/KSw1JqSXV3bhyAFP6yT20 +WLJg5rM5pVC0UDLCKFANXRBKfrCArIohDk1XcSyAPwtpOw8xzQJUZLtbBBEWMPfeBpnP8+AkktIC +GG90rq5f/P761V/tnP7oJYclxBDkhgmUyeir9kJxdwx/v9F/PV19k/YbIk3H69n+KKof8sZWDk+y +BStwluPh42rjgKRtXgwFpW26ywVkmfYpgiuFMgN50/SAkKctisCldb3dn15N9t5pwTYjtXEqBjOB +L1GsFwSjINkO6qcw55ATywismipKKeDwUhfDbUFqRbXzuPFINXd4sZ4vMBubCEE5qj4tltJqt6LU +hiVO+5UEM88bs3yFID1wclgdQemq1lbSvGwPX+jOXgo1qApof3b+DbiZbLRpoY5SVZyuCnKn1gJ6 +XwPl20or+L2eLK764wvNmaB0BFzC97farUPbGeYLAlA1YG402xKUHhCkjU0umxM8dzwYPcQJK61p +gDuqMV7ufr7a/xoIT76gCkLt4tE3AIAAp5zYEeWhH+8HlX0rvUMVFQqSG8yrrQOSizZyQhnzab4D +DFDVJhwTSFzgmO29ozdOuCzjwUZWZoQ2RlUJphFWT1JSlGU8e9hpn9+Ux9EePKA2NxmCSjihSVBh +NitAZAXJTrN/3Ro8ldQeyzXA2SDFA8wK0qhUdiWx4yRHlf6V6S/TfUSYUyyo4EiK0K1X1/k8k35t +fZ/imCbH1XAQfaQDTAwSB5JubvEB82W10eicjOaPRovHk+3nUWMPsj/HN/Q/PomvNjvDx+uTn87W +X3amr4GxAE9IC3poVYoLDGfhV4DYHznhVX/42WT2xo92EFyDAzQLxGPCpNKsRbGx5U6PHv70+tWf +Q04ppL0aNUWrc6BVjZGdHDBSr9l/Ply8F9URSPXx+CSpLjEqQED2Yj5oc1Hs94YvOg== + + + 4ze81AcmgBOmog4AuFKNhjk4GQDprTZPdk6+IagqQyeK2gOqz0kd0FDAHwSpo6hpAcBCSYDgArkx +WTw/efwzXhll8nKhpAhSxQ+2wAdu9mPMwGlPHv364PynUtpbRwAm2emfdPrHQH2jyoEdHkbNR8A2 +ObEHAZvJsmn/FGucz4vZLI+TEcW1LP+g2nr+x41GhQKP47qmNYCxkJRFMSEQeEUeKsoYQiDdqUIG +CshhKqToCOILPKSIeIKQxNWFarSBXKlyq1I5qLcvIMWTVELgFks5ht4wzRpNG6pSBw+vNfbr7Yeq +OaP59samUCzwHO3wbAgAQlIBy9Ute2572xSdQH68f59Q5Ea3dyQIUSbLQY4rIr5obse9z3qL1443 +RctiNZqMZtegFj/5FM/k5HzZoYWB5h4G0QlSAu6Hm0Z3vX638YD69B6Szcqc2PeSfYL0IYppNuTF +mukMHXcAClQzqkzaGsOk6SAItqvNY9Od8GLFdEZhdSmqDbAdZpJm0nBWrRErVTVz7Ia7urOju3vA +NoE5gD9AlBnuPKgcAwQBWw4qa9VIm9UmjX3FnuZRO1/SWK4axNu6OUwqh93pG9GAXDwguFoRBQQO +OKXDiM18CZLyVLd3gBUwbBMmB2QXUCnwbfBYYBfFooiRDkb4lr1S9S3NnDFCp1S2eaFB0Em+bDFi +DxK96e2CggMfS7vM5GlwIUmuA/CyQlXQppIx091V2DgpIPpG2gNRA1FDMqD0a6o5BVdX9X5//Kja +PNXtMcsEIMeAwIMuK6FetqCimAvwaNg7oPezWbZYEIplFcV9URlb3n6+aCGYQ9Ihm95PqJeKPIYq +IIuAJSr6CAQRkFuAFJKugOIA+QC8lOHbprNqD17B/AP3uGnjpexuP2/WVxRpIWUd4JGmPObmVcxT +Aq0uxgd/89f/o6HXiyWtWDLKWKAY4EJVkkjLUJTLvOtPVbVdKmlwtYUCEDMdSJQgpE2xS0UBJB7H +dyRtIukziu3mckJaP60oaEpVkhv3HpD5guaGe2a4mzTPDHedzZuf3iOBs8lSeoekVFLDaGl7a0Bd +BE1lF0STICaq1gnjlQiSloPU6fyxcgJD+4Y5dP1lVFkD2mhGV7OaJOMU0/Z5siC00vYxRl+QK8C4 +lLRF70B3lxRdS+vw6GMv3lscfrlz+kNQO4Gll7UWLCIBLkcHGBnjTENURl64jmq7pj32g6XlbSOk +z4htAqBYHfvVczM8gJwFzESQupKabupL90CWbZA2OFEx061fzc0NvJBjFBWYsymIA5Ju5otwhS7N +1sEhMaoGpyjmQlCnsrFVwr37GfZBlimWFUlqUqTD0g7Epu5u2+GubG2RfKOAaAhu00CVlQ7kL3Bg +x18nzau4erJ7+HVSOwS+p8s1CEOAvrTLKiQXsR8mR1urD5q1g2JhLieiqFlGjNzNtmRJHfPywPZ3 +bR/+1cpk2HJZY7iY5pJCWcfpGKQuCEzD3g7iQ5Cim7m0hjzN1DihbjoglnfzaUtTXeEb9cqOyIew +3OWinFZvLin5nJDPyRiiuUazVV0O+3vFQloIK+2vwVZBMsN0ZbOATmUcN6PqIaxmNsNybBWQAQQs +x9cxzN/YIB/cL/NsIMl9BPOKRaMMdKJslkE8pj3dPHDFTEaUxFZ/eAFAVEZ0+HEzoxBkhRe6sBaZ +jFSrLn7+m3+XJNv371MPHigM3yBIF0GVtAoNkz4NwTIReHWpDJox4LiY5SJZrZt2X9W7vFB104aV ++0DJ0lsuaQUPn2ICjDBQTKdpj+XTvQQY4bFcbDmzavusNTivdo5Ua8AKMP+VMmoUSyrIYZ5vMlxH +UIBOz8A9GL6S9izD0ruIrcHLoPbIr1zb4ZmgwIlVmg45oQpJHP4SJQ+d4EQzFvACLV/GzMwmTaCm +oQE9Ng1z4biHgjQBfHOCXdvbR4lIkWsQUwQVE3SNV8DZWozQ84I9z99FwRsZb71+IqktoB+COuOU +tHO9E8wUvYuToPJ4Te8H0S6Zdj8HZ6iXENBBLOQ1hvVKZYnlAkh2DAfmNMGHMzk1XzAZtuV6a4g7 +YFmlkkHRFZgWhm9RDCQ4NZtXWaFbbV1G1QOOT16+/cXR+U9YsUcxDVbqImSUK6XaluFqpRT3dIg4 +QR4DEyAxJ58T7z8gNjY4WeoAFoELpVvUubZnL117zvONXFqpjy2mHffUTAbPZRhAFZKFy2sBtkhK +v4y4GxvMaHQBcQrpEiReJisjJYNnQsfqwTt8eg+/d5/EcR9QMZdVNje4HByA+LI0MI0RZO3NDJ3P +C8CmgJUB1yXJuFx2MMyuJvPp9JIko2xWF5WtVOgRYRnzMCouEd5GXsjAbJR1WeoF8Y5mpuIIKFMp +7QUjcpwPyavaehQkDzmxK4htlq8XSvqDTWozyyOoSzEVkMkwGyRtpZWFuISXu6wA8rYtKu0SbsOb +g/ChqYggIKglmvHFtCN2349WaXsaoQ6X6if7lr8NBCmtf24MnGARVQ5ZqZVLm3BpIJrSKkl0CKHE +sSB8OnH6PdocnLxQkMFAHlQSDYkyEcSmKLYhJ3reXBAbaT8yxK22HzvhsWYuXH/F8i1IT5pUq1SW +JUQjmdiPD53wAD4LrEBwZzPPAhFl+TbDVAFngDyUykEJCSFU8wUjk+XLiBolW5xY28gwhaKhGAs7 +APKw54b7IMdyN+UZcTKEj84WJaDEijZ1K/u9aXozBHgshLPv9r/8yR/2Dl+C7qMAu5QhK/VItqoD +wfCXKOrwfBRWVrm8kstLEDtAhCiua7iHXnyWyXAKX9uaPCEJFxypiADBsItoENYfzlbvDGu4uYGx +pEcRHoQzTDtwbyBXDzZFjKhZ/j7AYCYj4FgI1sGswlRwbJjuKSUCL9qttS/zeaVUNOFF4jDPc3Bm +DHWBbuWLKmg64FH37mH5vEqQkaoOILuJYgtN/RZ4piZKfYwEBTdhhD68aKFbxNxi2UhvR4tt4EUk +UxGlgeWAQG6CvqCZEPSpbkwb7Ws/PsKpOoIlJSTGiVquYBTLNtAJAugEX5fVXrphm6/A+wO7Tjeg +sklYPZL1MZBbDD6lCA7M0rSZpl3Gl/S2FWy1B9dJ4yGTfrkWAEJKYqXeWPdHl1HjlOIb8HvdGPBc +AuwISKkq1XjOl0QvbRlDu0BK0y+buIQg7EJehMzuOlNVaXNcIikdimvgdA2yMM3X4CIRzBSlOlyn +5W0BXRTlHjiAKLdMZ4rTIBk84MBx49xN9sFbOHF40wISYKQCDBMiCCBR1rbg3SiuotmTAmJ++mkJ +ANDzd0S5AwIwVwA04AF2hrMXo/krcFqMsKNkD64QkJAVKvmiAqQiTHYmyxfrh9+CWAbrmp1HwBJR +wi+hNvgJgFsmK/F81XKHxRtdeRN9XYBfnAR2p2SzHAGez1ayGRrYXRn3SRYox9AOdtibntogKyRQ +3JgLCCMrwJanDNMBwgAeLorpTadclkfLzoMNogwhqfSi+mlQOzt7+pv33/37auPi/n0G0AxemU0e +iBngW6EAZKzVaJ23+ldSuqFamc6eG+YURf1c0cwhPs5UnGBr//jDL/7sP6UVDskEI4Csdr3wWFLG +4IQQLOBIFJOAFZIE9HUBsYBgMPkdSe3waTuVLsi9Qtll+L5qrDVjp1By0k0XiI0RDvAizZgB5gBW +CEoHIwOUSG+gJY0j2YD3hwWCZOqxLMQL/MWkKFvSmqY/m67e2QEAVFdUuwwTCqynSJEoQSJLv7tJ +6kd+uMYJH8NMRW5JYhVBpWy2DOwUQXVYlPbgMUBBGTUh3IT0YZwqUpaBjTBMrJnToHpqR3sADoWS +CgsNroUSFic1SLaW8hwPAGdpunM4IN19YQzixokX70PmgqADKiWrM9BuKAqJRlS1UaVxxcsdRqhJ +xihbMu89wDHEUJRWqSQV8mw+x8Dnykqv1jr3wp2bdsxetblWNGCqrgC4xDQh1wNhWB1/PLz6PqqB +13UX268hdsDJdWeLl/sQzgzTADmPoBpoYVlpa/oQWBz4CbA4nAgopk6zNWBB9+8jmQwDiSObV/JF +DSO9NHxwD4RAkBzSdAJ03TS3Wa5LpotrF4vyxoPyxgaGlEyarAH80nw9aV3sXf44XH3eHj8Fblko +WPfuQVpMHw0A6YciliS3HW+72b4CgQnZHxQHsLLt9TvXWxaKJkLEin84Xn/+2Td/+c3P/+rZyx9K +mE2QIdA50DWSMgCQAae66S46lrQBI0C+M7MFI582j0tADkNwwTWDfCPZBJCTuLlvX05TYQI+yfEN +oEYo4ZBUBDnLTVtsXHBiq4Q6LF8rIloJhUTZYLk+Jwwg9im2iRPgYImQfqPtA7LRfKfRe9QYXEOk +39hlA4tDcRNwBiNcBAOAainaXFHHgB6g43I5mmMjKu14CzPZEkAXREfV1jOWrRUguW9SdJo3Q4Jy +GKHCyi1BGynGXFQGCG4WinzaN8rd6oyf1oePOblPMNX0RgduMXxEc+muNpCToCOag1etwSuCjjcz +VD4vUXRMUG6prABzwKmqqIFD1lgOVtl+8ADL51gkfWCBTx9kEwBGWnCiqLZ0q0fQrqQ2kvqlExzZ +wUo1u6CASC4GqNT0XlTZKaM6hruWt6NaYwA9DPXzOSWTZUolmWNjUIUP7pUh6StqT5R6ZSzK5IG5 +ySmjQ4CW0A82KCC6DJtwPNCqES/2aCa56coKsKNvbtLFgoIgdrGUFjkEccQyLV1fwurI+lCzppwI +ach+kOE3MhpBtSSl7XqQl0e5HEyjL8stko4gpW7mFJqvSnpf1sa2uw34A/AFXM729mx3K61LzwTF +goQQCc22Wa6dT11IgVcJsVRtAHoHsFH10vtFhRJwJDmTA7rl8NJINrdFbcrLQ1gIBMgeEYJDorhX +KBnwgnzHCWmNX4J0EFTFSR2/CaL0eTGuCq4IehykHDDbdvfJwdVve6sPQF+BAIPnUDScW2GEWNJ7 +tf5Tt3omW1OKrwPMFoFmFDWYEEh8QIYpqimrK808tP1DkknBfzNLcnyt1riIKmeyPkfwiGDqoIJD +fyHLDeB4IEvrrdNK+5pgmiXUw6kYaHZcPTLtERA/+FdVH26t3h2cfSvq/TJhl3BD1kGWjiA3gXUM +13Cjk6B6qZrbEK2bGbJQFIB9AchAjMDHwUwKypTmu0D2VLkJOEPTkevPxotH1e45K00woporqCDr +RKlx0zhbRTFVN8bt4bPu5EV3/BynK+AGxaIKqAvuBECUz6nlsqfoPYLyCpDgNum05CMdkWmZPjyT +4XN5XVaGte55CXc3s1w2zwNoYzhoJRmOT29bPWDQm8CHYIf0iqT3zyuC1L7RI26+aJbRkGQaXrQP +lm5sciAb48pJVD3X07YXFvDbTI7Jp306knJBuX8fL5WsuLq/f/55rXdA8m2UiBHMRbHAtLfSrr5k +KBuzWufRcPo5RoJ4aVFsl2TqaX4vyNk8zElcq52Mt97N976t9V7kS9ZmVkovDPVQgA== + + + NTomuaasb1v+nh2sRaUP2JgSg5xcLINmrGr6CqjaTXX9lD3mCtJNSx0TEA+UNcU1KRZivGKa4yBK +m91DqjWsVVw91Y0JCFKM0EW57kRLRumySs+tHG0d/hDUztNv5XJ82lwbM1S577i7ICUkfSrrM0kZ +avqIJNIa44Wiki+ogMB+vKtZk5sv3BskXVe1MciEMh6gZEWUR63Bi0bvCTghAE5acJgHqtb2gkm9 +eypbk2r3crB4PVi8E9UpBDUsTRjt1dpXjDDEyAYvdngRrIgxMm3rgxOw+pPW8Pnu+Y+avy4hKZ0g +KeADHUGuCUrixnPF2qbZ9MYIhBUEVzYHOi69P5CWQLd6uj3VzC2gQILYE/hOPq9tZthSScexIP2T +cCEwAfxlbcgLvVLZBnS6f68k8TUmTYgeBDgwjaRx3OpeAqAVSxyKKX4w8YPte/dxAH+CCguog1Mg +Uevprd3MTQ1Mvq3qW4a1hM/lRcgCcaFgK8oMVHYRpNkGCUfCXKFkDdJfseRms/LGBkWitigk6Zca +TEXQ553Zu+XB1zGAAGRwOgJ63589dYIlJP0cQAEei8pcs7cBfAplHTyBoqIoWtZqu7XmKcxtNm8V +Si5gF2DLZo4rogbB1gx3L6yfGsE2K/dosBcLb2i8eyMxYoYDQB6TTAfF40w+7XMEoMRLTSda29GB +Gx+KcpdmYuAJGJGugqQCMZ4AHAEIS3KTE5IybgDkQjzO994fPPm16izBezczXCG9g1fj+QRJ72Mo +kGtMdw1QrOnTbBaENguSHEFNmvUFuYESLmCant5HBZHYKyM2wCYnDXipr1szgqmB2pK0LVkbgWrg +RSD8NSdc1npnu6df75z+JKifYlSjhPrAXTVtdHMnqiPrizA5NNwFyddB8+ZS7HJNa+QCVfMWpNDB +mTon9iwHPnSC06CS6t3JuagOS2WnWHIKZYcV+iBOU6DGnGyWIkgriLZcf1u3IbnUSmUQdA6Oh4Y5 +M815MRXUoWkvFGNGCy0UjTYzymZGxFBb5ptI2Ujb/YCmi3drrVPb2wbyXERU0xo3W6eGPvjkkwIQ +UcOZepVjzd7npW65bD14QBWKmuOuJLmHohaCuMAkZYBcyI/alqJOAO7yOYkgAmAdWUCMkoUzEJ4N +HPMozCVBO3A1xZiG9bN6/5HjzXm+xaSpxPfD+XBygSIGICqIEZSMGalXxPxsQSthXhnzea5BkDZJ +25CpeWFMMyMMqxXLfqFsZfI8yVaom916COXRYjusX0z2fhb3ngLVAb+C1ANRaTs7zc4L1d67+f4l +ADSDwAFUv2kx3xO1GSw3cLkUmZmkWNIKJQ3ckuEbQZI+fF1GHYjuzuCyOThUrAYtVAG0bf8IkhFF +ezwfF8tKoSQpSgPOhUSfT28sm+ndbCIIwxUtRLJamayeGz4IrpBi6+mT5nm1WDZVc8TLwFJcBHeB +wMvmzPJ3U+qFQVyYYLWitQy7oWg1ko0h6Y+2PrrRKSz6TasjVdL6NF9BCAclPTtarg4/n+185ngT +UYiBjajasNG/poU0oEpIADJH0iatwSMvAhxQS0CwsQCcU1CnjNQvojDhwJR4jq/YzhjkDy8NARVl +bTHe+mDa20CAKSrJ5YFl1UWxR1IgtyMMj1luyPJjRZ2Vy/b9B3i+IPFCK1/UQUYRTKPSfRi0HlVa +T3ix/2CDefCAhpkH8cUKzTIRwTtAWBn2jgoJgq2DKNjIMARVgazKcs0y4irmtmQCyFQgjWKIA5hZ +yCs3bLyRy6nZjFQsAZ9Jv/cHIkGzEYJaG5s06EdB6MlKP/36gwSkNaNwhwCaV1aLhFtAXYSIIIoZ +bmA7uwhqs1xVAE/gG/mivZFRCwVIqbFhL+xoTfFVjPbTxwfkQaPzaLb3hVc7Ab6R7mPBvXTVSJ8E +WkVUBGVb1vdEdcYKQDCcm3uwNcfb29oFTDgBUg00LAcEDwUeDpIcfMwAJu/HF/X2C8ObY+k2MBnD +LYqtMmITIdxcgS9jjmYtRHVAs/H9DTLdcVRIe6hBxofUgIBpRAABbngrWmpvZEWciCHuCkWbpBIQ +gJDgaL7txScg1TfzEoCw6Sxs/wD4hmGPVb2Fk5amNDxvlt6XUPu5krWRVXJFA6CGE5slTMuVZNuf +TZZPdk8/3OzfVrJ5IKKmpg6iZA8nA1A0lr30gn033NesOfjPvXuFUknlBBCwTpkIJGPlVx43+p9J +2jj93goxNzapMqLDkjEpCzI2gUtvMgCzijaW1X4ZtQDh48o+6LsHm0K2YJWw6EFWhqUBZmuYcz3d +nbILAhkhvBJeyRTdzbxNMf1q6zpMdkBfYJgFeWpr/f7k+hdx7Ri02EZG2MhIGB4CuqZiLa/xUu/6 +s78drL5g5cFmVslsioLYTSqnwHL/5L/NfXoPJ6na7PjH+f6XujmB64SMA/PAS3Vw7HzRAqpAcdOo +/uzp+3+wvSNBHRZxuJgAsAUhQaoA7+ozwgiiw7QnolItISKseL5g42hVkeedwVPBGOQRzfWmq4OP +GF2huDopVAvAYYga0DaIU1aop12hCQ84ba31uj343AkPgO4CBSJwVwEN60w1C97E28gDQ65p2l4U +P1H0VSYL5FMHA+PGlROdElwthxi5mz0h6Wxn6c0Mg+Oe7R0E1XO48kJZ28iwqdBGHaCgwEs5ZRjU +Hi72f9rb+lyxtwvwEZsiQ9dyOW1jI/32BKYUIxPDWZ88+l1n/LoEKklqhtVDPz5V9BnIw2xRyRY1 +XmibaSNmG+RDejeMbfjRgR/DitTT+zBEigMMXyWYECXhx4ig6yRdZdhKKoXyMoKBnuoCyS+jNvyY +L8g47gpCS1Y66cZjqaXZq6hx5cWHkCU301viwN51YP4IkpZCArqe2WRxItA0kOpTUH/ZPNAn03Fn +QM43N3lBHI/XX5rBnihNWbYDc2Lp3UZ9gePK/QcoyXZFdceNr9r9d5I2zRXlBw9I15nsnXzgJJAS +8qcPyExeU/QtYMuAFSDSgVZZ6XNVS9UYZQsSxCNKNli+3+692Fp/jRHRvU/Tu6OgZRipDbTk/n0a +JAC4DSvC7O2CQCsAvW+cw6z2pp+Z/n4m7/zf/0rG6f/fF/D/1bgz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN +O0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu +27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN0//rX8mYEv9Kxp+wbOfFRfvs +7dknu/1P2MbAPYGfF2efvb1888n0E/ZEb7x52358/vbxyxdnbz4SEfzK0CyH0BeXZ88I4Y9HEnAQ +MXvz+PrxC/jl8vzs2aVIKHBoDP99YhAmYdz8b/fjJ2pg2J5muqbjmYYRhA4RGI6vWUbo+17gB7ZH +PE8P8i3N9n3Ls0zTdYJ/edCz9KA//i6E93E9wyL++SzT9s3AMZ0/HvQvPu6/6qB/8XGPPll/8uKT +rU9CQhCJ3TVY1bj85PV/Mc5MjbuZv+7jZ5fRH//avIQZ+X8nE86CCeh9orcv3z8+v1z0msTu9JOD +9OR0Pv/4B/FfjEpNtl3N94gjwjJMwjS89PxH/3VnpFf0z2f98/8HhA1Xafo3F+wQ6bnGJyx7c42p +A0SEZ4eW+cnu4L8hqLRjCYpbNBszXIVJW7LECJaQTJsVuyRdw/G0MD9JR4o64MU2K9RRwiuiJpyF +kR5OhWkLZczkuEiUm4Y9lI20PRcD53ItXh6XUCuXZ3I5qlyS0r5Scks2JqI+5eQhJTZRyi+UNd3s +SmoDIwJRHmr63HLXtNDB8IQR+wRdRVC3WNJxKqG4JsM3dWeOMclmTiyhDkaFZdQoFFUM8yS5a7sr +UR8yYqOEmhjlY5TNCGEBVSg+MrylFR75tSvZWsLpJdwpopZpL4L6qRXtmf6OG5+I2pTk60XMpLka +ycAkOPmikssLKKbhpMWwIc3FuYIAn4UTcaFsFRG7hLlE2s+tSTIJy9dJOsHIiu8fmvYORtUKiJUt +KLmiWkZNRRuIcqdYVoslheObgthNe+iV0o5GCGoJfCMMdxHcwdKOUvVcXt7YZOBfy2W7jMDLpdk2 +zXcIuknQ9UzaC0iHX6JYgGEBwzYoulpGHIJMimUrLUeNuQjqlcpWCTF5viWJ3bTfDuJlC9qDTQZe +mayQy4EhFkX6NDhASS8UJAw1Mhn6wQaezfOFklZCrGLJxokKjkfwbvkCXLlOsdUyameydLGowUVm +MjyCuCRVx4kaTbc4oSuIrXb72A0npbKI4gEv9jR7KiidQkkt5EWk7MAbUlwboyr5kpUvaAxT1fWx +qvQw1DGMEcPXyrgNLoHiHit0ObFH04GmNvIFAV7gnIo256QxyYJ39cA5027eVFAsyjjpKcbYTQ5U +O+29SXDNEuHiZHh49HW1dYSRLoq7kjINksemd0wyrTLmldIu5UYJ0dN29GUd7E0b/7LNMhaUMT9X +UDJZES4bDkgbE3EVhPBxOpHUsRed1luXs51XOOuUcV1QekawF7cfW9ERJfYpvg0rst75YjB7gdBB +vqRJ2qzWfuFXLii+R/JdBA+KJQ2mEcXctAdjQd7IsIWSkfbfLumbGVgdrow6BDg8WyVgwokQwaMy +FqFkBWfitIcnVYM5BA+Ew+DEYtkAR83muLS9ato80yyW1HxeLhX0cskABwNHwlA/8taeu725yWxu +0LmcuJlhH2yQsIhgLEbWaLaHEQ0Eq/LcSBCGubyS9sTAPJKqwJIBICAY4ENH1Wco4d7fJO49QME5 +AVMkaSAKfQiW9N1ycrGYljO//wDNbJIYYlFUnWYaBO5vbNJwGSjqZHN8viCCLxVLzmZWKxStUjnt +MUWLgxRYCiJYkYFJyLAo6hnmjmXvmeaa5Vq+t/3+879Y7D3/9F5eVIZpi8X6CSO20zriEERI2jQj +V5TTwthFmF5X1vuS0iHBw8lwuXyjGP18WdvM8yQZe+GJ5R+SVEiQVj4v3DRH6gPCIERUwiOSbSva +zPHXgtRBEV1R2n6yq9hDSkgovgEzz0k93ZqPJs90a4wRLrilZi5Ve0XxnTIS4FQFwVN/uykuzuTA +IkSHAMRJiJ2YpJqAbCRZxwivUJLThidcBD6PUqFubbeH7/vzd43hJco4FBfJRl8yh4I5IoWO4e7V +20+C+KDbu/KTHUBgDHMVfWz6K0EdYXSDYMGEOoaHAC9pA9WcAFCQzSkYkdy09lVggbI5EcPTSvm5 +kpYtmyVYVryBk23FXONski3wMM+iOs0XjUxOur/BAc4gqFMqA4IZAFNlJP2zVNRzWQ== + + + IbPJZjOwlGqpaMhSh+Ma4FGbm2xmk/tjF/TNDF0o6RiZCNKE4UYMN1CUpSRNiyXwiko57WIUICgs +QRMjG6I8dbxDgknub+KZLINiaTcwkkowzAcogMu+aRJr3b+PgWvl8zyKmARRR3GAULdUciiqJfAt +mg55LoZA2MjKmZwJKI2l7ccjhGwhANq4A2+7sUmmWIf5LNuAAwgSUl5d02e11pXqjD69V+CVpuWl +HQbKaQ+lCqABioe5m0Tw/5D0HlySXGW26B94qMukz4zIiAzvMsOk995nVWV577q62lT7VlvZlveA +DGgkhMQIBjN4KwQSZrDCWwECCYEYZkDCDDNz39x3111vn2KtXLW6qivDnG9/25w4WQdthRFgIjhg +KkhKnNKVen9wlJcK/pAZZtM82bSkTbEYSQ0EwjBpTWsaZjdEJwSlzAgFVijT6Gu+vL/tre44E6X6 +VtTpWYmeZnciUlnSW6rZx1eWL4bZXDo9r5ktl09y+1SKSktyh2GLKCg4hGyYEAR9of11jy/qCyQ5 +voGhFiSywRHGlo3kInxOlMuSVudl8hf0Y8lFzZ4K83krMWvGJ0W9rpstXq8k8+uD4eVS4yjGHz0C +MtHVOhh1zMUDQqrWz+QPoTqq3pfkGsNmQTvk7+4HouAul0cBBkKhJAQozICmElC9ACrLlGimxgk9 +M76JlgnScduekY2B22eMu9Vxtwa1wkFAeiHahooxkQL63e+Lgp18Xh0vgjGXEIKuMdn9bYJkl1vz +eg0g4cBoeH/7sjgv1rwBy+PFlcS8PlBokherGG0IItkBDMQYNCkmFxFaqCM4jePyIUoH/wDY/iDo +yAFDhiGjVGJ0lPO4NbdbGhlhAoGUIDbD4Fum6PfHuUjRtnqxaHPMxeHi3V6ifT4/sF0UlKmYM6dH +eyC30bGI2y2Cu0bH6LExlmXS+eySrHWoSNHjj6IjgpS8v7N6GTWS9QmKLYbCZItpmAFRzAeDCk1b +DFfg5bYeHcYslLJIhx2IY7l+JESnUGuoBtkNQyQ7pOE4aC5N78Uzs3A7Yx4JpAeyFaUGsK3Humq0 +nUrM3H7T44vblykuEWIdToYl65nOXDK9nC2s8XKF3AWOHHTocFGQ+mp0XjXmZG0Kv0aHUyKf06Jd +bzAOsfYF4hhJRevJWl9Qu/H47PzCxUp90xciW5RH7ZlMcTtbPpQp7+hW37Ymrlz7oJnru/xakOzJ +VsJYwR4oSgv2Zt+l6BCXyP72azgyXn4iBPA/WYrJjI5THrJ1mBMkbZt3eQyfPxEMZVS1LauVURe4 +RfUFMoI8pRozqjHFS639HV1g2FAa1eMRyL5PbsHr1xgoC1dCBalQ0uczfT6Ii+DxSBAgYmDcyti4 +5PYY4ElACwoCynKBQFyRAyMBeDC3W/V6Y4GADaJACYAZyOKYm3f5lCDtALSy2ucENEUBw46OZhgg +p4KDg2cgeePj0vi47PNZdCjjxV14dCrkjI+zILGR0QhkC78fCtmjhC3FEMxeEHqkh1kMS4Zmc4Lc +wqBFuAo8GBUCdzF4YyCAdyVdXmnULY26ZNxdrbLr9vLwpfAMZBcUJk0xBUmdSKQ3Eql1w2hJQiKT +moinZyNiGQCDbWaFrK43M+nFTHHDF7AUpSzKJdhF4jr4Oie2FG0qU9hx0vCxKdgSw+yxfCFCSKlg +mJOJ7GK9dejs+bd2Z47SXFJQa3K0Lxt9RIa/71TGClWAHESHvhCkmhYdqMYELzZltQut1IxBr3O8 +NTjlDSZ8wQQTKUlyXVFbeK+kth1nplRc06LtEEN2S47wJfhAK7GYLmwp0Z4VH548fV+qNA/A+0M2 +uE5U23DsYFT4YTBAIJTAvyEZVMgm2xcrTfASkRKmwETKXp/uJeUW8fJ4wOfgiipoM5Umuw2Pu0Xg +JESlA1SGbF0SzrFcleOr4XAhEEjif0fHGbeHhxcNBKLgJVmqC3yZ50qS2AgEE+CoIFQ1aI+7FI+X +7Jvn8ajAmNutoLJhJuP1G1C3sbFwIGC5XOroKBRTCoYgRuhZmOQYhIOGbIWzQBrLFkj+YvKAGSkN +k+W4Ijwzjgn/hmPi+gEtmC43/Dx4yS0T9+4Wx8YEwInIsUv8O1MBPyybhzxpRh9WDfYeGMNhUVA6 +nPR6VHg2HJDslU1ZYxgEJsNweV4EDh23RyA7x4IkmQyphdxL5w4Vant6dILnc4qY7bYPVhqb4Uia +E8u8VFaMhuUMcoVlNdZ2eTRVq8tqDR7Pic/FrIWYuYSe1a05VgDeTIHL50pLvqABN85GirnCTq29 +15o82Zw6LllNQalUm4fN5JyPSu1vh1Iy43PxzHoiuyGpXVySrNbJzqJBJ0CBTAqmMxNPrdRax+3M +ki+Uo+G12CxLbgSUW9WifVXvkkQZzmBgRbkK20+zGSs+1+iejCVmdXsyU1qi2JSb9GAWLg5JBMoL +HYGl5/kaTgThGHdJfCRnO5MIv4AEKgJrp+pTvFAPeNHd+8zjNVBximxtVObEDr7CGDN0FuMwOi6M +u2XIFq4N3/r98GYZl5vsIzTuRsm4QDCGDI5aw6kqUjMZXxDFptePHG3sJ7I84OH1IEyZXp+Gt/j8 +CGvIyI7PT9w+2Q3YA0sc9UETvQacP73vFkCPnFBF0ZEXgARFbeMrDBK+xYlUrQP5gIhDAb0eLRiM +u1zK2FgEPEZMnUsGEwYDZFcZwooexDFoseoCwDwKTkSFUsASTF2YSkpC1eUFoligcWw04if7xhdh +SiG74x4JgxaizfFx6pprvHCwLCx3wOI48GeNtL/WDHNZPxHlhCpVSuX1qDPAYVW9B+8d5lOclNGj +JUGCZllkriA+B8ebSq+ISgfROEhn3H4nRGfhY01zUjGanoDKcEBmUTXaoloT9SYtlCguZyZmm/3T +ZnImCHKQ6owA3PYMe1aNDSVtgLiN3/fDnISTQEKAsiW1o5vzojYVFpoMshJXgZMB2e7v1JoNhBw0 +r9cPM5PTjRmyCWFAA59ArHG/cFw02SS2wPIlIzqRSC35KdsfisH2B8l2vjDY0BQF1gIVFIWKZQ2C +aMMxFt4bx98P3bYX5seNoltIdiAQfGXYkqxOi9IA0Zuh827SxWQ3V/Ty6BgCGu31WaFgHg6ZFD1A +NmNHngVcwUgAxv6YV+hwzuOz4J0AEp6vwpkzdFzmC6FQbGQ0CDQCV6FQOhiETqUh0KFgQka49msH +RvwuspUuGM8Mk4aCLwXMNEXpKGoX1YGGwjMTn7+/qyF+Mj7O4bJxCnILRMvCeIEAA/54MJgE3nBh +MNiQfiKdbolsKOrRYNvQEZDdfHp2afbaURd3zYEgDhWm0hrcsl6kaINcjBuaboyNUweucbnGKNBa +AA3iUWAj4TBRDq9fRtKHqVbkpqa2Fa2BsiI+y1qbEfMev0izFsenZKUIvrKS82q06wvFRK0dZFIu +ssVTCgCznDk7MSsqNU9AR1yi2CT00U+ZVCSFBCeq3XRhNxZflPROiE2azhAwQ63JNtFSM57Zytf3 +FGsYFsj+scAVFUl7Q1G8S7eXVXNZBnL4kp8ClkwnPhu1J5E7SI7zaWhMqBIuHt+iUuhWiCPSpSjX +7fSyZk2zZIt1sgEdkp2iNeVozxuyRt0CfsILZXQfxipCNl4m29czdBqnGCUlCKCIcETBQIyhE+hH +VBytDWb2BXQMKdCCulMUWjIJzIyOccR4g7WCMSjsGPEtMvSFuCa3AmaDqkIBw0zaTzKjQ5SX7CIL +vCGKwmiJwJU/oLldnCQgHNX2lRr3qI2OiT5vDDVFOhsZ8dKUFWEzfrJFWGwcAkpIRuO5qmZMgZOJ +Cnvlv2+9SzYFDTnItqApQOXAiG9snAbwEHjDNKRNRh8hkIK+CNtE0gbCMpPbn/1gDpDttUXcS5hN +ISiRrREpSxAyXp8wNh4cG/OPjwX9Pl3gS7rWpOlo0CdG9TIcJijX7zeI34ukPYABHeX4NIoFfSeD +g3DtVcjkm9KISCV/QFWNKsOn8RMyUQODGiDUkcxuyXoXrsBKTvopAwPu3d9C1gfXyiat+FTUmlD1 +ejw3G5HLDF/k5QYyqQ9IYNLp3GamtE2xUORCurhlppYErYPY5SObc5bsxKKTWwLpwadJsY43ZJJt +Pz1kyzWooWVPg2lxC4pWAwzgVYj79cWCQceMDVPpZU4qBQNGtrCg2HW3X3D5VDduLUS0slo/XO2e +iahNKpyw4pN0BLoDNyLC8aKUkK2EPSvL9XF3xOcTw2FnbDyMTke5AQCyqWk4EaAgqZEQbSFF+gM2 +rDXUyuXSxl2oVx4BzedXveRFpsW8xL0QHI6O8fhlQWjCJCBxBGnLF9RRxJERYni8XsiTwDBxv0+N +MPFEvBOgQHRIDdY+rZUCftvnBXOq4+NMhE1TwRiIC5oVCDhBsodtkmxQSWZ0MT5JnN3lEdxeiey7 +7saFSVAo2CeXG3chBEPRfYvFjoxQ4GFw1H5G0A29fersQ2RybDTkdnOwefghcAspdOPgAatQWCiW +pgEqnyfMMVGOcRA/99ESA1Mx4WSxvIIshjQK3O4znukmOwBHda22P7UietxGMGCHyI7KCV4okqmn +SKbe3uaVwshYxIXsSSyxyYmVbGFTkOu61lraut7l48kcF4UcnWLZjCiVAC1Vbxays/Mbl6Vow7UP +DFA0yxZj5mxn4nKuuktH8oJYjiWnA0zcF7KgXBxsfGwyUzxoZRYT9uDQ4at2duLAGL3Pz2RjcDSj +og5Yvoo4X6xswT+PjyvwDPgW/6vpXcRkspd7ONPuH+XU1MioD1xBdo+PpHip2OrvtabOiHrLUOuD +qSPekDoy6h8dpRg2TXba5Iqx6ACChTZhIgmKtvblifUSSiG5GGgPs/FgSIva4G3z7xPdo2PIeki4 +eQkeLAwj5Gh6PcLnDoxQIyMh5HToyL7opESpyxL/4ARo0+Xh9vlEBOcgbYEh0emwW4ZWdZJdl0/a +nxZD0IDBs4lIuVS/V48waUNrhgAhJiEIJcQ6ECnZsBpCBuGmnGJxmeXS4C50BKBIhTK+/aaDOQei +ONZRFWAM0IqAkN0umC7yRsg6EuVw7ownILvHWSZkIYCAu0ZHycV7vBCXdCI1EzVbrnGKoTSOjYUC +SBbIKSobySpqA3THSzXYJDfE1KOMjyO/aCEUIpKW5BIoHRLs9UQpIISNk8YkaEzb5lS5scWJeZA8 +RWb/0ODWvmFOBsl8aWNh44o3pLFsSpIqkUgOPMZEsjSTpBmnmJvZOnqb4fQ8xI4m0Duy1DRiE6nC +Cq/UvPtqzmsVV0CNCNlkeoaO5EIIwkyGk6qt5tbV259sdDdxXo7Nh8FpgSggGuHaWnRO0SfszFqI +qyCOqTIcGpgW+h7HeeFjRb4StQa+kI4RlohxygdCRpCOgnvDfCYcSdXyC7ff8Y5gODo6GgrTph3v +g2lRo7Fx9I4GqxazOog84ByKNkMhg6IdiAKOjBu3ot2jZ+8LMkjr3P4zKQtfKSoJ+Q== + + + A9XYTm9j64Z6eweaMjoadLtZIAHiMuYSwb2oEScUQQ7wddBTsA28sWucHRtj4OhUqRGLdngpP+6V +oZjgyZExFgoCURa5nMjlVbkai3WYcMKxuv6ADtoZGQn6cOPEJyfRp/HkkBczf6dBj0fYj4ciyYmQ +b8rS1Lyulfc34oZFJMgBwGAI8UKBMICjYxQSja60QI/XvMk9NoqDIwyWQLZIDYiQ4+Osj1gpAafG +v0PBOLhr/yGCEqLhdfWRMQYcBWUMh5M0kjiVQFoZGycAdhHiEumwTdOOJJZTyXk52oXJJxtshswA +eSKmUUwcoOLFkqI3ESEFuUIxqZg1sNIzLI/wnuPFIsNlOCFnWh1OKo77IGc6sdw+newwDIXyydBi +QSxinHH8EJtm+TzI0OXFwdNGbJArbyTLW5ozTfMFbyAK4iVh3Ce7fArLF5BGmUiZl3shphQz52PW +NMyVN6CiXrhCjJvHi7TlEKvsj3n8AAw9OhbE1zCu055JZOYTqX4mNwmTA4cjo5Ruamw8hG8xFKra +48VmREDetGGVQ5Tp8Ymkm5B/pSKA6jgLmcqmizxyktBQ4+MYZHQ343KxPp8iKhXN7PJSlcw+BXWv +h3e7IygEqh8iM2YZr9+ByY9E6lFzmWZzJBL64LhQDgXG3usjc3cRoeGk1pAmiFLvby8/BopwCSG/ +5vdqYSoetwcAg89ngpOpEPRR8fuiyCO+AHkuJkk1/M4IbPYYh/MGAmRj5DFiHTmSdsGT5KlNBMwj +iyWSQciLw8vnNxi2CJCAsqgQ0qiO1kNGHhsXSET1k4uRhDqE3uOSVaE6Msq86U3wXWRvbWJOPJB+ +llAomdAQIcdB3ClbBm2CPMmkhwvQipPdmwMAkgmpJVqjtUWxEoRjoW1ZLTNcyh+yg+F0gMpRTMWO +r2VLR+zsKgJLhMtBRkEjwDAoGiLoC8YDoSRUGycNUwlZKvtChiDmJKkkyk07uRy1Z2kuiwgPr84i +QbMpikmq5oqV2dWceQppMZSgmHyYzDMkvUE5AHPIlbKFQ2p0kgoXfEEHrR1mM+AWtD/uKxSCi2tG +yDbvWQ+ZIJJIBvcqYFpOLtBcIsynaQaJLEN8dYA0I0XbNBv3B4FPG8kCiZVmC1Bh8lQxnIJYw2ri +jvajfYmXWnQ4z4RzZK/7UcrnxTBGRkf9UE9f0IKfDNJphvguA5SCgkIgXOMckSHkxAAOWGAiwF7a +F0wzbEXgq8GQQeCxP1mKGoXCmTDODufJ5DS174PhGY9QQZOCaXSLPg8kqRqiMqFQwu+H2wRgYJiT +wC3NwMBXDL2vKU1QhN8b9bjJbslvepMLJspFPA83MopGI1OpHhJ+44gbfpI1pAOjDFjU7dbdblx2 +1LZ6KBBQHQ7aoQB5kAoyxI3gXZA2hiomYgsIm6OjMGwCovE1B0IgcJ/PIBN0UFuERz+4NCsINVAK +pN/tUvFGls15yVQG5yE843CRimEMMMK4AIHPJ1NDinXIxDud4aWeYS6lsjtKdAJBDKPhxKfF/S2L +UW6ezytKQ1F7HF+GWLjcssAWUolZbxAULUGLdXOq1NizU8vAjy9gabEhL7dJP/qjZnJDdxZprohi +hdm8bk7HEkuiBCecUow6E8krejdIx8n+wBSSfk6QahSNgeLh92BsvP6EN5D0+G2PD4qW4Xn4nxJw +gqaguSQnwlm1gsh3QdPl4r1uVSJMGB9zhSGCktYQ1JovCL4iE4aqPmHEpv2EObUgeRoI2c0h3VNU +2u0x4JNpdJBfGR0LIX+RvdNxp1ANDJ3fClMQhaTHY4wcoND+sN9wI+Nk1gsaZAlSNxZb0o1pMlMk +VMMMLoAhKc+ngtUZYqjyqtYN+DUqqAuRzPgYPYrsNibwbBNvgWKS3of79cdgNoIhB94J2hTwxxk6 +h690MINGu+YaD9TNNU6eTh44EHrTmwLjJHWCOkyQiQvcEkpCrw+MsDSdC4UwelmKypvmQBThaZOG +0goF7b9bR49LAuqoYAKZJUylRkdZD0maEdCX16MZ0RmM0v70hYxGBszc5EEDdFn3kDLFg0E41cQY +LnJchBKhyh4PeRgBM+aF3xMaWmyCLD7xqSxXZLlSMJxAJBl1RcCH6B0rPoTM+cjCkniQgoYCnNAF +lWHSAl9R5JaswdWzIdpAlXmlxErkUZEIA693Jb0XJJNF8DYgEA2HdXlECCIMbURqhoV6IJiZqB2e +nDnugfB5NSAZEqaQtUDQU8tF7kjNpKY95EFejGYqotxiyIPUIhupBqgkxn9t9brl9cvIaLBVYy4k +cYMNJzg2m4gNmLATJEE+C70ecdFjbiHCl43YpJ1YUvUBXBYvZHgxN+aKjBAJiBPeoJLkFbTIUpyQ +zXH4X4E85Q9EkfFh+QSuRlN5r9dCz1JB2+PmEc0QynBV+6sCyOzWmBt5MJ5JLMpS2uMBf8Y8PlyY +6HJDavHLEh0ypUhKk0qQJw8MPzIRIOqG1MLzsMQD0xjAOogFkTPotyJ0gQO18jWWLvq82oED/gME +2DyQgH+4xxWEApioAOI8xjAYF8Q2ZMXjjeKrFzToNkZdiJn6/gOIkqEPIFvIm7gjvMg6HJDVCE2u +BBYO906uB+C30XrjRHB1huzrDilRMRrIjxEOloPM+YNbcFiEZdy7j9QIQsy64PC9+v6UBdrNGB8X +IHYBsp88EEuTaWdgwI93xUBuFBIom+fEGnyOy8VQFC4AIp4I4XT7D+LhOR1nKKilERcLFZCUuiRX +gROv30I7+/y2nxA1R4cMLpLABXv8MTCMILVVvZ8r7cQyczBdwI+kNOEcyDwM2nmcxQXQ4RTD5j3e +GEVnQ1RqHIBHdTxKIGDTTMqKTzd7h8uNDSQCmiLTPhB9IIoKObCvkXCSZ9KyVMKAgHbIlCysmpcA +W1HrqlIVpBIwvG+D5f3p/TiQD1GAlcIQATBgKnhCQ28iT2EwA7gdMpFujpGt1FGXmN8f3RcLGeN8 +4JrggWsCrnE+4LchHDzkPhjze1VRQCEiJAJAXr0YLg3O2edRUdZ9WZfGxqgD13iBUvzQ7zVYKiWK +5X1LpgpcDtYR6oxsi3CKUwBOo6MRnII8NSAiiPN6Rg/g4FwkbLO0Ewwm/MGML4h7bI26hBFotxdZ +PgHw83xZN7qK3gmEyBMNMsk8xlxzjRtSG/QbAZ82NgZ449YQCTEO1P7saIoKJ4LBGKHEAIxBio1k +yPooiuQ+YAyZN0jmcm0yA0YaEOJruFwyOh3XD6BSdCLEJNx+HQMIvOEtKBb+DVcZM/uJ9FzMHgbJ +9KMB24b46Q/KQQr5KA78y/CoFgx/wRPA2+Vkap4XyXQQWccCCiVPgVEyE5FQ0yBb6f35eVgXGLwy +zWTJ/GckR1bc+aI0kwFTob6gRzh5AiRCGlE0rCDWoVyoI9wOCopGQHhkhaJhT2jRLh0ucnwd74UD +GQf4QTiRfDBoAx4YEzCJL5iCJUYdQ0EMlCOKRfIUm85xXC3C5P3kKQAunofc7D9rFhF/4Fq9ARMj +mUkP6+3tA2A2L3xvan+tlACdGnfB+Rv7T5dMFGV8DO3P4St5ojcaGRlh3dAyXxQ4gcaBHILwul4J +Xg6NDAlD+fxkARigBRmCdYmMjvhHRwBODll+nNxpLBVfiHDONdeMH7jG7XMTLOHCQAtQTPf+80R4 +J/wXQgf+gYPgLDRZcNISpAasGmj8wBiPjEziz352gNjhav1ByHomTOfgVcB+DJUM+vWRA4jAEWIR +gSK/BePEi2QVSkQowOpQ4WQ4Utx/Ukwe3olqVTW7crTtJlEUltUmTjKSw4uUyQPcWhTeRYJYzBeK +ESdPE58jkSWUBTqcFISirlf1aF1Wm+FIiRPKHJmJqoVZ27Q7ljOFgBwOp1Aml09z+VT48073hKQU +kdCpsD3uVUbIrRleuAXyQL9KVnLypTBZtmGNjMuj43KIJk4J2QrsDSUNRwqi0ghzmZExCtnZ5RbB +mZBpJlKCWw4zZYDZ60OCEKDg4Ui+Uj9Wre9Jcp+NkGeIaByyBMVLHp3sL/WU9tfapalwHkEJgR3U +h87yEvaIBYJpUWgpMuQjAeCRaYf9xTZkBns04honqz1xa5reVKJt1Gh/JjNKcvoY50cw9Kd8fiQU +stTES2ZBo+Pj8sgIAxXb98OAluyB8wmSKdAwnZD4YsAvuV2gNQd6igQHrQkEyYJSlk17XJFr3gQI +ecfHWDAw8A/vx7JV5C8SKMZCXJgsb4B4uV3S/sph00eeg+MeWdzy/sMpDl4lQEJoIkilyE35yfIP +D5nnF970Jt+BNwXIVREJS9DhLENWr2XwDw6QCNuA5RhpH+3v0AqGMrLWsVOzUXvCsDpWaoqTkOLr +otaR9Y6ZmHEyy8nCBhUph8jCEgRABOEKikuevdLo+jzNgM2ihI7YFPApa8jpZdQa9ZU1CFZHkAq6 +0YiaA15qCFI9Qh6al1St3WweLZY2NaOFIE9mn0JIZFl4IZhkpCFeKCG2e0MwHjJ6H8ihmKyoNmWj +J+ldhDW48f1nvvr+StcKwxV8cMhMzrCmk7lVViKz3JBO7z7vjbkVxElZH0jaFBR2lExagtksxWjJ +ehNX6/IgiMVDNFm/KqkNqCrSJZgc6AIJB8nyHgSQPu49xGQANrgdWS5xfCXMFAFapLwADZAgBSQ8 +ZLKacAIRRAg3nWC5AoULDsT9lOMNkAUM8JkhJGU/WjXj8TthrqRoHbhWr88ic4w+bX/tAQ/XBFuL +4EnTaS5S4CN54ArX4yPP0InukEdLYdQ3iyTuJrEXmgsagV3hfT6kMwusyDKgF+h72tBrHq8A4hXE +vBWfQiOAPwFLTqzA7gZIOEqpaomsbfYZKDQqyPK1MFcOkAW0iTHCeAAPeewIQSE0Qjkgiqg9bcen +ncQQ5UaCDvgJXMmj2GAcdRQUjHC7UF+1MkOkITMxJeptDpAwu6n8cql9NJ5fFdUWechLW05qKCgN +8EOEzAzkUR0t1hbUStTpc0JBNVp2ZkbSyfI8SWtbqdlceT1dWIjGpyJSDRIWMyct2Cqpyou1/d9p +qNFmobou6fUgk8SN8EpXNqZUcyjq/TBqxxcUvRXPzoKI7NSik13nlRYVyfFykwNQxQoIYf+5ZCoY +jjN8Bi/FaBjWwErOx5wZUWnxfJWNlCCdfjJlUaDJwsUofHUQ3pJFZaHLcBdx8hiFzeGAePES3kLW +xgco8IwuiAUAmGJSgtxADuXFiuVMRhHG1TonlHi5GmIzbugaEMjmDHtKM/thLkdqFDDJM9BIlsVh +JUhAL+pMcnI1IpZwnayQhougI2nFaOpmH62Hy2D4Ak4EeQWAA4EoFYqFacQoU+BLglARMGgchh0k +XMAdAa4+ONKAibfgW/xvLNqHWIDqPX6TLLDx21BwpBVJqph2N5mftlL9WLzVmNgxE9Nk/U8oxYl1 +XmqzfEVSKnG7HXf6rFAIhBOorJ8sA1NxfNwOETUafkkJhvSoVacZWxDTslqBhUaOQw== + + + YNf0abJwTsXoZeFJoH1UOM2RAnXi+Vk51oklp+PZOdVsaya4q2g4rWJzvdje1u0eMBA1692pY2qs +w8Afak20vJkYGs5AjjaVGMl6hdJyo39IUCohUJDaslMzwFWqsJAsrAhaT1D6kNoIn2A4VDkJfrCT +U2ZyUrf7QIufTiixnqBWeaUi6W3VnDLTy3ZmOZFbjcZndKPZnTxlZxZ9VJyTak562cng5/NRZ5qT +SmEuDahEyNp4G2orSvlcabnc3M4Ul3Kllag1CVbxBR1Ja/FSJUhWMDr7SyNiiG8w2/sPfzXy4Q4m +xfEFSW44iXk11hW1qhptWMlJUStTbFzSG7hlvHR7EgOVLa0lcwtmeiqilMcQ3umkKFcVo6PbU/hK +blBv2snp9sSxTHVVsfuJ/GKysJwgS7gnstXVRG4IdElqPl+Zq7Q2ErmZ/Sf7f19sX+DkkhFtMRGo +oQrh2/9EQEWLDaAmRFCS0wSlYokVwecYTLyxELUm6u3damdXUJugGlYoIaGTR/ZUjI2ko3a30Noo +d3d6cydXj9xcbO/yakPU4YWqbh+MUFVUmpY92Wjt5qubuEFZb/n3JwTC4TgvFeGOeLKCt5bMzuYq +K4ncbMxqkg/ssEBClxOqFFmiVo7Fp5zsjBKDvnTIR3L4PCcVNburWhOGM3Qyc8XmVq2/E403Daee +yA+d3LSdm06WFqKJfqo4r8cHcqwlGXUwiaCUJL2qmR28K1/amF26NLt6IVdZNpNTUrSDWpjxvpWc +yFU3E8WD1e4ZjAnLIX2APRKcmI85PcixnV0UjZ6gd/L1Q2Z80rDasgFg1630ohGf1ayhGpvM5uZm +li/EkkNP0EThUrlVO72oxgZqrA+Q45cFtRZ1pijW8Yc0oNeMt+10L10k95IsLMExRqSSbvUCtBMm +lEskGwwAjIG1RKUWIJ+IybJcjgrjJ046v1pq7uQbm7nqGl4YLtwmOogVi4JeM+ITRnyyWN/OltdQ +LMPp+YJRhk2KIsgkI6ltKz6LDs2WVxv9vZVDt5W7hzC8qeKKnZ5H6XuLZ3tLZ4vtTTM5kcpODBeP +Ta+cbk3tAipgQs3qy7E2TmElBopeK5eXQKGAlm728FIMIiXtqePV7m48M9Pqb6UKw2DYYfhczJnI +lVeL7Z0S0KU3Q0zaSU2yYsbjEzgxE8+AsiaKja2plUsrR2/LNw+W6qtbR26w4sNAKG84C7HEvJmY +K5Q3e7PnE/k1YNXlkWja4SIpw2xmyktObiFdWuvNnav2jqKO6fx0b7Atqo0QBW8Gj12U1b6TWck3 +jjQGZ2Lx6XJtHQ2CQMdLZTuzlKse6kyd29q77/TFf1jfvrJ55EqiMBNL9EvtzVJnO1GYK7U2Z1cv +rx69PVla5JUSJ+ckteikp0BQjYljnenj6eLi9t4dvfnjfLTGq2U72U/lp0udg/HSZrq+E83ORVPD +Uvsgw8f9IUVSS5nicmPqTGPmXG14ujZ1OlNan146m6vMmMlWrr7uZBfBVPHcUrm51Zs/hTcaFrA6 +GQhbrJiVUGWrZyWmErmFSudoc+KUqFVkvWzF2wxvS1o2ardy1fXa4Eitf6Q3PDm7dBEWTrf6mjkA +3+L2k7mlXHmt0dtrT53JVw+BaaGV4Uhai7ZT+cV8Y8PJzsWSU1ZmJltZ0eN9TqtpzoSRmLQyc4X6 +Nka4N3dGNztsJC4IGYZGEDB5sZ5ILU4unevM7jUn9/qLFyrt7UPHb8LIQD01s1ufPLK0e+PWyVt3 +Tt22vHE+mZ0wnU65uSmqddloC1orlpwZLl/XnTlV6+3OrV5G44fCjhytgUXjuYV678hw5fzkyrW9 +mb3jF+6ZWjxhpQYRMaeQT7UsZaob7bnT5c7hbGm1N3uGEXMMG0tnB5pR8fklRS/Xe7srx25fOXJ1 +7/w9D//jZ5zUjBlfnNm4tdQ6wsstUe3GknOS3guTZUs2mCpEm5DCVH4yU14oNMAPRxL5pYhUrrc2 +3vexr6TLyx6/mkhNzixeSGRQLxDjqXR5C8R7+NitvFb1BWMGnFVhuTk42Z48O7l0qT3cO3XunvO3 +/IPu9AuV9fmN61YO3bi8c93k0pmlw1c3Tt69sHzx0ac+XZ8A/ZZyxZnG4Fh35sxg/uzsxuXlI7cO +5o9vHDx/5MLdENbppePrx67WJk7Y+aWplYubpx5ozV+OZwaFxnQs1YqIGc0aOLnFbGM7W99oTu21 +Z04ki9ODhUPl/paVmoxnZ+RYPZGbThfn04X5ubWrlfYRXs1pdj1XWdQsOKsO4eHMfCK3lK8d7Eyd +6c6cTuUH6fxkLN5LFubL7e1iY7M52J2YPbZ37s6NwzeCLXWzVe0dmpg7Nb9xaTB7qjVxvNw5GnOG +i4sXlrevZ7ikrJcAic706cbgaKm9s7h14/rOLVfvemJq4XRYKADzycIaYJ8tbzi5zXR5rz93XTTW +jUQyolKV9WqpsRLPzxQaa8nCXK6y1J48GotPQsWS+cWo3S7WltuTh8vNDTvRkdUi1HBy4bydmi7W +13C1utUtNdYbE7uZ6oqgd+P5ud7MkWpn3bDqtf7BRHay3FiaWjpd6+1kSvOd4e59D/8TDhW1O/Pr +F9eO3ja5eqk+caRQW9PNSRjaTu/o8bNvqbbWWd50ku3e1KHF7YvLu5dnNq5bPXqnlZxJpJfVaNvj +k2APUqWtua3bpldvLLWPlXp7RWIqFlrdjd7kFs1aoXAcTjuamnWIuC/lK+uEXe3GYHi4WFtBPDdT +C9nGoWR5o9I7lKsuB8JmIGTAfYly2nR6yexisbFdnzjamTnXnD6L3JfKzOeqS5nyZL2/Vuls5hur +mdLM0vzR933kC92ZIwyfzBRmljbvWNq8c2Hz6vLu1VxjfTCx8/ij73nsnz8HlzK3fmHt2J2zmzf1 +Fi4s7lxdOnRLIrd44/Vvedu7PpKpTXsCumFNZopr9cHR+a3Lh8/eO1g4tbJ6+t3v+0RreBgY6E/v +NQa7gNzOibuu3PrEyeueylcOLc7vrW9dAjxiTjeeBagWy61Dw9UrO2ffeuL6d0wsXjx85Lr1rTOq +WU/mZ9KlJSs1dNLTpcbaoTMP7F54CLqQzs0BeLJewREMu4f4yQi1MF8tVLanls4JckoxivHMJEoM +a2FnYEGnp2ZOPPDQexfWzop6dXL5xs7shVrvyNKhm9vzl+38tp1dkdVaLr8qKOWIkM4VZsvN9fUj +Nx48efvMxiUN7kVrDocn7n3r+3WzWqzODRfPDpcumekZXFupsVVqbsOU5kqLmeJciDF5KQ1yxk0V +6gfXdm64ctvjIPMjh687snd91GoUKnP1/sHmxLGFzSvnb3rw3kfeDQ7Z3bn2rY++e2H7IjIRJ5cR +FpCXa51zg8WbJhavS2Vnjxy5cPnK7YViX0Chk5NmeilR3CjUDq4duS9b2WL5bDI3Az1FC1gJKP5E +urJhp4bV1sYdb35q79wtYS4B0yXI9cbkqUr/mJNdEORmzBxcunT/Wx9+byo91GNtIKrYPVztn1jY +vkU2GuFIQpBy4Uicjdh2fJAuoMWOoUzN6fPZ2iFRLM/NnklkOjSn6Vap0trsDfem5o9NzOwsrp0y +nIYvpNqJVru/1xqcrLYPQ8WszERnsH3p+rccOnsbJ2WbE7v1yWOF1vbkyuXq5F6yuIwqX7l83633 +PZbI991+3YyDkZbiuRmAdmr5HAZtY/Pazz3/jdmVM5bT3t698cwNj64ev2vrxJ2nLj+4cuQu0xne +cOneW25/XFQr8fQMTtoaHKt1dttTx2bWL/cXzpqpyQsX7zp4+JISrdZ6B5vDvWxlPV/d6A5PHjrz +5pnNq+nCyurGFTlaH/eI4Hwzjlg3IRl9ZI2oM1trb1VrM/2JLUHJWRD04iI0MRqfyJfXhsvn4/lp +2ahOrlyx0lNKFC5iQop13FTSx2Q1c7JUP0yxCfjJQmk+kZkcLp2c37xQaG1JMJNSvdM5dOcDTzuZ +Tq2zurxz/cTCuVR5NRbvmomeoNVEo4m7yBaXImIyFm/EM1NJdE12NpUf1tubME7ra6c3t8/D+Qxm +ji1uX57buDy3fn5h48xw7nAmM/no29/11W//6PCpW4LhhCCXVaMN2FQ6J8sdjPmKJJfuuvNtH/zI +s632Iixcb/ZatEZv/tLs5u2LO3fBBMoqvNeVRn/HTz5TbCvRVnPyRKW9M7N8/v7HPnLo9G3Z4nR7 +sE0zccloRpND2WhBbpq9I8fP3L177GrMbPWnDtZ665JR4aSKavRTuaVa91i9czjCZzKpiVxhjpfz +GLpEgaSzaHxW1ZuZ7DTLOwFK1qL5Yn1hdvn07uk765OHkS+8AcMXVHk5KSqpeHpQqm9Xe3v9hZMr +OzcevfBAGoIVrbUnDlqpdizZOnr+ofWjt7em9pr93d70HvgkzCPUO3ZmVlCLopLP11YBg6mlM3Mb +106vnrRzA0FOZAoT5dZqY+pIf+Fca+aUmZ4X5GKhOMyX5pAFTKefzs4aepXjksnkxGD+VHvmeKo0 +1505UevvqrFqoboIMOh223D6RrwvqPkQ47CR1MUL95JP97h4js+j3YjP0eE0GpxUFpRivjTdndyB +BLR6B7eO3zO5eEO6uLOwcmNv4ZyVHXYndm+85ynVavz9kx28VNPNqXRlt7t4S6667adMSS00u9vI +ULXuznD1wvzmTbt79+4cuaM1OF5uHrTtxrkLd0/NHQkxFqeWebmkRMG968niOgghVVxSjcLJUzc1 +mysCcqI1KDc208U1KFeqsNoYHM/nZ1c3L1U7m4AuKFfRKyBJx+l1+9sT04fUaIUTcoKUB7wTmdlU +cdVMzlRaBwuVlVJ5uZCfMYzq7MLp1vC4lZ0znIn9aaUsy5ei1tTazi1OZoqOpKCPVmp6cv7aiYWz +E/NnhgvnYs5kvbFy3c0PqWrOsAe1ieNoiv78tdtn7187fGMVRlEuX73jkdXNUyESSPOp3IYWq/NK +JsRayFaWMzBiLThSzWzGUrPl9qHm1Ak0LFmoyWeNaD2bG/iDMs2Y5PPU5oSZnJfUgRaFpZnwBzVe +sJOZdqY8lS7NlDvbiEVWerrc2Ejn52yn0e+ub+/dVGitalZLM9ux+CCRnrdTC5nyVrW/p8TqkONG +e6s3c7w7s9edO6UlBqyc24frMis6lcr06UsPHr/0SGfmrJWciggYjSyyOfnUD+W43XwoqGl6BdKc +Ls3FCzOZ6hKn5sEqc6sXUU01Wi/W1iYWLoAV2xM78XRXMfKhsOnzayHK9Pp5X0BJZ2cm5053hqcH +i9en65vIwgzv2Ileq3c0lVsWlBZMuxKr8UpuMH14Yv44zcdxAZnskigXOSGtWl3JmgAHkvmKxMBJ +TtJsvD3YW9u9vdzYaXY2pxdO5iprKFw60T1//u5iecJPG9naRn1wcrhy49Lmran8qhzt8UrZdtoX +z99Trc5HuEy9vbW6ff3EzMly42C5sasY7WJxYX7xHC/kcvm5nb17Z1dvzJfW44npRA== + + + akaNdnCntfZG1KqiUrJSyJWX0oWF6YWzq4du1mPdYEBLWJWH3/Z0KjURZlOyXo/ZvZg9KFS2ZpYv +rx28GY69Xptb271etzvhiMVGTEFMM0yKppNcJM9zZG5z6+D15dY2xSJT22EuRbOpUDirGoOoM+3x +6QdGaGRtJzHvckfI2rawCecZdfpatGka9aOHby60l2nBjsgZTsoD1U5qzklOy0rO5xUlsZDIzsdS +M/kqGmeNE2uQYIq2ZTkfNSuqlilX5+O5aTM9zFTXe7MnM/mZYmH6xPGb13YuKNGcqGTL9eW55WsX +16/USdxYjCUmObmA8aw3NyDoegx6cXx994651UvHTt+/e/KeqFPrNGdPn7+z3luH3FDk0SGZWMsV +10pVZPZaiE6oWo3lE6GQqkfL7eGxld2rM8vnEK+On3t4aePGcnnh8O4Ns8vnDbutRGsYEByH4TNx +Z05TmyHyQNNQtLyd7MBRJ0qrEaUh6k0EdrSAbrUjYlo1av2p08Uq4WE9RlxEIKhHuKRptn2eiMtF +EZbIzTe6hzuTx4qw33KRl/L9qeOzyxfRCKJagA2odY8W65vkz6foxXAEY17MVRZ0qynrtX3z38oU +V7uTe/PLl/VoO8w4gpDNZIfoZfS7HmvBqyAsJ7JLmtZimZSslmJOX9QaotaKZ+Yn58+t7dy6vH1L +s38UWuALyHTYoMIay8VlrZosLFSamxgHx24lkl2PV8EP0T5g9ajVkeSKrFQ1rcHS1uLMznU3PcQK +zthYMBSQJD4Vh03KTEciab9PjRmV5//lu5sbJ7xejovYmQKOsJktbFUbR6rNXfLHIrxSLjcLH+Xx +ihhYBkYLfRetRJ1mMtXdPXypPrVCC1HJyKaKU/H8RDSBilRxg2zYLuTnk9lpaBkvZzHmNOvwYlZS +yjG7q5NBKxw/ebU1sRXPTShWQ9ALopKxE4064l6yw3FW3G50Jw62extOqssKCW9QA/0i3JUah3Kl +JXSKlZyo948tbl6CUWn01uPZHitas3Obpy/fYSZq4x5B1rrRxFw8vWA5PYxPiEnCslZbu9F4laZl +y650p4/Mrp3fPHLTwublibm9dH6qUJi4cuWOc1fu9QRUQa5E7SnTmc4Wlg29xbJJBkUU06KUQRWA +7WhqqDszseR8rXuyNXFWUCsBSosnG4XyvGGWcb/wpZpe17S6ptTYcMLrYoK+CM85ql6Op6aQ1OAu +aCYRs3rx1LQZ7wXpaKW1Wu4eTFeWlVgFoYmNJBLJXn9qD/HQ65N8PlnVG2jeYmW10z+aKyztfwRG +FqV8vbXl8QpatJzOT3en92KpoaTXqLAVoqLQQU7KMHw6nluYWro8v37d9OK11daOrLUpJoORwfVQ +tMqwMUUrZctLq0duHS5dzhbXtFgTB4+IKdWsambFMBvxxLBUWatUN004KCUfjVbcXt7tYqmAxNK6 +LGZDQYMsJvSrttm8dP6Oan7gcUUUKR/PzGjRlmG0FaUsiHmfT2OZZK26rqp1LVoPhOQwi57NZksk +8g/XdhvD5frU4uTS5vaJaw+fv7ywe9IpdTSnmi3OJhIT2eysopb8IYVho7KctOxqKtvPFCfsdNPJ +tqqd2ZvveHjz+KVqf142C6pdyVUGg4XtbHeB5mL4/WZjPpvv+wO8poN54HzMevtgd/ZcsrzGawXT +KVZ788nyIFnuqvESoyQUK5eq1odbW/W5NdHKiXqWTI/rJYqJudyhEK0B2KX62uT86Wi8KMkxw8om +Cl0lljGT5Xi+rccr2fJgYW1n/dipVK0fUZLxzDCVW9j/nII5Pk67xsM0Fa3WV4sVmBy0TwKNXO4c +TBSWkJIEvcJKWUHL5Gv9WLJE8UZYtDS72hkelZSq36+5x8NcOKbLWU0p8HySDptBOsbySSveS5aW +RKMO4RCk1Mlrb945eSVd6XspPsjGnMxMurAoKiWXi3W7Iz6/zPEpQcz5A+QvIQRDlhGDpM4Wquvp +3IJpt06dv3ro+IX6YFEycj5KhkNw8gM90aR5U41m6/1N3WqpsSYgDY0WlebU7KWl9ZuTmaE/KAFa +mlHKV+bNRCPqtE2na8c7TrrTHm63Zw5mSoNSba5c36i1dvLFZZ9HPnCNb3SUVtRyJj1Fh9Sx0YBr +nAkFTMvsdnu79cZBVWt6vYrHzfNCwrDro67wmDvs8nCq0a02j5fKBzWlEQqa8WTPssut1vDgzom9 +4xeuv3rXQ4+944n3vvfDz3zia9/6xiuv/OYv//Gfr/3bGy98/yf3vvWJ4eIers27vwZMFvMNeN3G +9ERvaTi7tbS8dfjYqSs3XH34sXfc//bHb3vo4Yu333nzPQ/c+7Z3vPktj33+2S9+5gtfOHLi2r0T +VzqDFTgBQUo7qU4i09dihUSi0uvPrW3sHD56/OL1V+54831ve+c73vWhD9728NtvvOfBBx596gOf ++NjzX/3yV779vS9+/Vvv/uAnDp24aCWqvBinw5okOLlMr1SesOPZUrW9sLy1c+zc+u6J6eW1lYOH +N46ePnnh+qee/qefvPjTX//2N8997Wu33fvWxZWj5cqQpmN00GLouCRky6X5Xu+gLGcDASUWLc4t +HZ5aONgcrFQ6883JlRPnb73jgbc99Ng7P/Pccw8+/uS9j7zjgcefSub7sFKgOyqox/SaGevYzoRp +tSQ5kyv2K43JTn96anZj4+CZC9ff9cQ/vvepp5/++re/84uXX/ni179x9e4HNrbP9vprUbPOsMkw +Y4OCNL0EN4sDhkIxQcgVy0uDmSPl5ly5OX3pptvf/eEPP/mB99//tkcefse77nvr2+9680OPvPMf +v/jNb7//ox9984MPX7x6j2HVw+EYTemqmo0nB/nCom11y5W5VKpdKg2nhlvHz1y3ur528coNN9x6 +5x333v/M5z7/+z/+6d9e/9MfX3/j5Vdfffp9H+p0Fl1uwe1W0HS53EqjsRvwx/w+KcLEzFhNUWts +JB2JxBU1p+mFWm14+vSVq3fef+nmu+576NEn3/Peay/esrB+YXLuhGk1yFrWN9FRNTM3uXL00Mnr +Llx31223vvtd73j+uWd/8dIvf/O73/7slz9/+eWX/+tvf/vt7//1i//ylff+84f2zt7QHR5jItkI +k8ojldvlSq42iwhx6vKNN9xyx113P/nkk1/48le+9PVvfvxzz77vox/+yje+8eKvfv3s81/69jdf ++Nvf/vbcV1549z9/8uJN95Rr863O+uzS0dZgJZlpNOq97c2NW26+/Ogjb/7AB9798U995Ovf/vor +r7327Rd/8sUXXvjOj3/6xht/+j//9//+6T9wJb//9o9+9MiTT88sH80WhiBMWbIKmepEb+bw4SN4 +nTx1+q57733P+9/76Wc/+cFPfey9H//Yp5979ocv/viXv/rFH/79d//zv//nld++9r5//vDV2+5v +thYto61J9Vx2odnZ5fgMz1qZeBXEffrU2fvuf+Cxdz752NPvefRdTz/35a/94Kcv/uhnL/7pr3/6 +83/8569+/dvf/u53z33xq6fO3lZvrkejnVRy1oi2sqX5TH5yerixs3P82vOXH37bQ+98+h8/8NGP +P/P88z/82c9/8etXXnz55V/95tU3/vz6//p//wfd+oOf/PIzn/1Ko7MaCOnQRIqKBskKybislOKJ +TrMxu3f87EOPvv2hJx794Kc++qOXfv6zl3/11e9+6/mvffmV11599Xe/+elLL/7xjT/+f//nf//2 +td98/JlP33zr3dX6tKbBbwvBoBSJWDGj2Ousri4fOX/u+je/5ZHH3vnOz3/puR//4uff+uH3vvKt +b/zuj3/463/916uvvfrKqy/97b//9tNf/eJtjz8xu3C41duJp4YURRY/ez2ioeRiej6X6fb7a/Ak +c/PrZy5ceegfHv3kpz/54ku/+M3vf//lb3795y//6n/9z/+88de/fvLZzz7+5BP33v9gJjNlGD1d +SixNrx7bOX7D+Uv33H7Tg2++/V1PPPi1L3/23//tt0D0K6/+8uc///5nP/fhu+++evjw4XprKluc +4fksy9ianIqpiYyTnmh2z5449ZYH3vL2R9/22OOPfviD7/vBD7//vR98/wtffv6FF77xxp///ONf +/OyZZz/z2c9/9vZ73nLw8IXh7I7j1Iu5QaszX29MVirdzdVDe4ePntnbfeudN//LFz77la88981v +feWVV3/1x7/89cVfvfziL3/x2mu//o///Mtr//7a177z1Ycff+vBIyfy5UnLqZt22TGz/fbk5vqh +K5dvvHjh4oWzZ95y313PPfeZl176ycu/+fX3X3zxa9/66i9e/sm//v7VV3/z0m9/g2b52eeee/au +ex4YDDckMSMJmVRyUCyvKHLRUDP5ZG2yPXHq2O5T//DIl7/w+Re+861Pf/4zP37xR6//6Y2//uff +XnrlJ6//8Xc/e+nHzzzz4U8/8/Fzl29OZnuwQyArJ9HNFqbyhcHS4ubG6ubF8xfe/fQ7P/bxD33q +mU989vOf/vFPf/gf//1f//r6H1/85Yvf+e6X33j997/9/WvPfekLTz35ruHMoQiXQnAL+lU6FIuw +iVi0NuhtdFqzZ06efuofn/zIpz7yic8986Of/eT1v7zx+l//8sOf/ejlV196/Y1//7c//O7Fn//g +179+8acvfvfpd7/zzrvvqdamYmaBDkuAViLZzKRbxVxvd/vY2x95+xe/9KUfvfjjb3/vm6/966uv +//n1V1/7zS9//fJf/vonHOd73//aD3/8wk9/9v2nn37XlZvvPnzm1pjTdrvFMGWHKUOIRKmAoAj2 +/Oz6Ddff+La3P/KZz3/2s8+jmp/64Y++85///Z+/+8Pvf4S2++kPUaiPf/pDt912y7Ejp7O5Ybd3 +NG2Vhr3Zie5kp9ZYXpnf2d1eX1s4cWz9gfuuPPbYnffde+XWm893O5VUwlRlLRJR+Ugs6JeCfpEK +ijJnFpxSt9Sd7c8szs6cOn705InDBzfnr79y9OEHr3/87bfffdct99x3z3VXb1paW8/mqpbdyBbg +vTsMrUfCusRHFUGHcbl49sbjx880ypXpZvXs0Y3bb772kYfueOqpB7751c/9HHTz8s9e/e3PP/rJ +9950y6Xl9ZV0ppRMNRVEV87ieduKZs+fuf7GG++aHC73elNrc7N7Wys3XTr+0Q/8w7de+MLLr7z0 +2r++8q3vfOFLz3/88595/4f+6aF3PnLbtSePT0+vpHM9mjYkKc1EHK8fuUYIBOQwpcT1eKdUOLO7 +/fj9t3/hmY8+/6XPPPfse3/yw3/5059+/6lPvueeq2fPH9+amxp2OgNRNEJBQVXSePFCHC9Fjuty +rJAuT3Wnj24cvOu6c0+/88GP/PMT//L8R1966Qf/9off/Pkvf/jZT778ofc9eucdFyYHbYHXeS4h +S/lgAJaGLFH2ujkp4hSSrVKytra4cmh78/Ll87ffetN9d9360P13PPvJ933zG89/7g== + + + mY98+qPv+dgHnvj8pz/4xFvvvu70yUa1r6iJMKuzbEwUkpqer9XmU8m6xBmlTOXUkRNvuf/NH/3g ++//pXe94yz13v+9d7/z+d1944ZvPv+PBm9//6H3ve+LBW268cPLIzsJwvl6fnVk4lclOezyCz6sI +fI4Jx6iAyDNao9g5ffjoW+6+7XPPfvy55z/zvn964uknH/70R9/7/e9+72Mf/OBb77pz79Dhfndg +qHGBd+iwHQqoIX+EDSs8q8lCNJlsVCrDmen1jc0jatSKcPCWepjRaVrjIpYkpUIhZWzUF/ByPGNL +QoJjYgrvqOQV01WrkG1kUhWOESIMx7Girpqa5kSdOh2J+wIiFdIE8jmFZIASXW6kWl7kzEhYEyIx +O46QkjWMeMKMKxxvKmq9kO80ayuL82evvbBzeLdUKqGOgaDgC/AIHbDKFBULBLVgSDXNcjrd1vWs +KNpRPZlP5hBH88lUvVSolsrtTn9pZSObzlZy+fnJyYlGPW3YAqMjNQtCStOKmcKsoldGRoNwOwm7 +Yxu1jFWcanS7pWo1lSwnU3sHdxYmm71afnF6slxsG3rc0DOKUuEiyYBP8ns5n4fxummPm/37X7LS +1LITa/YaS7V8p1tqPnDX7ZfPnBhUi0sT/clme2N2uDnTb5XbHCONj3nd47TfK4yPBsfHKJ9XAHdF +GEcVs3GrnkPMKtQrpaZpJLgwZ+nxcqadtkutSndxuLoyvRKPxqrZctrMK7wZCqour+TyylQ4blkd +x2lrWjbCGhyDzs3lcwM0tRmtTU4d29q9urx6wbEKPB3OWk4tW07GUiIHwhSBItPuTM1dSKTmfD7l +mv/HDSMqCjmaMhQ+bkhOPp6v5SrlbKFebMG+G5wUE41ErJK0m5lkJ5uZoih0ip3NT5tOf+SaAKDi +djPBgBQJG7JcjEbrndby6Qv30BGbouEtK7rRjMbayJWSlA8zDkaAj5C5srGxAF4uN+P1CDxrq3Ih +mRiYZiuqlRW1QP6QVFD2BwWWT7GRHMZcVyoCl/L6IhSt0EwMxkbibSashUKqpJY0q2El2o7TYBiZ +ZWRFsgQ+pihJ065FhDiyvygV0Uoj5MN9YXhdlk0IQlqUkoqaCVFaMKgyjOn3CxQlh0KSJCSRkS2z +qaol3ajxfCJhF2NmZtzld43RLO2oShGyrmjNZHZFkmsejwgPzDJRryfidYUpHxv0hoNemgurKacR +09OyYMpCiqJspG+fX/37R8uDgZjAZxna9HuEEPmkUswfNGk2HaRsaJwsZ1rNudMnL9VK7YAnGBMd +U87F5IyC2wFHjVEeNydyOY87cuAat9vFiHw6ENDwQsuH2TiuRwfyc7Mcl8BVJZK9WmMzmZzIJtoK +F2dpnaXU5dmjupIB3eFQvNyQjL4eG9hOX5DyFGOH0dH7f/zWSUwnssvlxtF65/Bw8XIyt+jzQeNi +7docx9ojB3xe8hct7GR8amn50tTMOUmujo2GvS6mVV0U+PToWBjVDAZ1PpJy7H61tlEsLIf8qnuM +ElmIZizgVxjaZpkULxSRmnG6ZHp+fDzictNuD+Xx0l5PmEVulUs6mbheluVSuQAvtGLE6ppe57gM +L+Rlsqw9EeFzNJsYGfGNjQVxUr9PlfisoVYNow74dZpbvYlj4y7W5aJRdEWv2olZ05nEYSOsE9Oy +U5ObWrTqdrMeD+PzRf5/kt67S64ruw/9BCI6VQ435xzqhrp1K+ccuro65250QKORMwGQBAGQBMOQ +Q1EkZ0YTpLFG0jjItvxkW5at5Sf7Dy2/5/XeP+/bvH171qqFhW6gqk7Y+xfuOWcfDNML5X3bX9cy +fUEoFItdJ1tHUAneG48DYNoonlO0YbVxScBEhAk0DUZ6BB8VT3DRGAVRhxG2ojVVpRMNCqOxAGUk +aQFCEoQNI5ZKqQydt+wBK+ZDYRRBTMMYmpk+y5UQPMvwjXhSD0cYCL9Egp0LTi4kYmEsGsYSMYqh +HEg3As8ASCaT2rWrch/ptIGi2XQ6qDnAsiUMd+MxkAoWittBJb0wF47JMFauNylUZgRlQU8jIYwj +XYjAhbnEQnBWnQbzjiIZz17DEDccJuEVjdKLC+lojIMRDjYY0HnbXXNy22nEFATPcvuMUITYTkS4 +pWB/O07jdq95LPK58BLKsx4vtVKInUiZyaBaVNV0VrXMGMVsmnbApHTHd/zyHkWXaLacSOqhEG6q +1dnKPRJ35ueSNJvnuLIiVi2jReA2qPf5a/FUjN7dvMMwfjjCMWwBp3IMVzHM5XLtuqL0omEuFmEJ +3ITUCC0hGKJwbEFS+5I6NKwVSW4FJShxQ9V8QcuHIngsLgZVQJW2Zg+y/upgelmqb/JSQdIaglQ3 +nbHhTFmxkca9xNX5Vkj2NHJ1xn+BYCifonyccFSloWf6i0t4EAa4RnG+4S4zcj2eVuHHot85PH6g +mJ0wjCGqkxSEugOeCKYmlZKAH2/ffLx9cAmhhQOsMUWer3NcTVa6qj6GaJcE37HbKCotLqZhLgjC +ZPmCrPezhW3TWqOpfLm0brt96EtAwWmZJB0AFlluQiZimMVTTre1ywklmMFwiIyEeQTNphA3lbbc +3AxE1/xCChwKC9QfZ1NJDsf0CEx6UCLS5rgKgEAqDa0qkISPoPZSGI8lRJwuZ5xpubYlKrVEUg3q +m6FuGrVB3nN8AbIjFGYlscmzpbn3ogtzoD8s01yR5S6KOEHt5RALbkISC9AeDNETSTl5tREFQTNB +SRMSRsbb3L7fGx8QtAMtF/gaxxQ5psQyJQSx4F3AqhgiJ5MAm8FmbJTIFyrX909/0h7eSqEWDIKk +VEgqKJiGY4XggJXVd+yOrrZVpc3QuWQi2IMaCwI7sbSIhpeIxYWAiZC0YlkdgsxCrEpyNQbyIwEU +owRHz+bgf5IYZuOY/d4fhaABNGHQlBuOSKGIshSW5haI+UUKZOTN8xfbJ8+WYkw0KXNyT89u+Y2T +SvfMLqxLamN1fP3RB18TfC6WlmIpBcF9gipJ8jDj7sZSJmAChphXhsLg+bLAl2kaBsQn6DwgCc1Z +vOIzUpnkC7zaVK0OzRc4uW64M798pOg9gG5RLuJ0cBDMAKljNinWwSgLmJdhAoxaWEwtLCLxhAjh +JwhlTWlwHLAtDZwCEA08DtieQm2MKrNCT1J7qtbRjB500/N6aUSKRkn4KMAQmimyXNm1exfnLyS5 +tBTCIxGSwLMsWxWEpiC2aK4EQwe298H916XKNAjdCImlVdBUstKGNETSOoCqZnYYzlsMoaEwEYuz +aVSjuaJhD3HKEaTyzvFT3elfm09du5ZMJTWS8mg6n7EGfn41lVQjSzhLWrxYnF/Arl44vDAsZ1nj +nLcsK1VVa6ZRPRSh40kxhWg0U4KvbvVvbBy9FGSIMW28fNrun+G4E4nyoRATjfAoonGMA4y5tIgw +rF8o7/rlXYIuBMevkIxk9uuDW8tbj1WjDWDF8k0Yc16sJJNCOiXGo9zVQT8L+H0JVF+MCw6YpFSS +cHDUTCXkSFB3QkAw+/DopanXrl2LhUIUoKipjxmqQlOldBroEksmJPjAhflYPEaDVoGkSKOWZPRB +opRKKxmvGwZ/RFgEV6Clql3c5NQmxRdMq3d2+uGTNz8QnEcyWd0aZL2NnLdRLO7o7spihBVYf3N2 +R9Pb8/MAIxxEMk0VbWe6tv2iPTjP5/v3H70V9CanVPO1zUr3eq1/2hzdbEzuqvYyzeeLucGf/uJ3 +a/t3ISUxTEMxAyNcQWrl8ruKNkgG1eAtAA0sKJ5TppgqQVdZrmnZK1Z2mkLUUAghgx1BwekMlHAp +ugAvQaipWqvePFDVWtbtOt4yTrqy2jbcqWz2Ca6UwqwUkoHWgmq6OoSbEaSG660IXAmEouU0cNIg +cINjPYirRFzCCZdh8yCfKNZnxYqo1oGCIYtjMRbUezRC81xREMsZd9zfeEyKlVA0qJIBIEmQFmgz +CL8UYgDj8KA2SUht6tpcemERh/BA0hbLNhWlD/pE0Xqy2uHEKsnmebkG4hYJCk95olxXzG4qKStC +7s3rbzW9AqARChEoagId81yBYbKgtZJJSRLLolhkWQ8aU6hslDuHanbslDZEtUmzvu0MKcoLLZHR +iIChLk2XZWmgKpN02o1EJZrM5nJTUD6gpaFfS4vY4gIGzWOYup2dlSq7YDGiYFuC02QyjtrBobCY +imCuone9whpoWk0pZaxCLI7FEnQiKQUFZIhg4RVoK4lqot6kpRJCOU5xQ8+u5Ipb45UH4/Wnheae +JJVKpVm2uMJykIkWQZmA20tRBj6z3ztR9KBODoE7XDB6eU1rNrvHudJqrbb++PlXglEXzVprcjZY +uzfcuFcfnpU7J5zc4MT8bHL49//pnx5++GUaUynSUpSmqvULpaNa80KUu6bZD5KU9IKDwFRF0iZm +drtQu9mfvp8t7aLgN0nTcfo4mY2n1Bg4UCan6G3QbJxYy2Sn3e7+209+3Dx4P5kG79N0i5tWfku2 +ppnsZtbfA2WSRg1Oql1V0ckGZxzSdjIWlA5AEaNUmGlaA2I7GhU4JmdlOoJcl/Webo/ag7NK64ig +s6k0oCIdi7Kg6/RMN1/fqw5vcVpXMnq6tQz6LR5ngrVCdwRv9PKbheI2hMpCUM6dgG8BBIjHwao0 +JLktyi1eCgraCGpHyYxFvQeJHLsqhk8xReiRkelk3f766ilFGRDPAFaqAlKhDAEWCpOLi4gi12Sp +BN8Yi5ICly2Wp7nyCqfULG8mKG1BrNvOmBfKQSWroGpuESe8q2oAVjwoIlcwtE6lvAm8gCI6jmcS +wONLJMeWaabMCVWAfcA0oJU0or33XngxqLQD4qosyw3NaEPfgXBz3hh8+eJiLBYDptBgUpKA+ZQP +Ximb3+ou37dzK9nSmmIP9OzEyE1z1W3NnoC6WOsd/fTL36zu3wd9DuYFB5OCZVS9k3HGpjWOJfh0 +gqdpP5nSwmEWQRUQ6l5xrdw8LDb2WCFrWrXeylmw2VivB2cN/Fm1dThavtzYeXzz/heimsdIxXGG +Qd1UtQOtwiFsGM/1Z359J4kaoTDt+TvD1aejzce52h4nNTG6kMYBi5q15p5m9VipwssVSQX52jez +Q+DxjD/0q8uD6ZFfW6Npczg+2Tj6qDt7JOpD2RjBK57SZ8tnn3zx62pjLRLjQH+SVJuiWsXiYa15 +O1/aC1ScXDXtHsiYCAjRBO8WNrb2nj9++WN7dJNkctevP97avgc5LivlWu+wNb3VXrm3fvDq6PK7 +Ru8uqFCOz6pmgxZ8UHHAmzRfjweFL7R4QgiOh4cpFAXqd9JIcISTYMtSZpzvnDuVI4KtELRlWh1Z +bwGO8VJV0ZuGO6x2Di1vDBoGsAWsWSwmpIMdDgKGGSiWCUfoWAzcsRmPEmnw1KwHLO/4a15ph5Pb +rNg07FlnfK/SOIsn1MVFjCDzgtSm2YqitslAKuc5AUKlA0jIcflYNFjNDCr2oGDuKg== + + + othw3AkY2PfeC0XDZCREhJdwgDJwFqIETrwiiA2WySfjwNFqPMBzEmQeJ1ZkrV1u7pcaBxvr9z/7 +4s+z+YmgVOv9G34FJm48Wbm3svaw2j2No3o4THF8kQPeJLOq0uKEShBOEQjparW5TXM+9FdRqpns +2C2sFVuHVm7VNNvrqxdvv/5tGtNhiEqNo2aQ+AfN4XljcO6VtnDS0nWgpHEsDtaeoxkfAixf3t+/ ++GS89Qijsok4z3C5NG7FknI4xgLIKOao3Lqxf/qpl1/J+tNya4fis+EYSTKu4092Tt9/8/Wvnr35 +cbrzUDLqlXz35u1XpjcMxXiSKxTr26XmnmxOyo3D2eaFaTdS6Uy1fdP1t1m+rulDxeinMRMIt9U5 +6I/PoFVgwEGi61bfsAeS3oynNQQzV7bu1Lq7CKW7/mi6fW/9+tPRxs325IZf3ZGMpij6f/Uv//7l +669J1gJx6Pq7reVH9dFdPbMSjUkwR9Px8fnNN9fmwLTaqjUtDy6Ge88n+x94jeM0lbOdzr/467+7 +uHwZiXLgap3cWnf64Oaj78arT4PCcYtJVfJ5vrgUpiIxHiJWkHuyPgZ3BjYhneRZxuH4PIpbkMXN +8a3BxuO9yy+P7v50svFElBrz8/h05ZaTncaDUqsUfAWMANDEZPN5obKfDqp/qKBXZQm8jwnOAvRY +PO2CoMWpoAo3qPcF0D8hiiZcHMuwTAFkNoHngCsxFPS8A+DJMBmYygQEJ6pTXBY8Tq600RoeU7wn +ac3W+Fa1d5GrHIxW7mcLW0E53BhPk6amVzECRl5PBgU8tWhURhAvA5ZTbQJgqlLV9Xo4paOEdrUN +rNLoncz23l87/kASi9PpWXt4THAuqC+/uu0U1gW12+ieDlbuZguroFIkuVmq7nr51VxhzSnMRL2P +kb4kQeYWFpaw+SUcxaxydbdYOyw0rmeLWwyXB7CqdfZUq40Slmp0gYB6o6O7jz999tG3e6fv82p5 +PNz79ItflGpBZe965/zu0+/f/cnfbJx/qWU3SC4PUyNwlWr9IBbUeaOJoE6gm0zrFJO3srOgPkBQ +kVsiCC+VVjEyS3Il3RllC5uVzlEmOxhO9u8+eptxBgyfI2iDkSq0XJOMRqN3cOfZN+XGevB4hHQG +s8dAo4Yzjif1eFLGcbNaWl2e3gRaJEmPVxqCWueVlpldN/3VUnt3tvvwgy9+Pd2+vxhiCdq3c2u6 +NWGFCniopSUeIMXQmqpavTaXiKcU3VnLlU4MZ810VkEOgdfm+AAqCco5u/vmxbufn9z7ZO3gpVvc +BqhfCoP3Ed58/rtaax+kJkH4ljvFiTwvNMr1ffC2kEcoItfra5pSBtt4DTxgmOOUvlc7zddPi7Xr +NFXBUMc0hwTmLs4nQ0v0VRFUFrwkiKJkMjgBNF07AzULbQs6S9kQGxl/S3ODjcEQWpo7YIItahU1 +M5UMwLEOQ3kSn+PYLIQQDRBKljm2DS+CrBJUGWA2kZC6rYNyYy2oqhchwQvLWq81vBis3a/1912r +/sHLb3ePHiOkUaht75293Tx63RnfXdt5vrr/QnfH4SibsUdgdQkgXEKHIWX4lmZMIR5ko7UIIBzc +fePZ7oiTqhRf4uUmxVUUIzgdySs1Qam7uRVBKqlKcbB8Mt64O9y40xjs7x0/W999aNp9NzfpL18O +pheTjZtWYTVN5oOyzyk1505q9f1QhF0K0ZLSNt1Vw1oGvSSrfQDkdEpj2TwWlKCkBbmZK21Pd551 +l+8Vqtum2bi89ez7X/8eeBPGkKRcLTNtDy9vP/r6xWe/mew8gdBNIrJfXrbzMwS3ri4bYiJxiSA9 +MCY4kU2nFUmp4UFdYiaFWJI2LNT2bz569+WP/+r55/8i3zqOJjVRqcNQILgNMwUsRlNlVe3LSh8M +zsIiCtDk+NtcUBleBxMEcwdkbYBoZzxAgNXNy+naebG6ni1uC9qYldu80gEqWd76gGTLsbhqeeua +1Q+qK8SkNGIF9e0XSZywGq0DHNPnr4Xm3gunYASCQ9Abkj7AqdzCkpBEXHBV4VDwBCwRV5NJI5ky +wEORZC4oo03nKp1DnvaqlVWayUbjHHQhXz+x8nu6Myu0TiCPgG214DnVkBFq0DvQ/ACVyYScTChI +SgfbAsOeTqqgSyHUr8oSyo4zSgblqlCYiGhCgpYISkMLrszo5vzBYHxqOwNJKq/vPt48ft5buZHJ +9XnJpzgPI10UzZhml6GcVFIEZahn1iuN293R4/W910RQ/FkQ+KKdHYM0SqQksOcYWIbM1HJnoH4l +tT5ZORuOrnOsQxN6vbl1cOPjO8+/vf/8m7ff/K43vaWqnY+efPH1t79WjBpOOThTEMAyVI8mq4+3 +9z8iqcrcArYIGMKULG/VhEQmfcjuWIQHsQ1eLB3ceaQZ9jjjTgxQd3yJZvKqUqu3dtZOnnNKM53O +tNpnw/GjSm1/a+/xzvXnotZMphTban71w19kcitLSxyCupIKmnzGia0UYoLUB/pwc1NwcPGkICtN +v7RdrO9NN+8++vCbo5uvRKPrOOMnT9+B70ujZsaZFMrbldpBqXokKaPgPqw4x3M5EFrAa4tLoJ/t +cvOoN7tVah6AQiMpK1+YJFNSPClCaEESnD74Zu34dX/9ESs15uYJmsg9fP87TikDI0DAp1APxYt6 +ZrXWullv31oMnnElUkmW5XKLS/jV5W4qAm5daFnelqwN4RvjUYogdLDJ8ZiIkzlWAD872Dl58fjN +z9PQI7GE4zaOB7vXTHdsejOntO9WjmixytC5ZmNXkMB6GzLgvFxXtbaiAFKVkbQO3n9hIb64mF5Y +SIeDaufsVckyFUllGMqnSTuV5BWlbjiDfHUjX99uT246+VXwwrn8iut3GSHDiRYnuIpSkdVaxhp6 +3joKsjYlC2yWpOxEkgeBKokVlgtK/GGYK/I1cNbgiSDZEVQH8ATCikRFoGZJbpUq2xmnT1EZls7Y +2UbGq+dbs+HmzdW9R63uYaOxe3L6otHdYgXfy89q3XPFGufKO5X2meluYVgRx3O63paVKoirBHjD +mHglHmyeLYO/4PkmRWZBXS+GknMLMRTVHXeay+82u5f7Nz8DDZYxm2cXH7nFNYCvZEpGrw538HzV +y620hydLET4cYmWxDagYS4gLSyi8EilZUhp2dkpCqGMKpB7H+amUAkIuTZhosAu0Nl6+s7X3CDyX +qtWGy5e8UEHSWjwqRK+Ke8djHM/nkkmeYhwEszm+5ngzDRqTnYhaWzI649mlrNZFqTBaPumv3IDf +kHw1TdgIntGMXjYPjvskKDQEBtAaZfO7bm63WD/UzFEsnoHYi8eEyfBga/NGUCYuTKXRjGz2i+3r +nckdw15eWCRcu1erLYdD6PxcAtAAhIHnTzWjAYmQiAkIYsFLVuqS1uDFIviycvu02DgZrT0rt06t +3DJK6pbdHU5uGVafoHLJlA2mNRlclsdFo0wkQocj1B/uZfhDNTyGKpGYxxKeb3d29+4xoi+q5dHm +nfsf/OzBx3862Xtu+uucWHTM6uHOzb29p7rZTaNqMq3gwWpjliJtz+1RpJlKsRmjamhVMCwUXcSI +UjyRuQpgOhGs2bFLS4CNFKAouBtFHchyD3wERmYkudhfPtjcuzi88ezk7uvTW68uH362efC00j+l +eL/T3rpx/kJSCgimKHpDN0e82NPNFZIsIkgGuBjMNYaYOOaSZIHEcwhILFSHQZaEiqK3BMk3zBpB +ZWg2x/Blmi/LZtdy+/3B4aOnX2qZtqrVwVkIUk3PdPz8ZiYz4YUaiOGcN+i09uJBHWwkFpdRzFW1 +nqS0JLnB0J7jdAF14V9BR4ElL1YPxmsPptsPz269g79D7k8mx9fPX/6huByBZ6hgKw6Po5oo5mky +0+puK1oVQAwCD9JNzfTzzcPhzvPrNz/PF2Ynxw/+2//4354/i8Z0XuyDp2h0rr9884tnH/9Ss1fm +F0jIGkVpwrdAWoWCGoNCPG4Z5oqdXTPMLo4ZIJxSSSmVkuNJKZaSQzElHFzkYVrOWNFriRQPJjoe +Z6NRKhrsPZPIYDsH8H6e4WuKCc6oC4ar1jnI1dbz9Z3G6CJb2VXdCSjk8eTm6cXnGXcYC0pwB8VP +RL5KUT6KZIAQgSWDyuTB5Wh80Pe0haYMGrc8tzWZHTm5QW94sHfxstbfrfUP/Ma+aI4prpS1O+fX +nx0evyGvLtFIpSWWLcpKhxcrmtZiuYKmVuv1dYZxwGujgB5CV5T6nFCPXxV/DmYhxkGOA61crYar +KObwUlExGzC//cHBb3/3H/72H/55Y/8+/AZg069sTdbudgYnq9PLvZ27llWzMk0z09WNrmmNGbYe +j+mLC8EVS6ElHEIrmZAiwRoWuriQioTJWISmSde2R9OVy72jJ7GkAKoGDy7mc1WrW24cVVsnpj2k +GXc6PW1395GgSr9M06BIgyUwMOa1yqzV2AgtYuElkqZy4O8I3IpEuGQScsoUxbKTHUJgBI8H2ZJm +tPzymukOZbUpKR2A7unyydr6ZSwmQjN4zgcmTSdlAtM5Jkvghp8fieCRlxASB82TlbWm4Y4sABC9 +RVOZWrn//PlnAI+i3K83bzXal46zXCqt+YUVhq+CCNflWrO2AWm1sJi+urOgpKire4df7p6808xh +KMSAZQBmR1LitbnYXHCJhpxIOgxTA8NF8TmcttKIMj+f+AO4CXK10NgD0wdeO18/8kp7vNQoVTfd +wghlDTM3aC9fTNYfnN/54tmrP/3o3W8vH34jKhVJLoPMwHFwnXYkyiwuIuEQnk4BogocX0oGdXJE +oBIkJbNUhqJN1SqPpscPn3+xdnAHhR+BHOuH7eFdQF3T6mVzE9XsJxGdFUs0l8PwDEA6LzYVtdcd +3Bwug1WfRGMyBcwiAKp3WK6eRuxowowmzasL/jSa8SBVUykR8gVB5aw/PDh5enLzg/bw4OD6w8uH +H2e8tigXsoUVyxsdnj5bXrtDMTmc0DKZ8vHxo2p1Bd4FDhpB7OBZIp4X+DKOZjBED4eISFAoLyj2 +CH2MhAmQBDl/VixvFkprqlY+O/9otHxB8p5s99rT+6ONZ8XGoeWM9g6fdvuHAFMwIPniRj6/oSpN +IMd4gg+FsGvvxVJxkcQDTF5YjIdCJIZmcDwDeikerJgoLJ1PBF4Vwwjg0zLohEb7yLaD1StoD8f4 +GaMZ1HBbRAFOkZRCkw5DBWvc0QiRjNMc7SYSAOxUKEKDnNDkoip5mloUxWIuv/zxp7+4eectgmZo +uqgoHeD0SuMQFCxDaiLvXFV+phkmHzwOFVuy2HSzoMOL8SirKb7ntEHhvHcthmABzYHyCQc3YVHR +GJtCVOCd0BIai9EgVADlwNEgqMkHbqtAc3lBaULq1bvHltu4vP9q9/r73f716dqtnZP3Z3uPC/Vd +Ua5Ua2um3bzamWPCCCwuBDuOGDKoDGZZYFtqvcE5TmXDYRxFFF4sVdp7Fw/fPXz1ww== + + + ZPXW69ffvf3qN9nijOaKLF9luLKi97zCdnfyZLr32i1tSnJpMLxR75/YuYluDUBIx+JBfeNMZgbu +Y24hNTefWgwzrNSTzBWab1yV6dNEoVpp7HNCDvRkqbJy9/6rn//6rx88f1fu7tuFNUltnVy8Obzx +ke60CCbjeNPp2u1298B1B9XqVNMKMB3gfDm+DHomngjuGA1uz0GsoHoDBcYwszAfoFYqIeha07Kn +vNimmbLndY+uPyiWx5zkeeXZ5snL03ufLe88aU8faM5yKq3XS+tPP/gpxTuRGJUONieDzQ8K6MUj +IoFYhlzb3rg8Pf9gfj41PxeDzwcStHNrMCA0UwDs6rR3rp+9BC+MEw4nQDrneT5PE5ZtA6rnAcYl +Lqtq1WSCTySCnTPRMA3fgiIajuqhpSSBK5KUBzcEkdZore+fPto+fJyv7fVGNwCpJLmyd/0Fz1eS +SS2o/x8TEzEZw7OKMeCFEuRUOIQBEkLcYojG0lmGBP1Dw5eGl3CQwZKYn7sWnbsWvvZeeGE+DlEN +HG0oVZF1e92dAhiHOGPqVQQzRKWm2kM3D0r7cLT2uD+5sb928t/++/91+eA1eEY90ys1tnOlDei4 +ld1gpQqCaRLvHx2+T1DZpcVEJJxMJqhEnAMkBFUJalbVSopWoeicpDTt/HJ/+fp042a7s/XpJz/5 ++N13bmHIyfVi9bhQOuiN7hxefLG5/3J165GdXS76y7fvvtLsYpoEa+nhZBl4yrSmqjFBMCeeVMCU +gUOJJPRIcBEYDRYJfFausOv6m2DW7tz6aGX1TLeabmGl2jntTx9sHb669eDr5+9+25tdDsZHD9// +LFvadLyRafUFsQK+GFQx4KFpjBFMj8WDjMNwV9eWLWsVDD5BePFYUJNZEmrRKIAMBiITx4tB/Uws +EywPKXXbG4pamZfyMFYY6evWcO/o+drGbYiNTm+DFbOKVnSdXiqYRCOdtpMJHUlaHOX32wfT5RsL +Vw+RSNIAPUAyeUHrCFobUm+2erGxeUtRa7IMRNmxnK6mNwQhb9pBZSSWyXUa6zCP8Tgdi1IQUQwJ +ieCiaS0WZgDTPLddKgbncWTem66f3Xr05taTr9zSLiu2cLJwfPz0P//X/9mozEBAxmO8wJc0padp +Y0UbpBEdZIZpNFY273u5YSLOQDjFQnQqzhOoRmGGpVc4zgFgl4RqJBxU2V1YADchkZiVjqsEagP1 +5/3ld1/9IpkSGM4T1KrmDLOVzXL7sNrcPNi5+fNf/avp2jkQ/WByE2jRL29BaAkqkBdICClntf/4 +u3+tud1r15YWF6JLi+kI9CguArPIgr/S33z8/qem28FAFWgNyahlC+NSY220ftoa73Nywa+sNgfn +mjlwvZnrr4lqPWP3Va3jZVe6g0PdLhVqA80apBALSIFk3HhKB+fL8zVNH4LDpdhSJKHOL+IgulDS +M51lQa4rcvX89MV0dmo6nVx5ozO5Nd1+cnj+8YNnX60fPfar69u7d/76b/8xk1sGdQRQpugdrzCz +3HVNXzEyU5J2DbPVH91Q9VbwlCZp/qEiKLxYtipK7XCwnM0uhTCIsTRiQDNkvV+o7g9X7hk2zEt5 +bfWi2T4QpMry7Gx186YCLgkzaNYHB6SpjXhMBjUIH4sgDpq20YQCLA9wEVpiLKtnmPU4sFhU0O3J +8s6z+uDc8pZxOocRzmB07OX7FOMxXMnzVyuNvWxuTVOBH7MQUcmEwHPZVFJIBgttWQw1Y8F2CIO/ +OrkGXKlrdfhwr7i8ff3F9Vtvz259cnnv3eX9T9dmewILttTmuUKwtxMJ7mximFKwW4Pxs+640dzP +Ot1kjCVRgyHcVIyn8QxDWEiSj4ZJnqt53hYKlMfbwQVS83g6oSbioE/KIFxVteXnBhRtcXyOZh1F +q+VrG+v7jy7uv7m4/2795AXFB5C7vvtEsXoMZIpQpdkSL9YkqQz6fG3jDJzj3LVIMsphaSuVgG6K +6ZSEo1KnPri490Iwighp+7XdjDeGTx5s3qmMbohGW9MqTx+/Pb14AcqKJAE3Grn85ub2o4PD9/PF +TdXoDDurf/bnvx+t3r72XjwaY9KAJEQu568ORres7CqKmecXr7KFyfwSGolxKLAMHdSs0zK9fHmt +3d46OXmwffgQozOqBUM6cXJ9zW50hod3H3/+9M0vBA1If6/eP2WlBk5mKbaA4Nk0FqxrV+p71eYe +imuLSzjPl7Ju4BlJPJ9OO0shIRTmUExfDKeTaZ6iXSe3lm8cNQYXzeEFuOZaafbjz37/8MU3qbRm +Zft+dc0trVneFHAbJywU1Qy9M5neE6VWOMwFz6uDZ4PSwgJGkQXbXl5fPf/k3Y+i3AQlaToj1Rph +dBl0ZrV9enzrc8cf7ezefv3pz8YrF6m0GWyPxLyg8D6VY9lgvQ9DZJ5xQUgnU0GJ7KUQG0/qKJGz +vc1277xQnKyt37h++/W9D76998FPLx596uSnaTwjKZV2/3i8dhsCwLRa4HYZtkjRAVDHo1IyriRj +AsBUs7Jlmd2596KhJQxJy+lgvVhKp0EZ6qJYO7t8lUobf/RHiVCIBZ2smxPHW4P5mptDU2kZJ02C +NjnR191Oe/nG9vmr8dYzxZkpdtevbrbG5zSbd91pobLnV3aKtUPTm5BcNhIPCqKmEgqaUuNRDlBx +YRGBSCBIC6ecFGYkENlw2qbfZWSv0FjfOH7RHJ42+8fDlcvuCMxUA/QzERxgacjgvtk8y+VFuaTq +1cl4/+WHX7q50cJ8kmE8yxmqehsnvauqfXma80vVdUEtA4DE4iAggZg8zWxD9IIIbNUn5+f3puvX +Ccqsd4/2zt9ePvzpjTufbew/mG3fzZVnRX/029//3Rc/+5fB5WJUrj+5tX/9k1bnbqtzx87OEMyM +RMliYahqNZij+YWgyHMkqqcQj+bqxfLGh2+++eSrn4NpjSXlFJ4h2IKa6fXHp8PJ3c7kIS3VIerK +7V3AaorzWb5Cs0WMAOx1JmsPdXsQTYgk7YEfv1JxFsQwACBIVpZ1qo1VkFWplK5mus3B6Xj1/snN +V9uHT0FzGnrp7cdf/d0//J/j6UEsrohiC1BUlrsk5cO0JlOqItdYNhcBl40oytVYSVqnNbo8uvV5 +vbV3enT3L//q3x6ePN6/8cHJwy8n+y/HO88OLt+d3f744s6r1uC40939r//0v7/72V/SlJ3RW4Yx +AAQTuWLWGVl6D0Ps+XkSHCsIoaXFwC/PvRdbnEcDI0kUDXuqmf16Y9fItEW1oTtjxRrq7tTyN1KI +ppr1cmNjPLswnE5jcH1l78nujVe7F2/XTz6ujS7N3KyYX3v6+CeX9z4V1LqotBv9s0r7RLO3ZXUV +Rb1olAMblUhAvgjhq21sKMwa64PjKzW2is31znDn/N7rG/ffPP7wJwc3XjRHZ6LRo9g8CBVZaRBE +JpUSUMyWle5w+c5s40mxuisoINEVHHgHN8FYQTKygJbayM7uFStHWqYLM5tISSyfS6akRJIXpILp +DMr1zVZvF/603L4geK3+4Wh2OZyeFSpb1fZBrbOfcXoFf3DvwYcHZ/dJ2s6XNuq9/Xx1NZOdSFov +mTYgNShcf3D/41ZrG/grFlNRNI/jZZwoI1i2Wtt49fqnaxs3IhGaFytuaavYOp5uPfngk19++cPf +7N14R3PVcX/34eM3ilaCGKs1j1e2Ptw6/LQzeurkZhhhErj54v0vuv2TYA9zlAc3TVB5cOjFxkF3 +ehesymR0uLF5AXjOckVJbytmr97c3dh/2lu+VSjNADbr9TXT6oSD23upaFRghbphLTvuDEEy8big +Zzrt0Q1Fb4Ea56WSqFUJyrKsdquzo5u11Z0H919+15/dqrR2VLMJLRT4fNYbPnj25c/+7N/tHz8D +Y2XZM1FsIGkdTQuxMBleCgrah5YE11uFiXjvvcjSIh6NcMkYWAaXl9rQfhx37EwP6JjmCt2VW+eP +v3nw6k9XD16C9eiOTk8v37588/OtnXsffvLDzunTUndr9fAJKKZ8+8QrAsW8evHRj5sHTzSr7/rr +reFprX1kepskU/7DbQtLixhDezTtpIOdtALN5iStoRgtv7pRqK1d3v345aff5xuzxnBvsgXZfbPS +OekvP1zb+ajeOcVpm6Qt1ezySj3jTmx/Q3fW7fyubIwZpowG624iyxdYqZ4mPJKtBaVohUoyuNog +bzs9Mniyyl0dPF+drD/aOHi/MTgXlJam16brF5XmGit4hfrOzumHTz768eLRT4qtPSvXZwRLlnP7 +h49Np0Zxlmy2eKUZwKZU4plcq7Geyw1BN6aDqvjB5SwAmCjm5otr7e6+JAenEhgGFHtftzqG1WoP +D3ZPn1c6hyTjXRzd++77P/O8Fst645WHo9mjVvcs628lguczDFi8Vx/8ZDw5CQWXzAY1VE1nWm4c +D2YP2uNLUch/8ubrFx9+EoszkGu1zunW9Y9ffPqbhx//Kt+4juIuQ1t//ft/d3HxLJHW/3DDiOVu ++KUjQWyFQiSO6cvT82b/JBLlUDRDkMF+A8Xo5Ipbbn5NVSsff/LdV3/8576/jBO2ZnS9wnqjc3Ry +88MP3/1ytvVEVLo8X9WNYSq4PBq5di0K3YxFRUBXlmukUs78XApHtUppHexkJAT2QcIJH2gxmcqI +fBV0HYye6Q47o/PB9C6vdM1Mczy7vbx5Hyjj0eO3X//w29HaWbY8e/zBn7z95vfnD77dv/7m2x// +/d7p64wzbtV2bt37PFdejqfkNGqBWlOkPI4pyeA2IrPo9WcrNxSlnE7LBGWrZrvWP+nMbu2cvFw/ +emL7/aPzJyu792vDk+rg1C1vq/ZA0JtadljrHbvlNYx1GblMQO/cWal7QcrdJOpRfE22Bn51h5Wq +stWRrCErdWSty0tNXgzsbRrRIPU4IccIDgT8wcVnB5efzXbf701vVTtHMPX5wujs/ptcba1Q39y7 ++WltdNP0VwynB471+PpjijGTKbHSOLSyK5JUs50hQWRTKYXnc252KMnNuTlkKVib02W13OyeWO4Y +Re1kXMp5I4qC99IIIvRGh6/f/ezNZz8enD2v1jZtp4uiEk0aqlIFtxUO7gIWeaHQ7h2223vF4iyR +4BcW0uB6CCKoYcJyWVmpsLzHs3a3vea41XAYBW2/c/rixuMv1g8eFeu7rNDEMFeW8n/ys1/u7t1J +pI1IVAgKywTXQwRPYEDOMbTT7e1adufaewnwoRxbNjID3Rrr9nKwqu71f/LND59+/qOiAHuWNnY+ +HK0+qrUPAAy9/CpJ5mPBEQB5PLnkWD8UomjSl+WeKFQ5Jkfg7vw8mkpwq8tHv/ur/xQNU4sQdTER +FIVpTfz8dsGfyryzvnmqG1XgLF7qK/aMZfTO4GC0emt549Zw5axU37DdXn94fP3Ox0eXT5c3zirN +nXwFkGQMntfLDmZrN02rG2xlkWuSWBa4LIRWUBkA0+DvslRMJNhkggNlmPWXd45fPg== + + + evWL0zufzrbvHO5d/M9/+udPvvzByk+y5c325E6pedwcXBzeePvs45/tnX0wmp5/8d1vM/4sTWRz +1Z328u3+7OnNxz+7+ez7zZOPJpPz//Cf//m3/+ofMDoXT5lXd+SZJFc2sqvF6kF/cPj6zZdndz+a +7NxfP366vHOv3N1d3bu/c/T00YuvX3/9y2p7rz8+efXuV19+/5d3nn21svPEr2xKWktSOpo5SaGA +jQKkOUaAPyqrWs92R6Jcl/ReGnUVtU2QRiJFkYGoGxrOWNO7NJ0HejIzjY2dexm3U6oMB8OtWmvX +zm0KSo/nGzxXBuf1h1ukISRwPEMz+VRKC4XASkscWyQJF+ie5/O8kBfEgp5pZewhqLJIjEFQhQH7 +RoB5141MNZcfzzbv7h6/sJw+y2dxKjjTcbXjjkGDjVVZUazY3jJBuumUkozLgLTJhJKICxj4PsLu +jE93rz9b3riTK20xQiWRlC2j6ecmNO1BmNF0AeyebQ0EvohAfHL5P5zSwtLm4jy+MJdemE/BjzRp +sVSwgsZx/vy1RCohxqJscD3iEna1BCMm45yilFjOgUwp1rZLjUNVdmuN9fbgYLx22RpdZPMzXa+D +c6y2NxXDk9RMxq1rZqPcOKz3zsHrpYINro5p9HSjdXXGlgnOACIqy/jppAydDYcwMMIsm2U5T8s0 +87Wt3uhsa+/B9et3Pnz9+d7x3dHsxq0nXx9ffv7wxfcXdz/pDg8cr+Plhr3uzpP3P3ML4Be21vef +HV+8Wtl53Ogf5MpT02vXq9NP333/waffEoyXzW+a7qxQPbj56Lsbj75tdg+2V0///r/899dffZct +Ljd6B5Oty/WDu6++/Nlf/u0//vt//F9/9jd//+z5l3/zr//jn/zy9/n6Tr624xS26t3znaOPn3z0 +6+PLb0S1oynVtc27kERpNJNGdIb3wTza+e3Z9ku/vAmibmX1UNcbljP2yqumNwQxqWUG49nde8/+ +WDHKrtfI+gPZ7I1XH6zufuiVjkiqznB1O7dmOBPwbhmzAvEA3Iqk7UTSCNYUYpIgVtu9E0VroHgG +9MDW4Yej9duZ3EQHk5hpEpTKSVmSMTFc4gVH1kqK3lDNRsbtylotjUiKUb1+82W7twvaTzW6BG4B +fWCopWk9HDNjMRZAAEILJUxBKVv+WrN/S8uMRamqSgVVDqxlxuqmklokzAlCwXYHstoGfAMZiYLF +WMATcRl0DgkRmzYo0onHeNDVwc7ApMqzPvwYi3KQO+GokEJB1eQEpcpJRdcftgaHJO2X/Va5uqzo +pVxh7PqrljtzvZVKdbtU25DVrGF4VrbBCZ6dnbjFLcOdAA2JYt331orF1XiMQ1IyRWQwDDSJHFpC +r2oKoSTugO+jKEdWK5JWHy2f37zz5u7jT7rLh4pRzBX6O0ePy/VZsz0r11YktQJBmMn0LKvv5caQ +wrXWVnd0ZFhNQW1QrMcIuYxd97LtenPdL42DIpBdiLd1yILN3YeTldNyvr02Wvvqq2+2j244bnNz ++9aLT759+9Off/njn7/7/tdv//jH+y8/2Tu6ePfFT568/Gpr58H7r37YPH61ff3N9Yu32wdPwLRy +Qr6QG3z9w1/tnDxZCtPRGCfKFd0eVbqX4/XHklrW1eKf/PAb1+2CQMJoLwfGeXRxcvuL289+3Dx5 +rWrlJ49e/fDz303WLhixotljVunw6nBl4+m95z8frN2nGPf1669H05N4UgmuRE8aBFXgxOZ4Cjrk +qWX319cu9k9eTlbvdpdPVbtDMnlZb5nZQWf5TDKaCCZDv0SloGhVTsyCAeHEkp0brR88++zHfzPb +vmeabddfwYNDIkKwpJsKnneBZeiPThW1ruvlUmVFt8f9lYd2fpMTwToB/HY1vQ90lk5nOK7o5SfF +6ppqtCnGD67JiwAiYTDRNOMDxgYHiMLBZrZwsI0wuOEOxPzCAk6SXnD/1BKFEK6VW/bKm05hZmXH +hj1KpS3bKPGil0jxNGfLWrVY3am2T8stMIBd3SiXykPL66KYms0tdyd3moObvcntq6KUQf29eJTO +Zlo5GPCUEAohoSUEQAy8MM8CQZclvjIcn7BiTtMrWYjk8XUrv6xkGrY36oJklf10OtgIJCqdSv24 +0jqzsjOK8kgi43gjUa2HYzyGu6JYhmzySzPdbFO0l0rLsRgj8B6ogmQq2EnCMZaletVcs14Za1rB +yZSHg82VjcPhyma1MbW8jlMaldubvcnu1vGdZv9gY+P85Wc/bp+9gJG0rKbIexSpU5hQ9Ts3L1+2 +Bnugn11nWipsebkVIzMkGWB8JqNlbt16wLCeKPe84m53dHn99mcXD9/tnX/ol9cNJf+TL376z//P +/3dx/2NebVW6Z83lBxvnX73++q8v73/SG+16Xu1Pf/0Xtx68SaMGmLuMt1Ht3VzeePr4w19Vm7sl +f/TTn/761Ze/iiVVsCcIbita9/jG2+ef/ubZF7/1a3vDwf4Pv/m3vdExgugorutWtz+5e+PhTz7+ +6i829l6Csfrg1Z8023sLwe08eCwmkWQBoqLe2Ns9eq6rtVcfvvub/+MfVa3OK307vwPf7hb3Lx9/ +/+Ttn3fHd0nc/fTdzz/5yS8K5WkkxoUiNPyJIAZNFWRluBTctcrdv/3y44++AgCZm4vNXYu990fx +uTkcQX03t0cSzs7+3enqGdhSwwbca1BMnqBLCQTmrgImi2Vs120RhI7D34WClZtWWkfLa7eObn6U +La/SdKZe38oV14I7T1ETdGM0JgbbI3nP1EoEKqYTpMQb6SSVTHIUV6CFCtgZlqvQXCmNKpbVAgk3 +3Lh749EXB5dvlvdeFBoniZRI4qpldXAiePR35fRlNG3IUq3a3BPkOmREsbACTUJxDUY7mlDALQbl ++wjHVBvJYD+JWm3sgNw1tYbIFTDEYEkLwKdcXhYkN5kkeT4LgJPJtmfbt89uf7R7/DibG5VK41xh +mWGzipw3zaok+AxpSqwtcPAWMRyhwVuJfAVSnqEzJGGlU6oulyTO4xkXLDkkuCxVQTAzrCtIvijm +DbNe8vvLo73+cB8YARq/uv2ot3xerEyMTEXX846V96y8qZeDtfsoL4tlHRosFmjaxjEVRySgp3xx +RbXGyZRZqOyUmwdOdrK+fW///HlncsKybrs6vH3nRb2xwdL5UmWzUFl3ciM9U7ecJrhycLKa3mBY +P3x1OQVoxay3ni/umpmBJOYtLdfrzGZrJ8Epxfb1QvN6f+1xf3a/0tz2KxuCWORI5eT6/dObLzS9 +DlLQdsYsB+orb2jNRIxLRJms2fz6q1/88fe/Ai8T3K8aVRJojpXbldZJub7vZqq/+/2/+ea7P03E ++IV5NBFXFLVX696aXX+dSqnpBK+IMI8DhrYBNICSYPBB+y2vXYAQ4mH0ZP9g73a3t4OgBo7ZIGIF +qQKDQ2BiKk7GIyiBULqk4ShGoLQkF1rjS9vfMOwVQWlKgru1enJ568NCddWwO34ZzPI+xdYQRBUY +S1cKSEpAUxJDZTnal4VKNrsMvowg8zxTzKgNU6mOe7u7+49R0gZaoWgXRYwkwH6CUwW3Xl9NxMVI +iAquYI5wJGHDmEhSUZR8CAw/P9SMMklrXn7YHpwUKrt2dmU8vZMvrpOkNRkddrs7SDqoTIITYNXz +yVSOJBua2ocmpRKEYxRcuxMH35TW/7ACiKJOcBIfsxMJ2XKCDOX4iutNveyQ53LptAoyWBDyFGml +kpzABjsSWdqCoKXIDIKakSgHGcHRZiJKBKezEwKSFCTWFfmirLZotphOi9XGWrE+w3GwqK6RqctK +0dSrnl3TFR9Jcpqcr1RGBA5pxTK0CeFtmtDgKnQnkRBSSZllfQzNUKRNUy6MEomqhpyV+SwYChwz +ustnhtXl+QIvFCnSBb2kSCXLrHJUJpVgwkso5CZLO4sLSGgRS8YogZZUwSxmO+36FuTp4iIWDrE4 +XmDFJsMVaTrL84YIpqW7nPNai4t4cC4st768/nD75NX6wVOwGAyEE+NQpMqQasAOpAH9UvVKzh94 +/hAiP6PlbbMocDZMhMCCJy3RjM3QViJGM4RGoSKD84ascxSjiLrAW355KBk1knYJwnD04o3jO4+f +vLZsEGmFYnlrOL6fL+0zTJbEJDTJpuIMgag0mSEwlcQ0jnF5vqTpA1moUpjp6pWHF0/fffNLgrYQ +TKEoCwfgwi2OgpeZTDDxCIWAsEyAG9Ix3Loq8qCgqC6LRS834IUsy5jN9la9vVuobHqFNSe7IgMk +Epbn9jxvAP8ZZiFfWC1XrjPsgCTq6ZQeC2NIkjTVrKb480EZGQQCmGEqPNek6AKK2gTh5oszSa6C +UCHIHPB48EsqB8IYgDEoALKEYSmBBO8cIYOqCGGGogHiyizlMJQei2Cu2awUVijCIlGdxCyOASVg +YajUaM78Qi+RoAXOUdWCKHiykONog0BYNElJnFUtt5FEmkjjLAVc4/G8D1+XiPOhJSwWoUH6Lswn +o2GSxMx0QsRhvkiTQgA9IMy06ep5xqhiaVHgfZrKMbQLGQHzGA2hkaVUMkpxZCYSVKggwB4yhJNz +m1kbsrtC4878fAqocGEh0NJXx2CZRJzRFFeVHYbWYlEC3KIkVc1ML5sd5EvLZqaTiLNIGvgUX5iP +YCmKpmCCFFl0uu3VSmVi202aMlGEjcexdFLgmCpDuQxlVIuT/sp5KApYgUbD6Vg4zZGiwulZuxRU +IvJrilFIB1DvT3qbDVBBik8RSrkwcJ0mMBFJO5EIg6REDFEMMC9Gg6YMSJx0ksXSPIFpgGnxKE9h +lmfV++3VdnsmcIZrlwU+CxoV3kjhGoFo8/MIQBaOBF1bWkzEkyqG5yS5ncmM3ezUdrokLgP4bO/c +0jNgRvKg4nSjm8+vtFq7WS94cphKCoKQlSQPQj1YFwsuoGRI8P6EiqTZWARJxTCWUEgUmiolEiBj +PNPsqkoAFCiqXZmsIWCOKPVz/kFwyIW0U8FCG+AqGwml0LQINkcQilamJkv5q9IKyWSU2Ns8v3v3 +Fcc4iRiFJDgiJetSHjpFYmo6yUWWEJrUJAHQRksneRqXeVIWGZWjNRInU7EEg5HwI2SiIlcksRSs +U8dZNC3BHM1fiybCdCJKRSAM5hLh+XQ8whCoLrFZUy2BbqkWGvfvvgCRCWSHJCRAFSyt4mlFoBwI +v1iYyLlD31shUZMFjkgr0RA59148FoF5MeAbF+aiPJNRpHwqwafiMEQ02LdoCGMwXeULLGFjKUni +fF3tLYWQ+fnY3FwEuszSpmWC/DZzmdyDB0+zXjOe4JC0QtE2L5REuclyxUSMcDTv8e2Xv/qX/yWN +6+/90dLiQgJPC7qUs8xCzqsYsv3o/rOTi0cYoUTC2NWifLAuz7GWLFmGahc8UJibqlznOQ80Ho5K +8HuG4GROzahFEpcIlCHSLE8bvtcVBQdHYQSSuijkPIhJKYWyaYQERjCUqqmN0XQGmA== + + + KBTGFuajBK4rSlEUc0RgWi2CcBgyY6oFnjZxlM9kqtX2HkHBN6poOtifefWvJceqxxP00lIa3DSa +0gTGJ1AtEadIQirlK+Wsr/FaOkEk4iRJ6tncoNHZg4hKpyRoUX94mC9Mg1uhQxiEE4EpTMCAeUNt +sZQHgVT2B7XiEEcYgHRVyHCkxlG6QKlYmkonUPj8R48fs5QcWUzHQtjiXDw0n0rH+aDMo+BeLQRr +BOrgKQZLYrFwIrKUQJNYzjA7pVyvVnAMq91d1gw/GgEPlQoHU0xQqI4m5dBCav5aZP69SComqFJN +EUt4SpJZK+9Ui9m6ZdaSMZpAFBoHrlFjACxz0aX5RCyEInFG4fM0riUiGER4PAqRL7KkRxN+OqEs +LaSW5uOGUoKADC2mIA6BdgXWdY2aQNrpmBRZJLEkZBYXXkRiEQpLAXjKyRgh85LCs6bCtovu8vJA +lBUCDJJTbDcHeb8sSjqO4QyO58A0tsaFUm9hIRleQrCUaKt538zrvOCq4rBWODzczZdrKYSOxSkM +BQ7NqEqmkHNr5Vy9lD3dm33x2dvxeCsSQSLhVDiUkFjVAHmUMSxFpVDcM9Ra3tUliKgonkooLF7x +tW7NfXRz+/69o+2TWbsPH6ZZGRAbOgiYK1NMQ0syaiZrG5apZe2cxLkZrS6wHsieRBiTWbVZbfeG +K5lMoVYZiqJDkzJDKGiKCy0ic3Px4FkWE5SLgaFLx0lQv8POdHtr29IMEmESMZImTVAFOa8hKz7H +u+32qm3XMpmaohSSCRZHRIgZnlENKSPzDoUrQNmyWJEFzxB1k+fqvpXL2IasurquMJQCQcYTs2Hx +YHeiSoCKHInKREpgMI0lMkBkEB6AITwoTFTCkkkilcCTSUdRx5Xsbte/3Gh8cGfy/Nbq9z99eet8 +q+TYPKsTmAzcJ1EOBNi1PwotzidT4LJTUiqCswin0IKvm1nNsBWdhuRNEYakKALPAz7yksSoupBz +zTqGiKHFxPy10MJcDMIDyDEErjPEzc9hc3PpxQU0EWEh+JE4QaTJcr7GEiKL8Y7qk2nQ/JxA+6qY +T8bJxYVYIkpyoGHSNJ5IKEzaN4hBRdoaeQdbrUEv16ga0272yfX+26d7FyfjcdsdNXNFz7cMj6aU +xblwPJyk0oQjyr7MZphk1SSOp4VBJ+vaomMpWdfRZaGUVfoN43DZ+fb12bef33r3cvfzV0fdVikS +TkZCCIWBYPUtWc0qXE4mfYVYa1nHs8JqW685xKyh3dwoffvm+rdvT/7jnz/5f//Hz/7X//1Xf/mX +r8/26+WcYKgSz+dJwiexrMY7dd+ZtJ2NUWGtX8obUi2X1UQVSaJ4Csmq6qhdnc26J0e7337/fX88 +JUgqlSShAUsLgFeimRnz/z9J7/kkyXmde/4DV8RMm/Ims9J7bysrs7x33VXV1dXe97ge72cwmIEh +AMIKIOhA0IveSBSNSInmrkRR4hVFUiRXFGVWV1q5jdVqIzbu3dhve3IUUTExwFR3Zb7vOc/5PVmZ +57CV8NLcqTkexyuOM6jXmuU8mcsSWSyXwRRBXW7VHty5sTIZu4575sx2tVoicAZBaEUpCEIByI0D +XcqBEPDwqrmFTrkOhbDhSk2TuLRTv31htjEoLpfVk1nptacPP/DShc9+6Nbbr1x64cG53Vm3kndo +BMPSJJKkWdxWpapAKQJOGRzZ9YXVljFtmTvLzq2d/EuX6h97fuvLb5/89gcv/vVPfucXP/7KR185 +uX52Nuk1LFGhUBrPMkiG41lPYlw6i4GpbprKUmC2HWGjYx+ulLaXKyc7y88/efbBjc2XHx2889q1 +D7z84MHVK5N2p1rImzJHZLNAX0iKi0cICKd4hAJFnT8Vjy2mc0kcS2ZNlq472qRT8TXJ5ul+xe9W +yyWrULbLdI6fOx2HhEWSJMCWQWbzdGLootfXjNdu9J672nv57vgLH77x9U8/9dn3H3/u1cmvvvvc +P/z8k3/4tZc++b4bl/Yn9UIB7EM6nkbiUQFJ1KTcehHfKKcP2rl7O+bDi/U756p3z1afuTp4+fbw +g8/NPvzi9POvb/zVH731dz//1Lc+c/2FS6WmTWQTyWQc5WlNoBUGxTU8M3Fy10bc3XXpzeuVL7yx ++4n3TD/6/NLn31z/828/+w+/+NSff/PBT3/v7n//s/f+j//48R99/YV3Xtx98qTXCDw6B9kqeIpV +d9WlsngwNK6t2Vs1fKdNTcr0wcg9nvpnp97Dk86n3zz/61/+3k9/9rUvfe49b75w9uq5VUOmU/EE +kiKxnLK4mJ47tZCLx3wRrci5ho75QsIXU9OasjNw9sf21XX7o6+e++ib19564fxvf/zen3z/kx96 +78NBy93ZmG7vXDq88IJhtch00uWwooSPXPL6qv76rf5LV5s3VuW37nX+/Luv//j7b33mld0vvjr7 +5Q/e+Ne/+8o///qzf/LlG//00zf+9Ov3b+15eQ7BU2FPQhZTmBwpY6mikN6pUy+eD77zmWs//t6r +v/eZ2596afy1D2z84Ms3fv2nb/7pV+/+8AuX/unn7/2bHzz87Evtl67VLm9V657R8KFWFh2jorJC +Sc5NCthRi3/2yH/nmbX33mq9ebv2+5+7/fMfvv3Pf/+tX/35J3/6nXf/+9989P/7f//qr3/2uTfv +dL/50Qs/+f4rn3z9XNXR0jEMiizYWJHRiUyGhpKPxC065VDR7TrzYL/45GH16pp1d9d94/7oD377 +xS+8/9IX3n7ynd98WPMKGCqAAmsk3Ta4jRJ50mee39c/9+6l73z82rc/fvVHv/Ps3//J2//j3/7o +Vz/+2A+/fOOv/uuL//zL3/raJ+5e3KhWwUFyimf6Ck07LLZkk/t17PaUeXZHf//V4FsfOvjR1579 +3mdvfv2dM3/8xRt//8e/+e9/+el/+cVHf/69Z3/53Qc///1HH3y02fXCIggQkkmiZJbwFbNjansl +9q0LxsfvB595uv7tD2394hu3/s9ff/hvf/zeP/zi1Z9/6+4//NnLf/uDd//wc+d/9IWzP/3Gtf/6 +mQtPX6gOqwU0heNZlkOpo5XW2XHhqK8+fWB95fXpD7945Zsf2v7623u/+pO3fvrd9/zBb13+/ifO +/sfffu5//scP/uEv3v7Vdx79H3/9zne/cONkFWIhGV2MZFMYaLvLC5s1aeJkx2biwSr76gX3PRfc +991rfOHNze995sI33tn70def+re/+8ov//CNX//wvf/6N1/80288d2O/vTWb1htjAterbqGXV6cB +c9Ihn1xlP//C8Ce/e+cX33rqO588+62PnfnR7z74l19+/CffevTdT579b1+99b//7IM//9q9b7za +/vyzlRsrEqiKyorxxfT8ExEinijy6Y0AuTUWnj5w3rzd/PRLG3/2e+/+x7/40P/2o9f/+gev/vUP +X/vxV+/8+EuX//BjG7/1dP3JTW0loEsqGbYTFSyetn27Me0NjyaljSq3U8bvz9jPvLj0B5+88IMv +3fjDL17682/f//WPXvubP3vzJ7/34CdfOv8333/yn376yq++/9Q3PzD5xH3/jRutQcnEsrws1gTO +MyV9qWoPPHrFJ2/O9BfP6G9csj9yvwqr8Zf/y7t/+u37P/7anf/rH3/n//6X3//WR85++1O33nzu +jEhyJCoEilqS6KqETjzioEHdXVXfut76xgePv/epa3/y+Vv/9vNP/M9//5O//eHrP/zclc+9un9x +u14yOJGkaVy2tLKjlT3VL4h8Q8V269KdjfILF+q/eSX4/seO/9fvvPjrH378y+89/NKrk+9+ZO9H +X7n1tXfOvXyzc32nuVRv2ZBTcoUhbfBiAm3UnHI379UVarVAX191b627D3fdTz3q/+CzV3/27Re/ +95mb3/rI+S++dvj2vdEHr3WeP1M6M9aHFclRODTLKXzds3oqI7dco2GwbZ3abcovX2x+/f27f/y5 +i3/x7Qe/+N4Lv/6j3/zHn370z373/o+/fPmf/uy1f/3JWz/7yvlvvVl/41pppyXzWCabwl2jVfPH +lui6HDW06ZGR2/XSz2yKH7hTfedB+3fe3P23X338n375zq9+8J7//tP3/etff+ZH33j6a28fffq1 +7YOVwNUtgXXhdHq1JVsUSwpzdsmbBfhOEbm2xL50tvj2k+M3bg5ePFf97HOTn33z0Y+++vQ3P3j8 +5VfWPvLk5P5msNuEmoortMQSBpBMdB7hMU7BMj6TXslT55bca+u1yyulp/brv3m9885TKx99Zuud +Z7ZuTqxbY+PGxNlt5QNJ0RlBpkVgflUMZL5oKlVLLnSLpbajtQzhqOvdWqvcWXXfeXLwjQ9u/8U3 +rv/jn7/xp1++8zuvr//Oy+P3n7iv7hlvnq+eaSsuleFzhCaXHXvMUB7YQBplRDRbYJCBSZ5pizfH +7Ctn7fdfK33p5cmv//iV/+ffvvoPP3vfL7778lfff/3+bnutUTAkA80ZRE4gM1kuvK+LqhvCwOXX +yvJRz7yzXX5wUH3lcvu33zj83Q9f+egLG+8+6Wx0LInDkFQyGcsiWankj/vdw6I31nnLpJkl3765 +N314eWtWpu6uGe+9tfSVDz357isrTx02njvfujTzpjWjbApgcHjaDdsV5lyaKYGRBwdd9vsFPa/i +hMsyTUtrOXIvLx4O8ne2Go+Oh08etK+uVzebwUYlgG0sG5JIkxhKZzJcKiVydInBdTSJYMk0j6Au +y61Wy+cmjTubheePC194Zfa937r41ffu/uAL937w2Tvf+fCZb79v/6uvbH364eDBtuVLKJh2hTfC +1sdUgSHdDBgihO3kg3HRq/CZaT53ZaTdW7ef2XO//faZf/nLT//jLz/x377+9Hc+eeuDjzYenm/t +jzzwxrpadt1llvE41iFyosZbo2q3qvItkxnkxZbG9i1pverOisZ2ib+3WXzhZOX2Rn3i8l1DKcuq +yYgsxqeTQizCLswBAZKGFEg4LSCIiuEVw2j7Xs/3B55b1/iKxDY0sefKBTYHLFgUlWF9pPAeuBIC +SB5TqpUxTdrZFMA2TWQZndXahcb+6tHu0mzoqAcN45mDxoWu8uR27fqsfLalnWvrezVjp2r3DBEB +LIggGKILXBPPgQ3MgtOML6SodLiwNVUaukpTwdZL/FFTerDpfuTR6iee23792vj6tF3meRljHb3m +V7aWZnd5xjeUokBrPAkLYliyofOKLevDer0T2M283MxLvsY5qmipOs8pBKWAVY9G8VxOV9QKy3uJ +FIsiiszlbcWtFmrNUptFkEDkBr7bKYKmORojqYwIhiKXYcFJIRk+EadjMRongmJlr1zfC28h06oC +a3G4aCs+nYMyzVqCs9rb2hztTjqzwMgbnGRJBTe0MPT8QjyZYnNEwAk9RemaWoenrehCIr6YBF9v +yV5e8z3NqTvmsGLvLfl39uonE/fWVvXu3vB4UF6rmNOS23UdLJ2bn49l0uGz7dEYMQ== + + + N58Gv8mwtUp5u9vca5ZGGst5Etlz+KZKNhTs4qj81lMn73v39XtnNvd77bKmKDRF4zQveDjuYriT +TMumO+mPb/QG12rBmsbZ+2t7T919lsMl2C+R1ApauVFod8u9qlPVGB1LMHhGi4MtnUMhqBA0n05b +6ZSOY3lFLKEJjMpArafiUTy8/JVm0axE5AyOyvO0R2NSJp4lMiyaEtCMKIbfWNkcHWjhwywrmYwK +tjed5GjM4inHMTu6OoDEYXOCzqrLtQ6RzPpKoeK2XcnlUY7DVJbQk2Gn8QyOuSxdSsTYd/2XyKl3 +RcBv0pjmqnlPD1iMY1DKYOSCrIfP4pI5hyUcjvNEKy+W0lEyETaEGTWHlz1/1XZWRtOL+aBLkDLD +5k2rX28dleo7LOdQpGIqhZXxVjyFLyxm40lBVAeWt2Y6q2LYWausSNXp7KJq9+IZnaDDhzJIuphF +TBKzOdJMJ4iF+VQ6IdBEQZY6LFsDmcphDoKYslgBLEkkpUQqHHVEUr5pdd38wDSagT+Qwls+wi/a +CMKFfxLltqJ2NKNj55ctt6/Igao1cCrI5qwcZiOoTVA+QXiZjELgBse5ul5TlJKut4NgxSsMbbPJ +EZLMKRZsrFyKxbKZFIljlqaN3NIRwVYSSXZhAZ2bz0JgEFRNM0fhA4kJJh5nSNLj6QKFchRCmYLZ +rIIuWRiukVReeNwrD8PDhufws1HIFNxS1VateSTInUzWzWa1HGZ6halfXItH2UwKltdT1IZuDXN4 +IZ0xUNSWpa4ktVNJORblGabRaJ+z3KmqL+FUMRqDyBE03tflADwaL7Xy5a1ia78dTqRdfzxtXGWZ +/NLoghh2L7ccdxqUdiv140LlIJYy5hbp+UUym7USMe6Jd0Uji7iqLxdb5yqtM5Y7g+idP40gaSUZ +l554IrO4SFBM2bBX/dKx5cwyiJNI6YuR8GspgfUgmBfCq2SxxXkknWApwjbVliYG8QiSjmN0TqFx +nYLtzijhI0sZDSUK2Vz+id+IOcVtWqyKcvHs8d3R2gnBBZzSoLiyrDc1s+u4o9Ha1QyuZnMqJ1bs +YETyFZTwc2RRMceD5at3nv5wY3C4EGPTKOjEtlc5L5szmqujOTOVEUnKlZQ2xBtGeDhVVowVy9sA +RdT0nizX01kDyTk5wmGFpuFOCuU11eyTdJD3Jo32oaw0DLPHSQ3ZGlV6F4PWWa+yY3kTSalPNu7J +Wh/FDNVscFLdyE8ErUdwdYqv2950eXrt8MIzJBtE4kw6q3FiM7zBjy0zYvgIj2t1x5MT3V7S7AGv +DQm2RfN9WZulsyA7hSwa3hOYTLO5nKqqTUWfMmwrk5KyaUlTO+LjJxoUY1huHVbaZ1lpwEr9HBkg +mMNLDYar5HKmJNayqJVK6SRT5OQWyTVjaXNhkWVYP4uIsVjYSBYjCqLc44SmILZIuszyDVHumM4k +kVTQnIeRFYptYmSJFVokU16MUJFFyjCGotxIZYQMojJSk5batNDSnbGshbdl4mSeYKrxtJFCHYyp +5atHWn7DLe87wd78AhOLCbzQkNUmkrMxHHI/yCI+iDNJlRDEjkZZmqu63szNr+awfDh7NGNycl/S +xpbZw1AVwvLUqUwsQqUTXDaj4ISfCZ//tREEIspNREiQNYZy7fyK6a1p7qrirFJcY36O5NUlXukG +pdmNW6/2xkcIaRFcEWd8N1h1ixthxzBrSQhvtlnzSisZXItlxBRic1K/N77dmz1ZH15m5DqKm6La +M/IbhrdFCV2MqcL62/lpUNk2vRWQlwxiqubYr544waGojSi2ghE+HICsL2Gkg6C6qHYgKiqt42bv +Qq19xi9vl8qb5y4/L5k9Vu3Ul6+uHT23e/Li5pnnGkuX+is3dX1QKa4cnDzKEjbBBhBaRmG73L7Q +n97pTm6X28cE4wtKQzWHgtyj+TrEp2SPZWOwvn7j3NVXFaO3EKMymFOo7DeHNyutG6y4jBJlBC9g +dPD4XjgVzanRcAqzHvb+JQs0W0Nx3/FmXmmT5PIYnYdN5LWx6oYTlu1gA2IsmzVWppdtdwznG0sK +IImM2GGloWLNeKWN4SaKyJbZNexlkGI0BwLoadZKobxfrB2WqvuJpKpoS6oxldQRfFYWLySy9kJM +RLCCV9xh+HrY354q8EpHsSeyNeWVXhoxILCN/CoOVSPshNYn+YYdbIv6suGt8/ooixVUa8Wv7MVT +EJY6hBbNtGR1ZOVX4YxyWCGHeYazAoUYIjAa4xDUUI1hsXbASYOwZ0uMhaNKZx1QtrlT8VOnkqcX +6AxWVI2xlZ8JcjcZF9IpWZZbAqQw7sErbJ5JBro5FtVRs3Oh0T22vDHFB4LacooznPNFtSkbSxCE +sjEMKhu98QUjv5RCNdkakGwVp0qMWM+Q5RzTw+jmf97Dn8nZOdJXnRU72OpP7+5ffHO8/ShHl3A8 +X/On+/t3sqSXRPMZ1CeZtu6sV3qXKsPLqjMMB6vVNnito9pDSe9Jel+xR0F9v1DZYOWqE4wv3n3j +8Prz/dnlcuesUdiCmIQTWRqeOTx5BlZM1jvNwaX26M5w48nW+KqaX8XYulda3z5+ttE7m85YQWl7 +/9yza3v3xxv3zlx91fQ3QMQgfiSty8s1jHIorrJ58Pz63nv6s2eC1glJVQi6oJpN2R4sxIRkSgXt +Mqwty9stVI4qrSOcNlWr69ePnOI+6EN/9c7q3qNK+4zlrQNoafYIJVxZbyvW2CrMoC4o9noKDR92 +c/OTzZ27LFdKZ2GX85a7Uu3BCqxL9hot9FIZq9U+U/BnsZSaIytZtEDQNdvfL9TPK/ZGFiuWK+vX +br6YDTv7cZG4DMIlgoR2zh9ef78o9+8/+fqXf/f7zc7+YkxKZm3ZmvS27q+df89w8ynL30wjVqW5 +B6kRT6gLizTOlFESdHVQ717JFw+SCR3JGrLSgpyKxUnQroWYFM8YAoRQcFAf3njiNBqJ4BhuZXNu +FslDTGJEMZ3NI3jRKmwVG8dQoBMpORvySZFkqn7tDEGVKXBYQgPERHNmvdHtteN381rdK65Uu4ft +4dne+HypsW24Q1hMxer1pldh18KxuWrPDXZbw5ut5ZuOvwWnmUR1nPVBpqDCslJbMiGzNhhxaObX +R2u3h6sX8fDe45npTVV7wisDLb9mlzY1u7+zd+v8tRetwpgIu8pXgYQHqzdmZ1+wy7t5f7S1denD +H//twexslspz6lJjcHVp7cF052FzeIZkvFiSZ4QqzVcxJk/LtSxVkMyl6c6jvfOvdkbXJHMZSudg +5aag9QmuqjprncnNfGVftaagV155fTGGpVGmUBkVG1Pbn6BUheS6ujUr1ffPXnzu/JXnF2NsMq2I +0mA8fWr73Gtu9SIrD3mh/vJvfr7VPcqiDqji1tHTL7/vcy9/8Av7V1/WC+tAC6a1/M5HvuoUViJx +KUdUjPxOpXt9vPXM8aU3uqMbnFCZrl+ut7ZiKS6Lu5w68huXd86+Ptm8t7p1Vwkb5TXq3bPhJqKO +ao11b10yV1hpqdm7srZzDyMCQGWQaNWeKvZyeFMr2wRmO3Py6OFL74ham6DLXnHXK4EBnnHKgOFb +QCOC3O+v3CiU9xYiYiptWYXVQm2n0jnTHl0CXUrGwKVvrG7dAQBeiDBQ6y3/SLGnmjujxR7Jdhaj +YimYPP30W7bde9dvRKMRkmRKbnAw2nx0+f6HWoMLqbT+1DNve8FqBrUyQPfqJAfghAdwLvnS0WDl +4eU7Hz2++rpp9a6cPLU8PQvEZTpDr7jeXT43nF5ZWrte6h7IWrPV3e+ML1NcVTQ6ktWnhA4UVskc +28FmY3DCSnWgNUlfqnWv9VYfLe88ak5viEbX98ZnL70naKxDGNj+eqVzbuf4mdv333v7mXem23cL +werK9GS8esl0liutw6X125XOhfbwwu7x05fuvl5uz0aTc1u7D63CGid3aLlJckUgMV4eOsGuqA0M +qzvdvqrYfZQs2IV1KAqquybZ0+WNJ7fPvwQx6fgbfvN45/zTh9dfa0xugU9KYx6CuWZ+qbl8No0J +er7LKj1Rn1Q750qtY82dwFlEYgzNljVrSbHaor0s2VtmsOdVDoLqDk6F06wa7V3D7YtqxavMBps3 +y92DSvug3j1Xax3ilAfy6JV3vTLs8jRf3QaQNvx9y9tsDi46wSyNqL3lc6ONO2Zh3fHXZXOgOcus +2CqWtyCqBbnB8tWdw3uPXvnkyb03146f7k5uOoWpIJSuXHn2hVc/m0YdnA4KpfXRxt3ljbvD9ZuD +9TsAaQ8fvbWzc5Mg8ixf6q/d3Dh+Ybb37GD1ycnOC4I6isYVTmigmJMvbeYru3ZpS7SWAH7K7bPl +5snCopDD/GJtnxO7i1E8EqMWIiyGl2GdwQhY5jidVk7PZQBfRaXHhlHXZPh2KmuDlJ2//Fqpsgm8 +ilM+RAIUR5qtQ5kG4sqXtuu9s5DLklTd27xUa68RlGOY/SZI7vkXji+9NJhec0tTRW+szE5Gm7dT +AHVMXs8v17sXl2cPG0tXa/2TYnNfM/qNzr7pLtv+rNI7KfbOaYVVTuk0Wme3zrzoVtYIttAbX6m1 +j1Y3r12/89LOuae98pqud7Y3r8+2rklqs9bcuXn/zat333dw8aXt8y90JldMu3r39vM3br+CUSDC +IF9dzRlDDJTbJ6a/y4rdanXj4Xve9msznPYrzSO7uOtWj7urt688+NDOuef9YOvStZfXjx4IZqfQ +PND9Pd6Y2sWDcvtyb+WObC6rWu3hcx8ATcjieZwu0WKXkfuCPuDERrN9tr90cvb8nfW9W4w0EPUR +CHKW8DEmsAqTtYOHoWxyhXJjqz48W2rtd0aX/PoBRtUIplLrnys2D1DCE/VOqXOmsXS9sXxreePZ +5tJ1Mz+TlNb9R29evfOKbPQArhi+CQahO7pSrB+4/goQLC9Wtvfv7R7dK1Znlj+GaC8U15rd3as3 +Xzk+9zT4BcNanm3f2bnwvNc4kJwVyV4BfL115+Vmcw1FVFVvd0YXmoMzfmkN0k0wVpKIF42rqtbF +CHeydfvC/Q9sXHy5snS5Njyp9C6I+iwa14FjV9eui1IrlwPz7mQRlwbmMVYEqY+i3sICiaCWrAxA +lBYifDrjivJIVMZO4cArH4AvS6RlSCicLIJr4Pha2EA+q8IKUHxNdyZ+ZSfMDi0kT1muKlqvUF6H +ZFTNAeCxpHRKjSPNmy5A8SUdCK3+5Hp/clvLr1BCNYnoolBdHl/Wza4glkHo1o+fgfXfv/DS3oXX +lrbuy84Qp73x+g2GB6TxwpTX+7q1VK1v11r7kt6mmbznDYJSv9ndKDY27WAmAIbp1Wp93SksQxER +pNbjuRVujnF0b5Iv7/mhjGwXqisYaRlm6+7DD56//Wa+tu/X9sKHpt2hprX29m7tHN4HpQXOby3f +LbZO6qO7oCEMsGhGLQeTa7debPb35hZxkq2BvFQHl7zqHqR2sbS2NDj8+Ee+8Mb7Pg== + + + nc55CBGw4sApHqwdvXDy5McmBy9Iav/KlUef+vw32/1D8Gi8PuM0QOi1wezJ/evvg13L4U4ebFGw +yggQb2WSq1JsVVL6pcfqdO7yo1JtfXPrhutNRa0HXgMlgiRiZsBvqv3O4LJhLxnOslmYckprsnp9 +Y+9BUN2nuXBwUqO1F5RWWdg1f6cM7No/8RvHijmCLQabUKrvUkzlselTQAxVd6vYvhI0z7Fik2KC +weTMzvn7stVdhDdkdVbq1HqX4EeC0oZpDsL+YLRZqmwQZCkeVxYiAtTERNIkyHK1fr7TvyWrg0Zr +t9Y4xHJuJq0B6kcTKkSaoo8L5UOCrKj2smz2IO8gBVixDoguqAPFXsHZOkIUSNZX9FYG1SWtVW4f ++NXdfLDdXb7dWbnLGf0MZhRqm1Zxls6ZFFcDmyaAm+ueM+0VeJugtHHC7i6d704uFpu7hjcVzB7O +F0mhVqzvVTtnQBzAoStGX9UH5epGvb2TL60msyovBF5xTHKWJPm61bfy00YfrOUmOCNGbCA5VzUn +kjFMo5Ji1oLmdn/l8vrBM5PtBylEQcJb8Zvj9Su0VAfrFDYGl3rd0YXB9Hx/ciKIdZ6vayb4r0Ik +zkAW+JWtw/PvBsZw/TUsbE7IRBMc+GiGL8aTDOiGXRg1muuDwe7JxacqtVUE80x30/Z2TXcmm0tg +GUDf3MLabPPm7tGTGFVAiWK+crYxvu83L5jequVv0GLY8P/g+GG7twdmGcF9mm82exf3zr1nZeNW +dwilc6vX3/vIR740nV1HqVqhcVwdXq70LzRHl2HBCSrYWD353d//0XOvfRxgFbynYq361TPN4dVy +68j2VkxrcOH809fuvMlKTRBSgm8I6tDKr0n6mOI6OFkOgsnq1lVGrGF0PUfVUlknmdJFudHsHWwc +3CXovCDUVK2X99dm2/fWt24yfCOR0qIx3tD7W9v3OL4+P09Ho6IoD4Yrt6vNc5I2woial5986MOf +vXb9ubk5FHxBOlem2G6xtF8u71nWWOCKcPqsVMPIPIbbhjNkhaagjwi+DZhdqp/zy0eFyg6sOZCn +W1yVw4b8PZKrEWyNU3ql+sFs/5FZWIkmWDgeUeuzcrPU2oOzgGpL0H7Y6q1zLGotkCnHXwtaR63R +9cnOM+dvvtFfvYYzgajWw3BKK7mcC86CFdoEUwfshBDFaCfv9cBnpRADKBQWJI1a8BFWYVOxVxmp +yUuVMxeeUs0OK1QgT8EUQITzQrXePNg5/xwajtgrqXqfFxoAb8X6Rr48Q3HncWPnLka6qbQkKA3P +X14aHTreUiTKL0SFZMYk2Kqdn1KUw7GWYXeqne21nZvT3Tul1jaCmUApujV+3B2Cg7wAVJ5u3t89 +/6qa304jfjQmFworXmkti1sQouDlUxmbYtumt2WXdiFrcpg1Wr0CiIiFV4ODHO6BAtebR93h1Vrr +Yjbno3ixUD0A6Hp8VcFCMQvJhl3gTq6+uDy7RLOeYS83eucGK1e9ynaOKgIrAo8tj04azd0cbqtW +3y5uQyau7j4stc6l0UIioeTd5dHqRYotMmxDNpZ1d42TBoXi5mB81S9tEIS7u319MjriWA9BNZwu +WIXpdPfe+sEjkq4iqJPOGDRZoohiMqkiiJVMw3vCiVem3SsVlxnaj8clzZqUGidZxE7G+ViEQjOq +wHic1GXFDsHUQKK90qpujartC1I4yGalv3IH7JiRX00jOoLovFCBHTHzE1Ff0uxZB5hh/d5wdlMy +B9E4K0hNgiliTFG0hwRXzkKdFerF6latd5YVK6rR7o4u5StbdnHNKc+C1iYUMggtSe+Ci0lldF7s +gkVVwyc1+hhVBuCBaO/2D8GcopRPiy0ECwAIVQOM6ghOjRGbcISTrbtZzBHE6mB8sd49D5hh2JOg +vF3rHoNDl5SGqnVA2DG8IBtLqgtKWM2RLsnmSSbvuktOfphMM4kUHUtyixEWxUvguZzSNsuVBdpe +nxytb15BCQtSj1XalNgU1a6qLwlSO5WWVa0eVFat/NALxpozQslaIgWu3Gu2z9j+SiLNY7hBEH4q +bbJcC5aLCAcvKjxfPnfxGZz05uexdFrLEQXdWp5uPJhsPNScrblFPp7SYDviSfFxCxoVJ/ICXzX0 +oV/aVq1lWakXK1OW93DKhDQhmKpqLHvBuulOwU6iOaNa36x3j2E3ZWvMaUvxtIXhRVkewNswzJWE +2mDlYnflCkFXgYVIugK2LptW93euj5f3Bd5TtKpfmjR6e+PN60BoiZS+sMjEEwpH1wS2NneajMUk +TmqDlnZHl01njCBmNMrjhB9UdkxncnoOXVwIOwTCARvGwHTX6r3rTumcXdzjpApGGLxU5IQypKSg +9xkR1KOewUtwvrCk2awcVDaLtSO/dAh4AxUQpYJ0Lg+OlaK9HG5BdWsvX+2t3DTz67K2ZBdWBbUl +KtVO77A/voTR+Rzl5ug8uMWzV1+6/uD9K3tPgVvPogaYUNC0HBUkUmo2F4B2Od7auYvvHs9OHH8y +2bhOc/U0YkHAAIfwcs/Mw2FfGm48JJmqwAftzpbrLdEcwBtEtcNJHd2cmvaE4cqLUZqBYq30FHB5 +9giqfCKrYkS+0TyAUrKwkF1YSMeTHBhwlChhbA2lirCtNOn6+ZGmt2JJQdKXNWcNzEK+vJsjC4mk +AqHV6+0WqxMkJ0PRTCE2QdfzAUDdBmxrLClF45zjLrFcZTHCJdMGRtUFZVypn+v0r1Qah1A+SLLQ +7R/Z+aWwE3hGTWdNim8q5pQWOxRfT6X4yfhCs7WL5CwwXCjmQQzE4qIgNvLeJB42YMSIsBdQhYJT +ZopZLB9LhYN+/OKaX1zPIuZ4/eb5O+8tdY5hoRiuAVEajdI0aTlOF2I+k9EppiYqS15xW5Sb4TNx +GZHn/bXNS+XyMsfaolrLYgVO6nnFLVHqUWQ5EvYP4cqV9c7gCNQ4mZSjUW5+nsKxwC1s2Pk1FLVT +SQFymeOreM5NxEVIbcXocCGZ5KGs02wVyB/NublcXoFMtyeqHRIpLQ5JoK+cCRKEkwXANooqcUJH +d8HAntOcaRbXE2kGp8CztCS5Gk6OUwfgEN3iFpjBweptTuknM4ogVUHKmv0zO8cP9s8/DBrbjNzs +jM5Pdu/Y5c1IkmfYul86krWh4Uxls68Y7bw3Xl69jmJuIila3mq5c6UxuKyYE1bqYVQFxV0mnNNU +wTCVwB1ZW/aKu5P1u/3RVbAGkNrROM/yLTBfrNjoji8NZvehPKnmCMQthwfJlIpidjZnpDOqU9jo +TG60J1d609tB6yRH18HaQK0cTq7ahRlIhGiMOLmvmiuPZ5pA4jvl0vjGnZfg79GkQrINRmiDD8oH +u4XyWVkfAa7gRFE3JrzY46We4azBGyJxbm4uHNrV6h5xUhWFZEEdDPMkuU2xlQwESVJGUW22cbHS +WMugmmYtVdrn8sUtzVhhuG40Ls3N5RYjpCTWFhYwmvH9yuZgevP285/dOPNuy1sB3cCyYm9w5HgA +81C/wmYjcHZZxOCBZIhCNMaEDXnCfuNmNCbNzROxhAj/StMFWQoYSpHlgihXoPAlU2FP71OnMk88 +kYzHeJoM52GlM3wiSZN0IZkyMmkXzIisgnMsRBYZhnIZ2onH8Mg8Hl1kGQ5qaPi8Ko57sjqy89uc +PMxiXgaxObFNshUE90CyJHXJL+0XG2e1/CSZ1ecXKASxcRL8coniw04++dKGpPco1sukyWyKIAhN +VhvgK1vhdzTPLG3cRakK1E2S0gytZBig5MBmTTDdg8n1C3fe6q5fZ40BwIOqdyWlmsMMXu52lq5c +u/P25VsfHqw+ChuFZVXbWVLMZZIpQ+yJ6jKvjGvtS25hGyMK2Yyg6yBWQ0GuwytHBJGYlMzogj5s +Da84/gYv11uDo3xpDcHzoGwYWdKsaaV9sVA9hIXStOrumaeHazdxrswoXdGeMspA0PrLs2uNziHN +Bq47bC2dl/SRbm9IxpSV2qrRqzd3RyuXmPDJvnJQ2S3V9wvlDVgNnK4ACUeiLE2VNaWTSrHg13Kg +imTZ9tZZrq1qy4LUTaZNz1+XlW4iIaG5PMU19fyGXz+uts/TXBm0FA5sMLkkAnmGnQ+b8ZQNZ5TJ +6gThcawfWcRkqVrwl3Wz7QVrYH7DgRRxWpUqpt4FmMxmTZBuUe6xXD2HgQVwoO5HIpSm9zi+FYnw +kFyAHzQXzh3DCD+RYGJRxLbbfnGWTOv/Jez1x6RSoHh8NmOlIdLiwmIEr9bXVtauQrk/dRqHNwBr +UWSFxP10UoJffvp0JpWUM2mToIOFhdzjr01VKL4k26aFLiA6JXRlcwq+L56WeKnterP+8Opw9YFR +3EiiViylk3Q9nQ2bu1KM1+ycObz8en/1gagP4gmCwkSaMhgWYrKoWgMrWFdcqIzLnNhgWJumFJKQ +Gc6T9Y6sd4PKFhhGPViT8lPFnuj2kGJAMw0wy351fffwqZ3j58xgP5N1aKrA8WUUM4GB3cKmbq2q +5syrHEnaJIOA/5V1NZznFYvjCKryYiebdSm6Yvlrlhf2fOaFYqOzTXNF8MKQNZI6bA6uVHqXZWsF +9l1RKrX2nmr1UogmW5PB7Nbm8XMgX53RVUFugcdpNcDDbqeyFi8t1buXd4+fPnflpdn+U4XqDoro +hfxg9+BerbGdQdRwLF1KwYhAM4Y8W6OJfCJOOk6/v3yRlzsUC3IB62axfIeg6nAWsKcALc3mUXtw +Ihsj8HcEXYmHEygEjqu2e0c4BStZh3iTzBWcCYUaID/slh8hOSYvcHmWdcvVTc0e4VQAGsjxUAG1 ++QUinTER1I6BeOKeJHVptok/7kaoad0c5sfiEM/wq0yIojTiwIdSbInlA89fzRfWYUl/44l0PKHC +yi9G+FhcTaNuJgeuoQ5GybKXoapmUjqG+dmMDX/GwnEeTFgFcq5mLCGIE8sYT8yh0SgFQcLyFZDx +Uu3o+OLrx5c/sLLzgultJFIyzZUUQCa5KWjLvLEiW2ul5pX+5Klw3hCq6GZDszpucYOSlyJZbzGm +2vqo2z7rl9ZRTKMYh+arijFahipT3Ull+VgSh7qpmADk4YgiCGlJqjb7R73ZDdEe42w1m8vDaQIv +5QjTtju2N7aLO7DmUBOTKdg1gWFDwaHYeiar0WzFDfbzpTOCskIxxWgMn5tPITldkPrxRNjtlmGr +sMXhvBJ7YJpdgiogqAlBDrtD83VBXfLKh9X2RUmfhVKTFkDtd/efgjDj5CpGF9M5P4v5NFcLKoD3 +ATjfStjB70pv+ajZPRD1XhpzgSUsa6la2dD0djRGA6oBuWFEheYbAEhz8+RihDaNbquzl0XUsKdB +Vhfk7mj11mTtAQBPNCbQdHBw5ikQQJBTkqkxXNvKr9mFNTW8QuXGYqxhD/3KOkq6cxE6mbEwqgYE +KIg9ErdZ0taV6mzzqu6Mkll7bpHD6Wom5yN4yfG3QyhaxE2tXavuP26PI54+nZufxw== + + + kZxH0mUk5ywu0pBZtrdSbh5XWudZoUGQJQg2KPEgszTbSSQNlqnp3maheaRYo/A+oowejwkQSDxd +L/rTaBQPv7Y+lSPxMkkGWTB9qA4kBoUjFd7cYoHmc0KpVNvuDM90ls/2xiduaQbVn6RK0n8+iS+U +a+2z0+1nB9N7tf4VIBbghLChh+jnSFvWl60CgP2m7hw129d6g6uWu5LKivAGUQXz6OGhNavkiLxq +9Df3nj2+/BbUlFg4q1HkxSIJXlXuaN46zjbKzZP28k1G6IBV73a3PX+UydkpsL0ZC7w5wzQb7Yu1 +7lWKbQIJZBGFF1ogXKFHy+hZ1Abo9cvbK9tPITkfxzxeaADqk2wNPBTwA83WeCFsABhL0JBcYDd6 +yyfbZ5+j+M5ClIsleJotWPYSxMDj+zEGELTbZ15e33+WDWfr0ECSteZ2rbkF6OsW1jVnwy2fAdok +mQYk7MIiEc5PUbvRKLO4SGVRN0dWVGvdr5z8541GsRiVzUqiWAJiQXNqDncA4HmuzfNdSIHwThXU +5sEO55wc5kJ+QYTEUyZNe3l/WZCrAFcCVykU1ovVAyjxaM5DsiqR02WppCgBhskCX4QID0prxeqe +oAwwqjo3T8djFInpFOGAgKA5myCLqjbUzHEO86A+njqF8Fyp3tikaXdhkYQaF09ZjDLON641lq/o +Zj+dZHy31xkcg1v8jXdlFyJcNKljdEs0Nmx3O5UA9ssqcn06vTF3OveuJ1KLixzJNE1vDUEtyGKM +cCgmUPS2brTAgYqyj4ejMRQMs2177Je3FKNHMQVF7zj+iBFKcO6wkhgeprOgdgjWF5Wu4axK+opk +zIA2gRwgHiDLZGNoF7ZAgoCW7cJUkMNhtV5pjdf60bQWTYgE6dv5saS0vcJGvX+VkaEWtxAyiKdB +gW2Sr+FMOZqAotyXtBWgApwow+KA7QKUgtiGiAW6iMeZDKpnEEvVJoK0JCoDnK4lkhpFlxDMiyZV +nGlAoVfMVXBwEGPhlJkoBiHEckUQXoL2abHPygPJmDil7VhKmgtnIIpgalAcnH4gKH0IdUFqNrtn +/PKOpHUJ3AY7BgAPviyRNhdjQjpjgDzK2gr4/cVFIh6j40khnbUYvquaa9G4msroKOYQ4fWEYiJO +ZdI82CKgRF7qgCECuAVJQbECOA6wD8ClOFVV9Em1dRnWH9jj8RgvfnV8Ui5OcqiaSkogj1jOxB+/ +4tEcjQnL3fUPffC3ZKkYT4jxhJzM2LwMIeSjSNiGIpmkDKsvCNVEQoSjjcUAzCSAKJoOh2In4jRY +PJKqsWKPlQY5oh6J0GH/tDgt8j7LlZ44jUZjouHMFGfVK+/KxnQxqrzrCRSYjWPDKySJhOC4I82c +guqm0qHtgmyiGU8Qa05+woClJaF06v/ZOQHHLFlpG9bILUxBbUS5LqplFNfj4fg8jqYr4fgYuUlz +BSAuPhzR25KMUQ4Lwj48UtfMz5Y37q3sPGMH27D1nFiBTUQg5DA7g+azeInhO6YzdYNVReta9kg1 +xynUwpkqAlIsdC1/X3HWoWYBmdBsnRXCm/rCeyCTGlibLFJQwlu/yvNz2VgE5wUgZ4VmWihWjsbh +CA2MKEJAZnIB/AivLNNCn5OXElnz1AJxehGPJ3mWLedQncB0yE3JGGvOKqcuoVQplhJTWQ0DVOZr +UL8ggHVr6pWP8v726sYDL9gA3pO4ANIQpC+csgrFhWk63ubS5LaorqQzTiTCpNNKMiVHHt+WzApd +imtp1qpmwb+qCwtEMiniZB4jvVhSymJ5sLpgMGVtbOc3wIrOR8Ie8hgekHRR0cEsr0bDkaYST5WK +hRWGcmC7k3Eu7N6c4KMROhrhMinRkMsVf9RuzuKxsBFWOF+D8MEyw3ItLoI6JbNZxfU3YDcXFwiS +8EEZwMCSVDGTsebm0NOnkhRhs1wzlTHjcTkJOJFUkmAew5luJoTiwgLDMpVm+wCEKJmS4D/nF3gE +LVB0HfZiYYEN/OXnX/mY541PncqdPs3jVAlBjVSaD7vQ4OHTEATuQlQnkuAZbZLME6TLCUVFawpS +naJ9IxxYuQZIFl5yCTt4WDncziByOiNhmElQ4b0EGcQkyLyqD/zqbqW179c2BbVF0LD+hWRajicE +sMMUVcbJGs0DTg8gPHCqEM4sy4RXESutS3Zwxioca84uzcMP+hjmkLQPRRz+4np7ur0tysvwAi+f +zCgL8xiSVmQR8FiRlWXd2KDZHuibbq9q5loacXkugJxCcnkECygegq2C0w3TnpnWahqiETen03Os +UAH8oIUByYeT63V7wEv1LAoujxKlpu2uouH0cwiGYiIFPoiAuoYTZiLJEqQNxQ4n4XTKEMMLESEa +U3CiYphTyDugrERCzmEFWBacquRwKHDCYlQg6LpfOXT9dZLyLl1/cXP/SYJp5PASwdZTqBtJhN4W +J4NEqHsSZBzNdYEE0IwejTCnTiNzcyTH1kCLIITCW9TJqqmNDG1IUaVI2KmPiIcT94SFhWxkAQdV +QQk4vApoC8s3kyljbg7vdA4gT6FcgsVbWORSCZnCHV1twG941xPZJ06h2awFqhhZ5OfnyAi8IWVx +bEuRO1C15xewaJQGmgIqA9ZF0XwyqWcymu8N+/1DFHUXFyWGXwqNHuIkM2Yml08g5lyUXoDVSEoc +27DzK6ISmiNApkQ4C4YhSQuKl185Y3t7JFOnmSpBFWMJ6fR8bn6RSqWNHF4AmwyrgWJq2FmI9Ciu +TtBgb6sMX01kNfjlYHywnIsgkNQshltMOBG7abmTcDwNXYRDtbw11RoDIIX9z+WWbi+7hQ2CrUTC +IVwimKawSxLmQCqRBBifWj78Hm0IQR6LcXCCFLgkDAqlRzNlhqlCTTTNIc2UwnlkKcOvntWdLVFZ +NqwJQVWgPIlsUCiMEikRxfNWfkN31uGz4CxSWX0+SgCIElQVx33QGYCHRNJOpBxI1WhMXlikkinB +9ZZIJphbwGNxmZeXNRvgYWY4a2DHIo/bM2ZRBz56Mc4CEvNi3yisNfrhxRDgWEhny2jee/LN2cYl +8H050C6+TbANlPAlAAxrlE7rFOU6hUkkykeiLOQOgFCOrMvGhpnfXVggeSpY6p1DEQMCKZ4CwNDi +adsp7g0mN2S1PT+XIVAzh5iQzrDswN4AV6fnmQwSqNYayODCAp3NOHB2sKqwFCThhPeUIrbprgbV +w2iUT8QVeKFZWOchBHMmbQBuReMCeDrgqCeeyESjAoK6gtCC6sYwlXQYt8CZIsM2Myg4uB5ON+GF +0fV4xogn5fByNFMFLkLxAsO2VB0Mchn8BYY74E8luV+qHlv5zWyumMp4iVQ+iwSRmBxPaoATCOAE +VeSERnjDNlWA3w90Hd6ASniOv8lJXYDbDHxKHAKYwDAlLLu4xUpV1V6qto690h4efrlmg0KyTKFY +mjY7h25pJ0eV4P9LcosiPaAjgFKBDSjSYhkzHBmDGQCl4ZdNpIcgWizKQGU39L7AV0nSY/lajixl +sQCqMEYFcJCpjMKwRThO1VwCXGS4BgQAw1UUvZ/FwDKYwMD50r7hrUG0kEz78QhIkJECECZkEEgi +Jy7Bb8uRBVHrxVLKu96VAAE0rRWGq4EBjMRADSiQnfbgYmd4GYI2g2iuN4MjBCUk6EI0zgNUON5K +b3RxuvcQzDKcXbl2BigxjViJtAZxAuK2sMhSlK8a7fhjX/k4++ogv1kU6I5fXCQRiHyisLiAAd0l +sxZKAHK0NXuFeDxTG2wFC447Y4DCcDzQch/HawAMEOEME150iixS6aR+eg5JQkryDbe4Ywe7u+df +ufno037p4NQpHNQMXgvzFIAZ6FssBjBWKVX2K80jNryhmu8PTmSln05bkbgSSVlZvKDbS2tbt198 +48thh0PUyyAAq3XT2WL5LgQhJAsEUg734CxYFvB1GXIhlYHFr7FCjQrHqdTB7sWSBk41BXkqyiux +hB7edJHSMogOXCTKA9Ac0Aqar2VQO42EF9C80iYnw++HDYJiahIE5Av8RcnlNFYsK9agP7mh2SBQ +dUao47hDEybPugwLhSz87sYrblrONItYmYzCcxWW8VNpdnExCXSaSkuwKdXWWZCCZFqBdKPDh3H8 +VJIDGsHxvKj0bX9Hc2cgDrGEABsNoZVGVJItoUQQco4JgjNSjCG8Ibz7Qm7lS9tmfg0qFyQdoBQn +DMC7pdNQaBhB7BRKRxRXw+mAlTuLCeWJ09lMSub5SiLBxqJENILD53J8I6jsm87K43HMpl+e8iKQ +qkGDLuFlqPUADJOtOxtHT7sBRF19eXwFcgeCXNKXKK4J6YzjJbDzqbQIXpjjq6LUBoqDOAGKyyJ2 +Di9iRAAUdOpUamEBh8KxGOWjcTGDmmH6ZE0wAra3gWEe4LqijAmyjoabq8Xj3Nzp5NxcJpVQMDQA ++cWoolc5mB2+0J7cqnbPA1vGYuoTT0BZDB8NAOuXTqksV9XNcbl6BAYTqj84DqCy8fSGYY5icSWF +5Hlrozu9de2p9z/1/AcuXHomkdEQ1AGcA1/D8i0QGQiqx9NFu6zYwmmod8piTI6Gw+M8sMOQXHDM +YN9QwgPlRB5ft0+GpdCDmCSpEqBRGtHRnAs1ywhHbByQTCWR1gkqiKfERBoKZYkgmyTdgtzPEeUs +AgHm0eE32hYoG0bVSo0zpdYxZPrj89KA4tJZBXQmgxipDAhUhReHvNAF9QAfF4lgJOHmwom3sJIV +GnyBu+lXLhBEEIPiPp/DwrrpIDkdpwsEV6HFDi8PGb6VyiqxOBXOjTKWat3zxfZZkmsiuB9e6Miq +OOViZHhXG9hJ8BHl1uVK6zKC5ecXctEom8PySM5IJHkgh2zOZ0QIyIAgYZe106cz0QiRCh9YoMIH +2WiQkQr8ICNUJLWBYAYrlLzioW5vavZEUOrggFAyD1IpSg23sJJMS5msoZorgtoF0cukrWiEX1jE +EwmOJPLgCk8/kYSizwsNhm0kM+5CFMiNC4kuBViCnZ7LAejihEdSgFUdimlguPd4KivIjjQ/j8Vj +fCqlxRNhk0MwRwRekaQR7A4ntUW1TzJQhrTTC9TcgojkKixfNUyoy51IBJbR4rgKirlQUucjPEb5 +rNTkxK5mjEF/QL6A5TRzphlLYV963I7H2BTiYUSVIKvRMIR4eCVSqiC2wO+ANgpmeL0olgBG4hYi +gFs6xXY4ZcyIfYprw0akAPYQBwIynTVjCRleUO9IOuzxi6B6Ki1kUSn7OInC58VIH0IR/DhYOSDb +av3c+tGrjcltwFcAYIicHAY/W8DpPCs1guZ5w9/l1H6OKoLMxgEz4iIsCBQ+gOFcrswJE1HZ0KwN +FA/Ff34RJakgKB24hV1OGqayLoIXwQU71jLHlYDxwJYWKzuF6jGClxNpM5vLA2bn/U1F6wD4wb8K +UntpcmN99yEjNZOIlsjKnAS2tAO1Cc4OJ0uGu237h4IyhmydX0BjcRroC0QGcgQ+Dg== + + + VpLm+xhVB9gTuDLoDIa5hjXoLp/x6/sE28sgfiQmgK1j2NLjwdlCOiNIcrfavlDvXax3T7JYAcIg +HhdAdSGcQIiiESGZNHmpgeTMGBS4eSxs+Yi5aNimL7uwQEWiEse3g/p+ImvML5KLUQpEO5MFr8TB ++8PLVqfx9OPEh2SH8poKr58XaLb62I8Y0biSTDsoXjLdNTjTuXkSbGO+sO36+1I49kIFvl2I4NFw +ToeXjPGnTmUTCTXvr63t3woa6yhVTSP5VMZIZ2xFWwqn+qIOJw+C2pl2/1YGBfNSyRF1FC+G9T3G +LUZhTfJBsN1dujGcPQwaF6MJdX6RDQ8sbaZB1rA8SpY5aaxaM82eMnwTtDEEgwgXT4Jn9EVpAqj2 +uLt+SI+RGPt4pI4CigfOOkeWcwTkeEFRurYbDruHUiurk7y/I8k9MKQZRGK4ou6OcL5O8A2jsLm0 +8Ywd7IffykWocLh2Rha4pm6sgpVgpT4nDVi+LUodFAl7jMfifDQmgAJb+VVR7T3+wr2EYkVB7IJN +SGbtNFpguE6ldbHUOAdBCIITNhymANWqpt0r1nc4tefXD1vLV1rLNxihD0kNW+O4s6B6hNPtDFqi +mBrFwFnkM2g41ieLwO73Ku2T1f0XRGuaSIU4geaAB2o0F9C8Z+SHvDrGiPDCCKQVJNdiBHxceH0g +bIGuNiStLypLgEA006CpWjQqzi8QiYSUzdjhn4gBiQniz4ltim4kkhqo06knEiwV4GFBNCHBgTS8 +0lalfgiCFk+Q6Qxv2T3LHj9xKgvij+ScWFrP5sCiFsNLuwuPe2BSVUFaktURfC7FQBXIx2Iazw/A +ZcfBms2h8E5YqzQaQPmLJ4zFRW5uLoemNYb2wi818AItDWuDG6P1B3kQAajgmAt43xyc1+0RFP0I +SEE2z/BDURuD+MSSEkRCLue67igIVoPyDqztYlSNJQzQLtCW+QgZT8sIEcjGzCnuyPaY4BoYnG/G +eYzxxmOLkcdJEOQuitfS2fxCNJxzBKJEsWXdnWruupHfYLg6hueBEzJIuAusAGDcAzkCEWa5Mkl7 +yawMkgv5OJzdXD/3sqCPIHrnF8hYeAUvoCgvFV7H4KHWKMYUpFiU+ouLYLQJsOSptIIRFs2V0ogB +miaF11HBJDaSKQ1kk2RbFNuU1AGCB+C2WHGJEzvgGigGgD/QnVHQ2F3debCy86Rd3MnkSom0Bewq +ip3HV6JqnLTseBuysYxSRfC8kVC7DEXtGIBq5jJK17J4kWQaqg4f2sti4JKK9d4+I7QTST2e0GNJ +naCbYE5Doc7oi4s5BFVtd8mwxpIGxSVIJMHQ6dmsI///7L3Zj1xZmh/2bovFzNgj7r7vN+4a+77v +ua/MlUzuLBaLLLLIqu7qrt6nu2dGs2g00kj2yJItGTYwMAzYgAXID7YBPxj2g/8g+3eiLFkSbEAP +BpwQ8nZ0VmYw4sY95/u+33Luyfz8Ld/fzhNDXfXDXdvbkvQ+w9SSKTuZMlgmtLQeTXmk3Q88Xf24 +3b8KS/sQz3na8YNFr3/lFaf37uUgRL1oVWpeuOGpZo4oKtjcFHN5N4oPTGvMMAFNx1CSFiAX/Oju +2M4ScJfNmDxfgepIAzEKASejPLscWxLZWIB3UNu2t6p2rjuTZ1FpW9P6MqGScrm6PVveMLQHRIUZ +YYS6bI7zbDmdcwtsiWLLmtrlhVCQQjC1pi8kec6y7TxVzlFBKqsJSlNc79ajxZJkDKqdm+XJL+vj +l5A6yCtQD6oyjA57w9dOeLK+/1IBmqFwgOrrFvNjw91CuKHlCDLLjXzBzRVcpKWsdSsN8svXFBOh +uofTx73pmR10Jb0F0A7L5yAjUSppWj1P2bmCadtdvBdEnyULyz5ZzeYr1eqBpNcsp7k8+Nwrw3BV +RaVDftM86+Qp3/HnmgWVEtNcDAFv+VtB+ZhILxZ14WPUttv3wq7ttgWlDtKf73yKa1cI+rrVkWO6 +E0lr0nzECKWwtndw9vXW4buotDT0OtSI4866k6eSTgqqQFdgc0x32Z8+K9WAA04BAputIDl1ZyWb +kzyDCYdS0lStGUYL2B/NnAEVLXd3sfPRD/chgEWxkclCZXUMYyyIsNs1lqsr6kzRFrazRVHhxiaX +zZma3s/mi7BRvNxtjh5W+s+a/ReaMdlMyJubEmYe5kvRexRfwxlQVl546IAglA5MQSIl82ITrKqo +PYqObX/f9AEyTdAoS0fAzFzWXqvxbibjpFNmvgA9Q+77Q0hISo1mgkRSgn/U9bFlT8jtDwFI69eq +hzxkHuXk+TjHxDRfQxXL6jSMjmkmVNSWjkzQutl8mEg5uRwote6Fu2HtSNRarFQmvz5gTbvDZ1sn +35Tal9AbZB8LVyJRE8oCZBXf1O19q3hiOFuKDoERrddg21HpZOcYmHAJUQ0ZloHAY6DDYcmRYx6U +fLl+0xm89krbLNkGZrFcICot2ejRfJzJaRQbucGu4Uwlpb6REMiOoxzpoQbGBzXQGBpfQYF7pQPJ +HCTSBsfXUXe5fCiIDRhAEJykDUr1S1j1ZNYECPvRblh+AL3hhQun2OeEwLW7pdIWWZdwJplCkEjb +mbwHqFGNXoF1MwUrLG8t914cX31c79+201kIUd91prXGCSdU4GiCcK9UOY2rp26wjfy5fz9XKDiq +DgMbUXzF9A7KzefdyTvTXZD7VrSfSIoUXUTIZKKCvCS0dFIGzNruwnImFBMA4evNU/i7zaSezgUF +traZthAaKFvP3y6S3SnHMMg0XypwzVQ+TmZDUZ60+k+rjUP4C5YNwFM7Rx8un/5BvX0BL5ZI6YmU +yXJVoCsxa1lXM8dP3/3V9OAbxZom03YqaejGqNG8gsr9W/9h5rP7nCC2ty5+s336bdFf4jrBOJgH +zewgsbP5AFJBVFe1zquXH/6jsHSuO7M8h4upAFtoAVYFumsi63NUhx8uDbtVoA1EPJsLOaZlW9vD +6Uvdm2ZpNy6tDh58YqWmqHYEvZWDhuHbkG2oU0XvkK7QfAmatt3/cjD9Oqo+gNyFBOK52IaHjVZu +gJOUElko5LbrntTqL+ziQSoN8VnEAOvdJ1HtilfbGdrLrPeEkNlOS8mUzHGlsPSg0nqEK89RbiKl +EKPNRJCg0KWqPau0H+6e/mK887Ud7ufwEUlDltqZjJtIkLsnmFJWaHjR0eWzPx4uvizAJZm9auus +XL+yi1uwh+m8nc67mj7wSSPmEPaBrIYp3XLtQbmOiHTIOgxPcEDWWrxcZQT8WOOljiC1ZKVJrFDW +oln4qRFEPsWE+DGbszgu1vW+ZQ/JxmOz74YHte6TUv0MLJkkS+JQ70Uof5omfwoJcj2VVDi+4rqw +6iu4v3QW8smP4i2I82RS043F4uhbv3JimCtFGWJOguKo29nlOHtjkxGUkeEcxvUng8l7011l8tbm +phBHy5PLj6oJK2F9timksq5d3IFaBlbApENWBeT3qvYcb57OmahHRugq2mQwfr1z9B3L1+5/RlZH +4WVkcwBZsrEhwQIgbRQDs3cMg5aDvO8+wqyOV+/88mkqG/0f/54cV/9/X8D/V8fdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HVf/278nx4r/9+T4W4oyfH0zuP7q+t7x5J7SncaX+Hn3+t1Xj9/eW91TLovdt18Nnj/66vkX +r6/ffuJreMpzg4gv7j6+fsXrP7ySx4v4rbfPnz5/jSf3Hl2/emzwNl5ax//vebzPe+v/HX+651S8 +cuCG5XJQCnw/jip8xauEbhTGcbkcVoO4wn/+//iiqOwGXrVcLlXKlbDEvyIv+uG5qudV4pIX8P/y +XX5Y9iuRH/2/vOjf+rhX/y7X9Ores3tH917f27lX5XWDPz66d/CvfYd5q5B56719/+7Z9vVXmJLX +PzzZe4w5+Tee1g9ev77+/PENv36Wx9N8EJQMzFIX/z/+mnzz+N77f3PWPH6Gb17gqa953+OX/INz +j78hr98lV1+J+PWX9cyFsVsu/fDz4l//+Yf/Lv7V6//tn9evf/1/fzz+8+W/ugqfXMU6PUbPXz2u +/fDtenD/V65gKnA143vFweMPzx893h33+OPVvQd40lnnyw9f8dN6ruP4h0hE/DkfeD7GVCJvf/bv +9AZyPf/yTf/yvxU+xDX65fXlRjx5o3dPUdZXSLK7xpcQSP/e8fQ/4EXSjoXhAkmpy2pTJv1m6jTb +EOSBYowEqc1xpOuAINVsZ6oZA0XvMHwpz/h4FyuUOLFK+kOzvqrWDKvnhTPLI73HZLxX7WvWosAE +maycyYhUwSRNs6y+5S2N4kq1ZqLRY8RyjnKL/sh0uixfMayZW9wO4iNJH7JcQzYmvNSimThfKHJi +Q1R7stYrRtus3EhmjAITsWKVYrxc3mHZkmmNwvjAKM5ko1tgfFYss2Io69UcY4tazSvtBdXzcvuJ +Fezh7QUuyjOBH+5WOldB7cQvH8b1S8NdCVonz/qS2hZkTEKUzduZrM6wLicEslKV1Homp+OzOL6e +o4I8HRbYmCfN6nqC3FC0jiA1WKFZLp/54SErtnN0kM7ZmbxDMb7tTg1rmKecfMFWtZ5ujEiDwAJp +10Qzga51q9VjmotY0i6rk8laiaSMf6WokKLxiCVlIGlDXurxUidFGh0V8STDVli2IitdUWpRdMQL +jTwVkL+1zcY0UypQQYH2Na1vGiPSTIgupXPuZlLGI5XWMxkMJBCFsoQEKBRzOZNlvFRK2kxw6ayW +K7gFOsgXQo5vclwNZ8vmcOVFUWlRTJhKS/m8i4tMpTSajgWxw/FtSeqr+kg3+oPBRVxdFiiD4Sqa +MXbDlW4PcwUnlzVoKsIJRXXAis1sIcjmXFluFYsLxx6zTOR5c1lrU1yIlGC4kqKPVGMsSRXX6WZz +Oh5ITtvdVs2FoCC7xkhO0qpcrOTzFieUbG8RNx44IWksyqu9Ah9zQvXs/LtW/5wVYoaLTXtVaTz3 +SxeC3KfYUoG0YPcKdDFPuXmqiPGSrsZKj2IrFFvO5OxU2sBl4wWk65LapPkyJzVMZ1GqXXX6j7cO +33BKRHFF3R57lZP64HlQOxeNiagNEJGjw2+mW69pqZItuKa71R68LjdvRG0saCOaq+QLLqaRYWPS +YDJnJVJKruCR5uKFYjKF6KgUE/FIeKXFY8L5Ks3VKLbGCE1OrpMGpWIbc4gMxMvwxg== + + + POUhUdMZlfSOJZ1B/XzByWatQq5IFTwkGBKJZcq10lEp3k8m5WRCymSMZErZTAgIIgbLCm1JGbN8 +l2ZbmjrX9Vkma5OGH2xJEJsIGQCBZoEPQ6e4xfDxRpK/v8kgOYEppjk19AmKhZwtY+Xz5G+1b2wy +qaTA0oEodiS5y3PlRFLCZTBMlM5o2ZyBXMoXomTazeWDAkUaaEnGlABLzsAoUpiElMIwJc8/DMIT +3z9S1H65tP/h67/YPfn8s/tZw56R/pGdS9kYkD+SjiKiSUeQTN4if/U7j+mNreLEtIcCMlyo7u29 +tb1JlnKTWU0Q6qXqZVA+E8QqLwTZrL7u/DQBwtB8rcDVBGVgu1tR+Ug3hwxdtO1BuXFshzNRb4ha +FzOvmuNisD1fvioGC5aPkZauv+eEB6I2pOgKJzZpjuTb+i+nyxmMiC6iADkBtVMXxB6QTRA6LF/K +FSzSzUWtIecZsVoM9gezD5Pt993ZY0aORLVmeRPTn+n+XNCHXnzSGbyo1B+Mxk/KjUMgMMvGdnHh +lw90Z85KXV7BEDosVwW8kO6wGR1QkM7YLN9Y9y22EaB0xmA50gYgU3DTlF9AWLkuJwxs/4hTGumc +hnk2nFU276Uy5kZCBc7QTFSggGAeYIqiyddCvphJ66mkkk4hlE4h71nmUFW7yKhkUkkl1R9avCdT +Uq5QZIWGbi5ldS6rU9veM81VvoCsaFKkRVOFZhCCHit0DWsVlc54ubGR5FJpmWFJqzNBbLBsGVCA +y153wA02NlikVjarMbTP8x2GA4TGhUIkin1d60tSVVPrKIRE2kplfKA0S3qr12ihTwO0uQinTSQF +gnVsWVG6eAEvgPI6bnGr3X/iRPPP7uc0uxeUSPsEijSIagINGK6aWRMBygozwIs4YZkiIS7bxmCx +fC5rzTztcUJFJh1ZJoyAmbQAIDxfsayR481oNlaMDq80BaXDoq7lzrqnrx2Gq/bg2g3nfjy3gqmo +dTR7bHoLfBXkFifUK5VDyxunclo6ZzJMRdOnvNBCQIEhpBsEBfhC+duZnJsrlCR5iKlWNNK9CXMr +iHVRrqt6R7MGsk7aAxRLx1awzckNP973oi3VHtjeWLa7pcbFcudTe/gc848aAZjY5gCImkjJSCHT +WlQbjxEd015oep8XaoAd0lSg4AK7UhkDOUDTJRAQxwOmYrBeAZHl2yzfl5S5F12hZCg2CoI93Vmm +c04ybSbTFtgKJwHo0WwAFuPFJuo9n3OBTrmsjQfJsZRCg9f42roHkp5KW9msg0y4v8mte7NFstrP +FvxMFldSzOYAoSVZ7WG2QYikvRmAkfIYvi4qY8QRmCZJDZqxgT9I7DwFOAqBkBxolIk3N6VM2kqn +tY0NvlAoK+qIA97yrXw+ksRW4M+L7iiRknDx6Szhvlweud1SjO1ieGC7c4DbZkJMp1Vg12aCTSQE +ga80aie6NWXEVibvoiIoRl+3je8gRrq9YoQWzZH+2RADqtqgKINlfV5qyvrEdneKPkLZYrkQ5NgZ +PKPZMmIN1iCtPlTS/g3nQXFZ9jyq7kPtJDIaQA9gq2pD5LZdnJnupBzv/fInf3X88BMjxbQQSjok +2dwLD0qV01rzXNa7ZBQ4MxWyXEvRFqZ7aDoHurWNl7FcWZXrljvLUhHIOleIMJOGNdethWLOomj/ +8Ojr7uAqR5P+626wV209rHUeVzs3tr8I/NU3X/2pV1+k8hZFGs61MVeQB4YxhrxZqxQb5CKue8vh +zHjkCRFA/9QYvrqZZDKkL1pIkbJtpDJOLh9TdNU0J7rZ3UwBW8xcoaro26azZzrbsjZet6uBYENo +zExGIU2t0ko2b/FgFqmNCDJ0KZfzcjmQi5LJaCAgImDSRiKppTMOcBKpBQYBZKUAICnx/kYBGiyd +NrPZYqEQACgQAuQMaDGRllM5g2JDJK1uLiQFRdHEtKOieR6Z08XJgTOgvGRSSyb1XM5n6WoWo8jY +DB0mkwJAbGNTBG3h9TQdbBK0VGmIPQp8ZHMCpqXKCnVFH2PSRKkLDcbQwC4ebywU8K5SKqttprXN +lI7R9btP0lkZuhSagbR44SsM39TMVVy5jMsXjjPWlLhaXkWVfVHtIMEgmwWlZtujauW42rrMFXzD +6Kh6G3KRqA55IKljw9quNm/CCnRsGbLE8eaC3BQJKDUdbyuuHQ/Gj9++/5PZ3nNWKilmX3cXurOA +ZfihDZug9JDkADrUhaL1LXdpOitZHenmDFxpOcv59NV4+UWWinNUzIttTR8Y5hjv1cxJGO61W+eW +O6F50gpalNvQgX58XGleG+7cj3Zev/l9uX2IhM/TAbBONSdQ7EBU6GEgQIGO8T0og6ED0pvZGAGX +CJXwTV7sZHN2loRbxSOTAZ4DK3qAzXKFtFJOplXkCc1UCkyV9GXh6oLUk+QexzULhRL+dTPJpzMy +tGih4AKXdG2gyB1ZamvqsEDFwCgKrEoFyZSRyZKmgJmMiRxLpw1EluOr2bwDdkskuELBT6XMzU0w +pkbRICPULERyEcTBgra4GjJNEJrEf/ENpBkJDV+TpBY0M84J/YZz4vqRWhBdaeh54FJaJ+o9rSYS +CtKJ0HFK/QGpkD+C0AA9Wc4CUg3yHjmG0yKgLFfKZkxoNpyQNAJn/AQmga/yUkNWkYdhOqOQtrgA +Sb5KYqHPK/XHzf5L213Jct1Qa7PJo+7wihMrktqRtY7hDP1wWW+emsVJKmOZ1kA3+9B4YXRQ9I+K +3glq1vYPBAX55ilSo94+yVEO1LggturNm/7k5Xjr9Wj7leaPFKPbGz31Sgc5przu9dL2ooOoehHX +LjVzhkvSzQFpm0qFBQZg0vTCvaj8oD9+FVRPcnSdhdYSagIZCCC3Z7kL054RR8lVMbGq3oPsZ4Wq +Hx0MZ6+L8b4dbFXbJ4xQTpMarEHFwYmAecEjkPSy3McHgTiSKU0W60G4BfOLlEBEIO1Me1tWBoUs +qnuNPFkHEWdI36aOpE7xFcKYZ2uYh82kkkzroC1cG37M56HNqqk0aZKUTCNkUoEqwoMj1lCqhjYq +RUeqOsrm4aOdtSNrID2yGZgpL5uz8JZcHmYNHjnM5YnaJ62OM5DEbg6cmHWg/Nm1WgA8SkoPQYdf +QCYY5gRfIZDwIz7ItKagD5A4GDCbsSgqSqWMREIEjhFRl9KBhFSBtMwhqJiBHQMXmykkWMbABzF0 +GbkEUccxJU3ppbLIKAHZmNgU8wUPdAxRCtpNZjRMGs16ySTz2WdZKFgBkrvgSxLws0/K3xpxUi1P +SDk2tW67c+GGS5zWtOfQ3pxclrSq7bYVDZzlk7WC6ACKt1x5oBpTWGOKrabzIc3WoGM9b8twRpmC +yUvIzJbpTFSzr9ojVmkzUt2L90eLN15pjwI4aANeQd7OnWDfLO5o1hJ2G6/PQ5xwJWRCgQk0c2p7 +h6q1zSkjHl5J6kLJAGzXbWhrBTpE8WbzEDN129kjHRYLFvAEZI3xQnGxpANuU5DbjruKyyd5JsjT +Rch+ivQqhsAGpxiQFoigqnR9f0mhDBMCtDfOvzbdQRbiJ42g+3B2ABB85YW2bu6q2hLWm2cbaVLF +pFUtankzAYPGZnM+TTWgkEnQC6TTPPws0hWIhMRYz3mX5eqZnA/thCSR5R6UOc9Gutyk6eLGJoVs +RF7RdIWiwFMVEDRNxTrMdd66v5FPkT7BQDyPIwUFXYo0swxjapgzRAccCs1MdP66ZSOeSSYlXDY+ +ggyBcBmHBwCwkI8oqoR8w4VBYIP6CXWmNdItNWNBtqEiQLuNyv7J/lebKemz+xROxTEVC2rZbjGs +Qy4mDU53Eknm/mepVIIBrBVQIBkDMhIKE+HI5nU4fYhqQx9Z5sSwhggr7LNuTXi1kcmrrOBLclk3 +WsArv3RourMcXVStCcWXU6R/VRkJ5ocHQbyvGv1MwYZdYoQS+DHPeIxYhoNTzVml+aQYHWv2lBZK +XriDNEOsSQ9sbRRVrxuDl4a/wymkOS7yihErWdrFu+zg1PROdWSO3M4zyCUvjPbdYAu+g/i4nIXC +BCvh4vEjIoVqBTnCXar6IKicWv6uQPrHk+56cHaGNdLdeZb2N9MKnpGVDqoPcyWSrtJVJBvPVvAR +myQEBQQRiogqFHk2Rj0i4ihtIHOuYGNKkS2IO8OgJEvImc2ERIQ3UIsqgmETRLfo4BeimtIGkA2s +Cgbk+EqeeMaQMC9pkYt8gxWF0FKRV/mClU5JmgJz1F8zNcZobSbUXLaImMKdbWxkWcYXhWqe9D8r +JkGgBGQsWepZzjYwmbBwVv+hrzDpeEqH8LaAKaTK/Y1cIski8WB4ORbUpqOOYEgBXwRtxIoDs8zX +16sf/H3SO1zFWDihDKNE+j4yvqJUszklkaQSiXwyQeVztiK3bWvEsi6VU127A4UJyM3nHaL3xEoG +acC6klxBsMDvZHJgrrMGWXwzhqLWzhdM0+nxcgXPkIUaCNQCgY5S7Vq3Z1AFfmkrzziY8Oy6P24O +qlUo+dG2669MexDV90W9w8stWR/Ck+aQCXylUr+qth8yAhi5WWlde+UTxZrCduVI59F2EB+H9ROA +HnSaVpxmaY/0NM2QfnJgQz/YBdJiCIbVRxpAqxD1mytSVOgVd8qVU0lrUwWn1jwygkE6r6RyZhpD +owlX9gZPe7MvRXPEcLEfbbEieAdqRIXiRShBW3Gwr+uDZFrM5VSOCxNJDpWOcCMBSMdWLi4woFSR +Zn24yHwhgLQGW6VSVjKFeDVg0HJ5M0seZFksS9QLycPNhIwXK8oIIgGOg2L9HGUjiBsbRPBks6An +heejfM4U+SiOpgUGQAfX4K9hrV3IB7kskNNMJnlRqDBUEcAFzioUQoo06C2R7ptkRRfzU8KnpzJK +OquRpvJpXJgGhoJ8SqUxCoWi3bXEEjY2GOAwMGrtEWzHnnzx9s/I4tgmnU5LkHl4EnkLKkzj5AW/ +2TxqtXeRVLkMJ/GuxIewn+tsKQKpeK7U6jyAF4MbRd6uEc9Lk/bGrm3110sraibtUIWAJu2iY1lp +kaUnsTqYPJSN5kZCTMF7EknsSWq31rxS9IFtjU+uf5TKyWSNi4GPLgtCVdXaSC3THjVr+4eXnzR3 +mFonBiBaEFpFb3+6+lTvPWHFhqJ2iqXdAh/laB/MJUHGF7eqrUd+9TgOlo+ffh/UVvcT7BqfSddz +FKNhLgW5Bzvf6l5DPyeTBjQDfsS/WvYMNpk0queqk8VzySxvbOaAFUgqQKistcaLl+PtL1V77JiD +5fazLG1ubOY3NxleqJA2olKr6C5BWCgTXowZ1l/Tk5AlkEJ8MbKdEyKKttwAuO39sNC9mYDXg8Nt +aNBgHIRQaNkDUa7f32A2Nmj4dPDImnTKqjYTiH4IC6yXykhrPFGBOXBbQEhUOuSWY/XC0iyV09bL +YjAaEHgBIamUmc/aIl9xrBGNFOJjRWnD1gFISTduEBmImwlbrVNBqgC7UBFIRYau5g== + + + 1kUHcY6MkoTQNJBjSC0RgJxOQXSRN4LW4Sh3Dr7MFPR0UuBpHwYE2LW5SS4+kwW5VOLynuuNU0mG +ZyxJKNIFOAv4FFMQa4Y5BNzJWh8yKQ0yzRjJJPyLRSMQYkXT24B0UHA24zLIECEihUmysRJ4253h +taQ2APIMWf1DgftrwVyiyHrp8OjymyxtCUJZ07qiWAeO8WKN5UssH7bqe9fPf+GE8wyRozFqR9dG +TnFVbj6QjX52zeay1U0VTFGplSp7rFinYYT5qqT1xqPr73/5Hw9nV/hcSWhwwLSCixQVpYnlHhj2 +Kqie01IXdszUodCAtOD3CJ8LHavKXddf5mgbM6wR4dQo0A7FusBeTq5yYrnfOPrlr/4BxbmbmzTH +ekG0ANIiRokkaseCVCv6U1geYA7DejTtMGwIUsCZMXDfnT1/+3uKh1uX1vekfHxlmBLoD1AThPPL +6x8PJjfglM1NKp0WkAkgl0RKBfYiRpLSAjhA14FPgTbQxqmkkEjwUHSmNiy6U1lrJLM6GBM4uZEQ +wCAgZVWqq1LD1HvF4pTn4tCf5Qs2YGdjg8ph4EQnl1CnUWlHVqs/wGAmo6ztoUp8Iuib8S2zYVud +dZdxSESSOUgwCEI8ECBM4GaCgaOxjTHg8bN76cQmTg4z2AbYwjXAQiaTQo5IKQUfje9pKgJ2rW8i +GDQLrWtvJHhgFJiR40osnDgTw60kkiSBUwS4VJYLWDbU1E65dKi7M4h80j2U9grkjpjF8BGSSlbb +hj2ChVT0LsOXi/7Sr+wJMsx7XVZbvFSVlLrnTyWtlcyBzmwiuXM2aZ8Mhsrp4GJFbWGecX5aqAhy +A2CYyuLkFae4rHcuS51rK9xl5Wa24AJ4iRnP6amcIchNuFFe7Mj6nObbRe+w6O9CXGULJuKFK8S8 +ZbJwWyGRyvliJo+EYTcTFL5yuM5gL64exuVFtb4FkQOFoyOUaSaRpPEjpsI057I6EhX4zQBSmWa8 +TE4l1QT/q7WQqGF4VO1epcgtJw0FlUxiklHdfCol5HKGanQtbyZrPbL6RNnZjJxOiwgEok+TFbNq +Nh9C5IviwPVOWaFOLGEOigvhMCDsszmydicqw7B8DjdBmJpG7LQEICKl0Hkrn7U4JoqCJZIhl/OA +yQwNfjTyORd+JFcg98U0rY/XbEBmJyR8bqFAuj4niHSUiNsFTpK7NiKQR1fbxIOQh4RHLu/wQgtJ +AshiaLhRG6UHj5xIKsSi5snFaMoARJ9J6abS29jk792D7iKNw4k4yYD6BQKhZEFDBR1TGKnQAWwC +PMmiRwqpFZHW1AUkkgeqJVxjTVS1S0GxsIFudnipnKcDiqsUmDrDd4PovNZ+FtTOYFhEqQ4aBYwg +hwHRIMEcFRXoElgbH8oxsa51crSjqHVNa6v6KCidusE+K9Vg4aHVBThooczwJdN74FefWOEhA7dI +xwzf4Mg6QylL6QWIQ6ldaz423S2Ga+aoEKXNCVVgC8of46JpqLiRSHrY1zJkgUgjHjxrAGklvclK +MSdXWB6OrEp0dYEUI8MGrBDlKeRnAGcBx8oKTbAwuavIlUHWkJoY0drat2VtzHINnqsj9ODTXBbT +KG5u5sGeOcqHnqTYCk90lwNIQUBBEKmkRGgIPrGAEzZ5EblXyVEVXugqco+iHZIe68VSxIjmqhw+ +HcqTr1vmIgfBkxQZymMgGtNqLgNK6tFMlabjfB5qEwkDwVxC3rI8BHzXsReWMQJE5LNuJk1aQd+7 +l4KIShHNI21sotDIUmqGmN8IdiNPvIZ2f5MHiqbTdjqNy3YDf44AIas5KqAL5EYqwBADwbtAbTzT +iotHMJubmxBsCqzxZ/dpAHgu55AFOrAtzGMeWFpTlD4gBdSfTpl4oyDUs2QpQ8oQnAklses4S8ww +LkCRG6XyDiOEZOGdrcra3PFOyrUbw13BiGE2wmhXXfdjRrhluWEYQ8OcS3IHZJFK64rQLMf7WQoQ +rYGLbW+7PXwZlE+RP7mCbxV3ZH1C6jHveqVLOzxmpRaCxQkN29stxieqBiVcNpwBLzYMe0axEWl+ +zMDp1xWtz7CYKBl6D8Imm4+zhVImH2RyYLSqLEP/tJEnKApWKkkqlNWYgr+jvFRKzqZNjSBhlEhx +IEHNGipmP0cBr8iCoWmvnOJuniCnRZG7gaDdOtw9w1TSGQc6mUUF5Y3NBA3/RRrDY6RgDUxd3ucY +kEIpk3E27jMof8hvqJEkWfUCB/mKNisWT2xnl6wUKT2OxwXwxOXlTKA6TwRVw7RmhbzFULYiVpMJ +dhPeLaHIwghvAWOS2of6zRchNig6hHYCNxXyEc/W8ZWlqii0zz7LgN1SSXJ38v59+t69QpK4TkCH +BzBJAVvoEvj6/obAsnWaxuzVGKbheUtVhaYtOcaYpoIfpGMmpSHrGCqGZ+GY8uamkCFOUwR8ZTOW +4+5hltbLFzoKGWmWJjcawMt2hoQpoigo1TiBi0yqYCJEOZMhNyMgxrLQe8rQKq7I5pOcKUgtQWpT +XAxLspkSgYeoHT/aAc3lyMaSiGLAoUhO8ILJ8xVF7hr6WLeg6gWadRBl2WgLGrlVpELA2zPNnlNk +sQjaBgBi4bSpjApChKAVtRGnDApUddV/urX3KgPiy1rIZFCYQfYCgU/9FBmRWS3vZsiNvCLLd1V9 +zJMbqS1B7BWYEub//Ozb04tP8GiQVYkUnLgjcLEk1OLikudCihj5Gvh6I8Um0oood5ziVhCfmPYS +KktWqrJaT6TEDUIBEcENpkQelE+24tCBJOFfFXKXv+DC40PyKVKfZRrZrI+aZaggk5ZhzWDKcFXr +XQFkdSuRhh+MqvGxrlUyGeBnMZPDhampNKgWL9ZY2tPEsqW1QU8ZCH54IqRoGlQLzSMQDcxiAgcA +FlhOKu+LbFMCtMp9gW3lstb9+/n7JLFlZAK+SScNmAKIqALsPOaQihR1AlrJZF18zQIG085mCjbT +Xt+AaDv2ErQFv4kR4UH24QCsNlhyJZBwGDu5HiR/gNJLEsK1edK0HlRiYjbgH0UJkoOs+QNbcFqY +ZYw9R2IEIhZSUPhZe71kgXJzkkkFZFdgwk2yVYMly87IgTzeVQS4MXCgQkNS+9A5qRTPMLgAkHhM +4+PWN+KhOcNwRzHbGykBLKAZA03vIU+yeR/lnMsHeQLUEks7khjjgjP5IhBG0Samvai3b4rVA4gu +5I9mjKAcyDoMyjkp4AJYrswLjUy2yLA1miknkfCITsYoFAKWL/vR7mj+tDO8hCNgGbLsA9JHRjF0 +CPkqciWZr+haGxMC2CFLspBqWZLYhjkwjZ6itZHDaxmsr5f3I2Q+SAFSClOEhAFSQRM69gh+CpNZ +wHDIQrqXIH3iEZdiPu+uyULHPN//jLr/WSGVlAv5AMQhg+6pYj5rqgoCIRILAHrNYrosKOdcxkRY +17SuJRLM/c+yyFI8mc86AlNW1c5akpmKVId0BDvD28Kc4iOQTpubIj6C3DUgJIjPzWzex8klkQsE +NqSoOE9VcxTGON5MKRvg7iy8fIzkl+WO7cwMe1qgyR0Nssic4D/7LA2qpfJOIWclEkhvDA2WEPPA +rFdHywwXU1SRQGIBwqAsiFWyP4ohvg85Bs9LkbXcgKyAkQIE+TqplI5Kx/UjURk2pvk4nbcxgcg3 +vAXBwvdQlUVvEVcOisEORZYfHcg22M88pVMM/FGE/NehUX0I/mamgLfrpfKhrJLlILKPBRBK7gIj +ZB4soWWBtirr9XlIFwi8DsvXyPqnWCc77nIuy1eBVIgv4BFKniQSAQ0XBauoAzAX4gi1g4CiEGAe +BaXlBCvLnbFcS5IHeC8USBLJD8ARGxQVID0wJ0CSHFWGJEYcaQoTFapqi9zFZuuS1Bf5Rp7cBcDF +y6Cb9b1mFfYHqjVb8DCT1crOYPLwPpAtC91bXu+VUsBTyRSUv7O+u+QhKMkEyl/CV3JHb1Pc2BDS +4LKcizwBxwEcKGjdrAYth0IGhSF8ebIBDKkFGoJ0ETc38psbSE4JXj5JRlosR0eiFH72WfL+Z+lc +muQSLgywAMZMr+8nQjvhn2A68A1Ogk9hyYaTsaINIdUA4/cTMjwysT9r7wCyw9XmKdB6lWPr0CpA +P54pUXl74z4ssEgkIrIo70M4ySrZhSIqTUgdhitxYmt9p5jcvFPNnunNdHeSJlYUkjUgSlKs40HC +lEHe+gzeRYxYMUcXiZJnic7RyBbKJsuVFKVl2z3bHejmiBPbktKRyEpUnxMCL5j64TYMMseVEaZU +zkrlTOjz6exzzWjBoTNckMwaG2RoThZqgdzQ75GdnHKbI9s2/I2kvpnUaZYoJXgroDeYlBObqjHk +pOpGgoF3TqVVYCZomhfbUMsc30EyZ3NwEAoYnBMb3cGL3uClpi8EkdxDROGQLShZcutkvdVTW++1 +qzBcA0YJhh3Qh8rKEvQoFqiKqowNHfQRI/HIssN6sw1Zwd4UU0my2xNDs+yR4U4Qo/VKpkt8ekLK +wxjmy7k8HArZapIlq6BuMqlvbPBgsbUeRmrpGSgfiiyBcmysya1CXkunAGsh+BQODlxToMiGUkGo +ZFLiZ/eQQtlkQgACI/+h/QShB/9FDEWCljiyvQHklU5p653DXo7cB8cYBQx5fXNKglYpEBMaU0yZ +DCpPtn9kyDq/cu9e7v69ArkqQmExy9V4snutim8kpAQXIC0TpHysH1KLoqu6NQ3K+26wcvypX96W +NLj4gWpNdXvqxXth9bTUvGTEDk02lsAAwgh3EVxy75VF1TdYHmjmEjgSyshP3YJP7yDWiK9ugbCm +ita0naHrLWVtqGgDkdw0b5vWZDR63mpfWc4YRp6sPtFwZDVoIYhkuCFZacO2Z2kIDx21j8xh+Jpq +jnRnrtkzmDWo8fU9X3u907XLS80cFDJfd/zdUv1M0MgqN6gzu8a9RNqAndTtpWZtg2E3yaIlkM03 +nLFuj3C1qQyMWESzZP+qZg7BqnCXQHJkF0CYItt7YEAWGDvNV5FsUDu63pbkLse3kLRweQUWSQIX +EGfIYjXBBEKIIG42FqQmgwsuRHkmzBbIBgboTBpOOY9SrWbyISe1DWsK1ZrN+WSNMWet9x7IUE2Q +tTCeLFuRxKYsNpBXuJ4cuYdOeIfcWuIQ3xqceJrYXnAuYARyRc7l4M58oKLAA17A7xXH7meyCoBX +URt+tI1CAH4iLSW1C7lbIOaobJptsrc55yDQiKAg9zmpUyAbaOMEQTwkD7ntCEIhMMKEAAo32A2i +3TDeQbjhoAt5kq7kViwVIY6KgRmeNAdnfnUHbsiLt1V7IiElvFm5cdqePI8aZ6o5Jjd5WT8s7yjG +EPggkpWBBqJjFSeK2XXDhaQ0TWccVPc0m2zP06yJX96vdy4qzSM32ha1Piis6G35kFVaT1b769cM +TXfU7F1o9oDiSxiIbMx0Z9v0dlR7wSF2ctOwx1FtH0AUlI/D2oVsjBmxLusjCYmqdg== + + + AQjr+5Jliot4uYqH4Qwdf+mXDovhnmqMZbkniG1QZ54sWTRZsnHRha6moC0FRBa8DHURkdsoQh0n +xEPW8BayN77AAGdsRW0igRm+rOhD+FBZ7frhlgszbg4kpS3rPVqopsFryECh7gTblrfgpDqJUcEj +90DFmoDTaqCAuRtuSXpPVNu4TkGpQEWwYsVwRra3QOnhMni5iQ8CvSKBCwWXoYscCxvlKXJbUboK +Jk3CtAOEmxgR0jUHRVrw8Bb8iH8tuguQBaA+k/fIBpt8AAaHW9G0rhfMSo1dv7woRuPh6saLd8n+ +H7osqQNZmwhyVzO6UTCJwoWgNAtcjMjmyTYwE+fHcAipsdBLBkXbrj9g+UBRK7rZhYSGj4Nht+xd +snHOxOzVoEnAfQxXkUiAplFjXy9Oi6XdqHZgehPLA3a1nHDcGl20Jg/tYI4ccL3BbPuFWZzy0IfW +CCXvxTtOuNTdkVEkXq/ZPh0uHitGlwYEmeOgvIe8KjePSs0HijVXjAWoVpRjXkKUS8CHoLTtlbbs +YIFsybOxUZwrZk82upo9Mb1tr3IaVE/j+pkb7dnOaLb1RVA9zjGRpPXDymlYxfOHbrgraW1OqiBV +RLI3PgDbqlqj3j7tjB5WWyf19gPX3wKq5KhQs8ay1qXIDsZwvTWiCPsGsb2++WuRX+7gy5Lc1PRh +GB+axZlq9Ux36Je2VKvDCJFmDzFkPOxgCxNVa5+X6kdeZVs0OgmYd7ak6j3DmdrBNr6SAdqjoLQ7 +Wb2o9s6MYBE3jkvN05hs4V7VemdxfQfZpZmNRvegO76M63vrO/s/bLZvSnrbcce8CDY0QXzr3wjo +WsUl2IQQSmmXZKnaFlTgOSYTb2y6/mowedKbPlHMEaBGUNpw6OSWPVMUxIobzJrjy87sZn7w+uzZ +T1uTJ7I5VG1ooV46ByHUU42RH2wNx08avSsMULfH+fWCAMdFstaCOpLJDt5+qbZf7z6I6/tFf0R+ +YUdAJswkpceQLWqdYrQd1vaMIvhlSn4lR25IWssKZqa/csKdsHrQGl33FzduNHLCQdzYCeu7QX23 +1D5y40W5dWhHS7041pwBkEQx2prds7wp3tVoX+6ffNw/+1Dvnnqlbc2dIhZetPBLq3rvKm496s2+ +xJwIEtwH0COW1EYxnIOOg9qx6swVe9oYPPaiLcef6A4Se+BXjp1o3/J3zOJWrX6wd/qhWNrJUB4C +V66fBZVjs7g0iwskOV6smH033GaEME9byF4vmgSVeaVFxlJqnkAxilrb9ucFNuQI5BLKBgIgx4Ba +qtEvkN+IqQlSneHwTFhpnLVHN43hVb13jgemC8NEBQlqS7H7TrRyoq3W4GGtc45gOeE8R7m8UFJV +gElVMyd+tI8KrXXOhouXDx7/ojN7jOkttx4ElUOEfn78dn7ytjW58kqrcm21c/xi98Gb8fYTpAqQ +0PIXenGCj/DjpWH3O50TQChSy/bmeBgOoZLJ9qve7ElU3RsvrsvNHYoLebleDFf1zllrctNGdtkj +mq+E5S1BrWZyiqRWoyoga9UaXm8/+Pjg+S8ao0ftwdn1sx/70U6BbjjhUTE+9OKDZudqvv8+bpwj +V1MZjWVDSSw73qjaOQnrR5X2+fzgXW/+HHGsNHbny4eqOaQZaDNo7JZuLsLqg8bw2XD5ZTHa7fQv +UCAwdLLWCaon9d7j6fa765e/f/P137t4+M3Vs2/i5l4xXrQnV+3pw7h50B5f7Z99Onv+y1L7WDba +kl7XzFZY2QZADVcvpruvKq3jhy9/NT98Jbt92ewEpUW5sduePoraV5XBjVs7cMs77ckjXo7ytKGZ +7WrrdLj95XDvXX/nTX/7TbV9sXvytt7d80rj+uAirB0DqaL6SWd0PT/8Am90fOTqVoHzBbWmIcr+ +3I+34/pRd/p8tPpCtbq63fGjCS8HmlVzg3G9d9FfPusvns13Xu+ffA0JZ/sLy1sCbzH8Uv2k3jkf +zl9Otr9s9B4DacGVnFix3Em5cdwYXoa1g2Jp26/u1boP7GghWX0rXDnxll89aA4eYobnB1/a3lQQ +I0Wp8iyMgCerg7h8vHXybrr/crT1cnH8oTt5+PjVTzAzYE/Lmw22np08+e769c9vvvjF6eX7Um3l +hdPO6Eo1B7ozUaxxsbS3c/rtbO+L/vzJwdknFD7NhbrbB4pG9aPB/NnOg/dbD76a77189eG328ef +++WlqNYN8lstJ9Xe5eTgTWf6tNY+m+9/yat1XihWakvL6ebymmF3BvMnD1788sGz71++/+2f/yf/ +bVje86Ljvcuft8fPZH2smrNi6UCz5xzZthQAqWjWAxWWG1vVzlFzCHx4FjdORK0zGF/+s//qf6x0 +TjN5My5v7R1/iKuIF4Dxi0rnGsD79MXPZauXo4oOlFXzdLR8Pdl6u3XycbLz8ot3v33/s79nh4tm +9+Lw8tsHj787vfl26+TLk6ffX77+g6PTr//yr/+bwQrw26639obLF7O9L5eHb/cvP50++/ny8NXl +o/fPPvwBiHX35NXFi+/7q8+Dxsn2g6+vvvij8eGnqLpsDneL5bGoVi1/GdaPa8OHtcHlaPvlZO/z +Umt3efS4s7j2y1tRbU8vDuL6bqV1WGkeHpx/3508k826FQzq3WPLh7KaEhyuHsb1k0b/0XT7y9ne +m3JjWWlsFaN5qXnYmTxsDa9Gyyer/Rcv3/368ul3QEvbG/fmj1cHXxxeflzufzFevepMnxfDnePj +D6cPf8RLJd1uIyWmu2+Gy+ftyc3x9XcXNz/7/jf/cPvoDac0kfOl5jnSvta5DOtXlc7LxcG3bnEm +ilXV6Ol2rz18EDX2msPzUvOg3j2ZbD0vRltgsVLj2A0mrf7pZOtpZ3QZxFPdbIENt47eB+Xd1uAc +V2v7s/bwYrh6Uu09UOxZ1DiY7z3rTS8cf9BfPIprW53hyfbJm/78pto+nO48+f2f/2c4lRtMDy++ +Pn/+i62zj4PVs2b/3Pa2IGin8+ev3v7t3vhCkL2wNJlvPz5++PXpk097l9+ePf+1X9qLK6emO8nk +NMiDcvv64PoXu2fftScv2vOXLSIqjsazy/nWNSv4NBdBabvl/ZCQ+0mje0HQNRgud562+g9gz73y +UW34uNS57M4f13unBc4r0A7Ul6pXvHBeqh23hg8Hq+fTvXej3bfwfeXqYb13Uu1sDRbn3elVY3hW +be+dHD7/Z3/z38/2nvFyqdrcO7n61cnVr4+uvj998n19eLFc3fzVX/6nf/+/+OdQKQcXH85f/Hr/ +6ifzow/HN9+fPP5ZXD/+7kd/+y/+0d9U+7uZgu34W9XW+WD5/PD609O3v1seffHg7M0/+Wf/9Xjn +KXJgsftyuHyClLv5/Dff/Pwfvv72rxvdx8eHLy+uPyI9iuEsqiGpjjvjxztn39y8/ZPPf/QPVsdf +P3327cX1l6Y3KDX2Ku0Tv7wTVnbbw/PHX/7Rkw9/Bl6o1A+QeLrdxRmcYA77ySt9Tu41uw+3T94p +etlwWlF1CyGGtAiqkKC723uf/9Gf/dOj87eq3ds6/W66/6E/f3by+KeTw09B42FQe6Cb/XrjTDE6 +olKpN/c7o4uLZ989ev3LvcuPFtSLNdrZ+fx3f/Kf216v1TvYOX67c/LRq+zh2trD6/boIURpvX1c +bR3QvCdrFYAzBtUcPDq/+fE3v/grgPmzp98+e/kj1x82uweDxaPR6sXR1Tfvf/Knv/s7/wQY8uTm +qz/5y39y9PBreCJJ78AswC/3p++Wxz9ZHX9bru0/e/bh0ze/bLYWCgJd2vIqJ3Hrstl/dP7s97Xu +tSDXSvU98ClKwI/B+KtK9zIo7/TGl7/6479++e5nnBRDdCn6YLj1RXfxIqwdKfqo6C0/fvzDP/nz +f1qu7NjFCTKqNXvaW3x+9PBnujPkxFjR6pwYCWIQRMtKEyX2AmEa7b6v9R+raudg/8u4OmUly/bb +3fHVfOfl9uGL1d7N8fkXTjjM0WYQjyeLl+Pl697kKVjMr66my4cff/S3H7/9haTVRqsng60XzfHD +rQefelsvS61TRPmbT7//+e//ftxYpPO2FwGRTqL6HpJ2+/QdJu3y6qt//i/+5/0HX/rh5OGT7778 +8V+evfrN9ee//uLTnz549hsv3Pnxx9/97Jd/pZrdqLKHDx0vX/SnTybbL/YuPi2O3nrlrQ9f/+bR +04+G2+vPH412Xta6F43e5Wzn9eMv/3jv6vtK88HZ5Te6O0hmVGC+F8HWrTRnAa/hhvv9yXWvv7dY +XStG3Qeht47BiW60anTOd07fR41d3eltPfjGr2wbLlTESitO00wpx9csb6s9eMoIMfRks30YV7d2 +Tl4fXn1ojq81iEltMJ0+/vUf/eOwOu1Pz05vfrQ6elfunBWjmRfPFauvOiOMotY6EdVSMRpG1e0S +qqa2X27sDCZXEE4X52+uHr6H8lnuvTh++Ong8tPBxfujyy93Dp5Wq1t/+Xf/0f/0v/zvT7/4GcXF +it4xnQnSpjt93Zlizh9oevs3v/6L//Jv/rvx5BgSbr7/FUpjfvhx/+qXxze/gQjUTWivb4aLmzz5 +neLAcMejrc+7k5u90/d/+Pf/5vGbX9Rau5PlQ5aPNGfklnZ0Zwy6Gc2fvfryD568+L7ojRfbj/rz +C83pSlrXdBbl+kl/9mIwfSrK1Wp5VW8eyHoDUxc3iTtzo33THlVru4IcFhjdchutwdH+6Zsnb349 +2HoKf5EtODnKlPWSapSjyrI9eNibv1wcvX5w893zD39UAWG5/cnqkV+eFEvj5+//7OL5L8fbL0eL +J/Pdl8ATToapD4PqvmK2VKPR6J8hDbZPvjy4/Gr37HVQXyp6XG2uOuOz4fazxdG78d4XXuVQ0VvN +1k6jfQAv4IWLSm3fsXuSVCqVVsvDLyZ7r8rtg9ne5/3FE7PYa/aOkQx2MHHChRMtFLNB86Eglr/+ +8Dvy2z0pWZIbKDeic2wojaGkdRSj1WjvzrZuQAHj+aPrV7/dOv5xpXVz9OC7+dE7v7YzWz357rd/ +bfrDH36zQ9b6trdd6T6ZHf+s3nuYZzzNbI5mD+Gh+rObnbMPh1c/efLydzfPfjVevuqMHgXB8N2H +P9g+eEbzvmR2ZL1tuMDei1LrAoBQbp2YTvP1Fz8ZjR4o8In+sjO8qrTOwVzl5tlw+arR2D+7+tib +XiF1AbmG3QVIhuF8tni42n1sul1JqStaA+kdV/fLrTOvtNcdP2p2H7Q7p83GnuP09o/ejHde+bUD +J1ytl5Vqgtx2/e3zm5+F1W1WLIMf/fLu1uFXq6O3q8Mvd47eFcOtwfDBtz/9M9OsO8Gyv3qFolgc +fvXw7R+eP/2uB6God77/1d85u/qCJoa0Ua5fWsWBbFRpwYe38sOlUxxDkVreqFje70wej7Y/R8GS +jZpyzXEHtfoyT+ks75Hfp/ZWXulQM5eWC0mzylOWrASl6qTa2a609zrTh7BFfmW3Mw== + + + vKw0DoJwuJhdPHz5k+b4zPLHljcpRsu4chiUj6qd697ipVEcgI6Hk+v53qvZ3svZwRdWvBT0+jpd +TwU17HZ333z801cf/850761f2hYVzEYN3pz81g8TptMyTVmW3QU1V9oHUXOv2juRzAZQ5eDsa0TT +dAet/vnq6ANQcbK6iSozw2nQnJfLWzTjZfNyrmBUantbB2+mO2+Wxz+qDK7ghXk5DOL5eP68XD9V +jDFEu1Hsy0Z9uft0dfiKlSNcQLV2ouotSamY/kzzV8BAsl4RL8PSFitEk+XL8ye/7AxvRtOr3aPX +9e45AleJZ+/f/0Grs8qzTq1/OVi+3nnw3cnVz8uNM92dy0YnCCdfv/9tr3coStXB5Prs4Y9We687 +w0ed4RPDmbRaR4fH72SlXm8c3Lz83f7Zd432RRTvxuU9051ipP3Jpev3ECndaNY7J5Xm0e7R27PH +P7WLM6pgxX73z//iH5fLK04o6/agGMyLwbLZvd47/XT+6KdQ7IP+wfmTH9nBlBN9QfQUtcLzZZYt +SWJDlsja5vWjH3XGDxkBnjrgpDIrlGmuZjpLN9zN5Oz7Gyy8dhgfptIi2dvGeVCebriw3JHnDJ4/ +/WlzcsoqgahXJa2BrA7LB2FpVzfquayqqc24dlgs7zV6KJxzSe2Dghk20PWG63VNq9rpHUb1Xa+y +U+1dzPdfVxt7rebu569+en7zwXDrqlHrDE4PTr86vvhmQOzGcTHekvQm5nMwugSh20XwxauLJ786 +OPv44s0fPnn9WzfsT0f7b97/ejC/AN0w5NYhWVirt87bPXj2Ps3GptUX5JimTdvtTHZePHjy/d7p +O9irV+/+/OTyu07n6OmTH++fvneCieH2MSE4Dy9Xo/DAMkc0uaHpGFYjKE2hqOP2mWgMVXsEw44S +sP2JqFZMp7/YftPqERy2i0RFFChblEqeN8llxFSKIShRPxzOnk63XrQgv/WWrDUW26/2T79GIahm +EzKgP3veGlyRP59itzgRc96qd49sf6Tb/bX4H1dbZ7Otl4enn2x3wvGhotSqtR3UMurdLo6hVWCW +49qJZY0Fvqyb7WK4UK2hao2j6uHW4bvzm5+fPvzZaPEcXJAr6CznMJwlSJFu9UrNo+7oCvMQBuO4 +NMtkDTyJ8gGqu/5U07u60bOsocD6x3s33/7kzwQlTCQouqBpcjmCTKruimIlnzOLTvdf/A//69Xl +59msJIlBtYkzXNWa173hs97oCfljEVmtXt+HjspkVUwsD6GFunO7bjgqlWdPnn4cbD9gFVdzauXW +dtRYuTEi0sMABS5oNg5LtV1wmazXMOesEMpqTTM6xWBmk0lrvnr9/Xh1HdVXhj9U7KZqVIN4OIDd +K00lyY+C4Wz1aDK/DMszQYmzlAX4hblrDx/X2yeoFL+0GixeHF99hFAZzi+i2lxQ/f2DqzeffuXF +/WRG0a2ZGx9ElSM/nGN+aL4EydobP3GjHsvqftCd7T7bP39/9ewnR1efVgcvK43tZnP1zTe/evfN +7zIFU9G7brDthbu15qljjwWhxCOIakXVqogCctst79jhXrF02J+9Hq/eKma3wFhRadjsHDpeB+OF +LrXsgWUNLKMvcHE2xVM5UZZC0+5E5W04NagLlo+L/jwq73rRnGLd7visM3tU6Z4axS5MkyDGcWm+ +2H4Je5jNabmcbtpDFG+rezZdPK83T9a/AqOrWmMwvs5kFcvtVBq7s92XxfKOZvcZzqcZFzwoaVVe +rkT1o+2TT4cX3+4ef9Ub3+jWhOGrmBlcD8OavFA0rHatc3L27Oc7J59qrXOrOMLJRbVsej3L6zre +MIp32t3zbu/Kg4IyGq7bTWfldEpgCprA2rpaoymHbCbMm4E3+vj+V73GMpMSDa0RVfcsd+w4E8Po +KGojl7MEvtTvXZjmwHIHBVrnBNRsrdYmln/n/Mlw53Swfbx1cvXw86+evv909OR12J5aYa/W2o/j +Va22b5jtPG3wgqvrJT/olWuLamsVVEZhbdyb7v/0V39+9epjb3Goe00z6Na7y+XRw9rsiJWKeP1o +eFhrLPIF2bKBPFA+3mDyaLb/rtQ5l62mF7Z688NSZ1nqzMyozRux4dfLvcHO9fXg4Fz166pdI8vj +dpvhi6k0TbMWErs9ON86fONGLU0vOn4tbs6MYtUrdaLGxI66tc7y6Pzm4sUX5f5CNEpRdadcP1r/ +noKXTLKpJMcybm9w1upC5KB8YhRyZ/oobp7AJSl2V9BqilVt9BfFUpuRHU71raA33XmuGb183kon +OYkr2nrNMpqyXGI5j2KLglzyo3mpfaI6AxCHopVff/XTm9ffVLqLLCNTQjGs7lWax6rRTqWEdFrM +5XVJLitqPV8gfwmBon2nCErdb/YuKvUjLxh/8f77x68+DJbHmlPPMToUQthY2vGIlT3TrQ0WV7Y/ +NosjpDQ4WjVG2/sfTy5+Wqru5CkNqWU57Ub30IuHbjjxwlkQTcPKdLLzcLL3qNpetvsHncFlf3zT +aJ3mMvr9z3Kbm6xhdqqVbZY2E5uFVJKnC57vzWbzJ4PhI9MaZbNGJi3LSuwEg80Ul0hzqYxkOrPe +/0nSe3jJcZV5w//At5Y0M93TOVRXzlVdXd3V1Tnn3NPTk3PUBGWNJCtZ2bJkS05Yjhhsgg3GgMEG +2+Al52zAYGMwyy6Zhd332/d7z3u+p8Q5dXQ0sqe7qu7z/ELVvb+b2xtPzDNU1mEXFbUsyYl8vjm/ +sLG+9/CJM5duPvLoY88++7HPfvIr3/zaO+/8+q//+Y/3/v1P3/jej+++77Hm6Dqc2/DtOWAkHsmC +1s22auV+szPbH5tdXts6dueZ+x959J6Hbp27ef+R8xdPX7l294OPXr/3kc+/8oXPvP76ysbB9Y1j +xeo4KAGMCPmDxYBWYYRoIJAsV7qT0wvLq3uPnDh24frVBx9/9Knnnzt3/0Mnr9y49vCTH/nkJ177 +8htf+tZ3v/DVb37guU8ubhyRAikUV1xuhsD8ulaOJ2qyEo6nCr2x2YW1A1NLG62xyfH55enV7c3D +J558+pkfv/mTX/3m169+5Svn7r5vdHw1kWy6XILLLnlcCoGFE/GRcnmeJMM2GyXwsW5/udGbz1XH +k8WRXH1849BdF649ePORxz/z6qs3bj1x9wOPXrv1pBqpgJQCuHPaWYFNi0JR9tdEKU+Qmh6rJLP1 +YqXV6ExPz+87fOLSY+9/9smnn/7qt77987ff+cJXv3bm8rXpuf3lyiQvZjxe1e2RAYIYNg5qFj7Q +4RAwTI8l+tX2SiLXTeRaR0+d/8DHPvbERz58z4MP3P/oU1fve+jS9ZsPPP7+L3z9Wx9+4YXrN+4/ +cuYKJ2XcbsHlZGk6rKjVSHRUlkqJZDcYLMTjzUZzdu++4xNTk0eO3XnnXRcv3H3PZz/3+d/94c// +/sc//+GPf3r73Xef/tDzxeLokAkzmShoOl0fz2aXbFbBaiEQjyAKaYpOe5EQgigUrTNsNJ1ubm8f +O3PxnqOnL129+fATH3z24JGzvanD9e6GKGWNuaz/4uJprVsfX13cPH74+KVzd33gqUdfe/WVn7/1 +i1//9jc//cXP3n777f/6+99/87t/+8K/funZjz6/vv/OUnPNg4QRTzACrlxOJPV0ByzE1s7JO89e +uHT5iSeeeP2NL33xq19/8XOvfOiFj33pa19785e/euW1L37r69/4+9///uqXvvGBj37qyKkrifRI +vjjV6a/mq+Oqls1mynMz02dP7zz8wPWPfOQDL37641/91lffee+9b7354y984xvf/tFP/vSnP/+f +//t///yfcCa/+9YPf/jAE0+3x1bD0SYAJklIUS1VK7eXl1fg2NzavnT33R/88LMvvfKp5z79iWdf +/MRLr77ygzd/9Itf/vz3//Hb//nf//POb9770Ec/dubcPbn8qMQVGCKjh3u54pIP1VCvpCkpAO7t +rf1X77n2yONPPPL0Bx9+6ulX3/jK93/y5g9/+uaf//bnv/znP375q9/85re/ffULX97afy6Tm+L5 +YlDtcHw+HB/RIvVWc3phYe/BQzv3P3jz8aff/5EXXvzsa6/94Kc/+/mv3nnz7bd/+et3//SXP/6v +//d/oFu//+NffOblL2WLEzYHC5zodPJ2Y4akQlJxJVDMZTvre/fffPihm489/NynX/jhWz/76du/ +/PJ3vvnaV95457133/3tr3/y1pt/+NMf/r//879/896vX/zsS6fvupzKtBgG9DZmtxMIIglcrFyc +mBhbOXTgxPV7H3jk8cc//8VXf/Tzn33zB9/90je/9ts//P5v//Vf77737jvvvvX3//77T3758wdv +PdbpLefLC0qw6XQak5+HzThH6QIb0bVSpTIJmqQ7MrXv8LGb73v4Uy996s23fv7r3/3uja9/9Wdv +//J//c///Olvf/vUKy/feuKxu++5oWkNjiuzRKDfmlhb2HvnoaNXzp+6cf38U4/d+MobL//Hv/8G +Kvqdd3/xs5997+XPfezy5TPLy8uZfCMca6No2OuRGTIo0AHNH6rlSvs3tu69du9DDz/4yK2HP/bc +h77/g+999/vfe/2N177xja/96S9/+dHPf/rZVz7z8udfPn/l3vnlw83Ogt+fienVfHEkk60nk6WZ +icX15dV960v3XTz9r6+//KUvvfr1b37pnXd/+Ye//u3NX7795i9+/t57v/rPf/z1vf947yvf/vL9 +t+6bX9mIJOqSPyPKCb8YrhTqM1OLx3ZOHjl85PD+ffdevfTqq595660fv/3rX33vzTe/8s0v//zt +H//b795999dv/ebX0Cw//dyrr1y6cq3anCZwjcC0oFqNJcYpMsbRWkRN1wu1rbWlJ9/3wBuvf/4b +3/7mS5//zI/e/OEf//ynv/3j72+98+M//uG3P33rR5/97Mde+uyLB3ZOq+EyyCEAK3+gFI42ItFq +f3RmemLmyKHDH3j68U+8+PynP/vJlz//0o9+8oP//O//+rc//uHNX7z57e+88ac//u43v3vv1S++ +/uQTTzXbi4gvCMbNbqVdDgHxBgQ+XS1PF/OdfZvbT77/iY9/+uOf/Nxnf/jTH//xr3/649/++oOf +/vDtd9/645/+499//9s3f/b9X/3qzZ+8+Z2nP/D4xctXUumGIEZdbgJKK6DmtFA+ppeX5tYeeuCh +L3zxiz9880ff+u7X3/u3d//4lz+++96vf/Grt//6tz/D53z3e1/5wY++8ZOffu/pp586dvry8r67 +BH/BZMLdTtnt5DCEd9owCpNHOlN3njj54EMPfObzL7/8Gozmp3/ww2//47//8dvf/+6H0HY/+QEM +1IsvPX/u3Nm1le2w3iyVV0NSvFnu1Er1Yjo7Nj6ysDQ3NdnbWJu6dvXYI49cvHr3sbtOHyoVk8GA +SJMMgtAoItithN2KO+046ROj/ngpXupU2qOd9tbe1c2N5fmZkRPHVu+/ceLWQ+cvXw== + + + Onvl6pXjZ071J6fCekqSs+EoaO+ix8UibpZAeQpjQbgc2X9y79592USylUvtX50+f/rgAzcvPPnk +ta9/+XM/A7h5+6fv/uZnL3zq2VNnj45NjYe0uBrMUWBdfRKKyhIfPrTvxMmTl+rNsXK5MdntrM+O +nzq694WPvO+b33j97Xfeeu/f3vnmt1//4msvfv4zH37+mZuPP3Du4ObeVms8pJddLo4gQh7EP2wF +X4PZbKTbSSmsUoxH9y3N3brn/OuffeG1L37m1Vee/fEP/vXPf/7dpz/1wStn9h/aO9ttNIvFKo5z +DjtGUyE4UEyBgyIVlhSioUSj1Fqdnr90/MDTj9/4+Ecf+9fXXnjrre//++9//Ze//v6nP37j+Q89 +fPHC4Xq1gKEs6guQRMRuA0ljTFEeNvkIxB9V83E1PTk6vjg3s7Nz6Pxdp65euuvmPRde+dSHvv61 +1z732Y+/9MIHP/GRxz7/0nOP3Xf5+PZmNlWh6IDby3q9Ao6pDBtJp0eCaobwcXEtubWyce891194 +7sPPPPXovVcuf+ipx7/3nW984+uvPXrj9Icfvvqhx26cPXl4c2Wh1xzJZDrt3pYWbpnNmGWYwlDd +4xacNhz1MNlYcXt59d7L5z73youvvvaZDz3z2NNP3P/SC89+7zvf/cRzz9136eL64nKlVOVoBUP9 +LrfssNEOK+J1U6iXITFeVbPJZLPdmpqeWaF5CfGBtmTdHtblYnyIRBBBh4Ma2GOxDftQj0xgAZ9H +oFA/bRwCS0vRcFYLJn0eDPH4fF6cpUWG8fP+jAtRLDbc6WAwY52CanPiQyZwtSjuExE3gyGCrIBJ +CXOcEhAVyoeKFJ2JRoq59PjoyP6DhxeWl+LxOIyjzY5ZbCiYDpDKTqdgszN2By2KiVCowLJhHJd5 +Vo2oOtjRiBrMxKOpeKJQrPTHp8OhcFKPjNTrtWwmxMmYhwXXjGFBholp0Q7FJnfvsYPaCchFmUtr +UqyRLZXiqVRQTajB9fmFXj1XTkdGW/VErMCxCsdqFJX0IarNQliHfRazZ9jkMpu8/0yyYuiEX8iV +s/10pFiK565dOr+zb6OaivVrlXquMN1pzrQr+UTB5yEGB4ZNgy7rMDa4xz444LQMY4BdiMdP42FF +yuhgs6KZZDwncgGf2yexSkIrhOR4PlkabU6Mt8YVXkiFEyExQqGiw04PDRNDw6TTrUhS0e8vMEwY +8XI+D3SuHtGr0NQin6431maXzoxNHPZLUdTlDkv+dDihCkHcB4CJQxWJcrHRPRwIdi0W6o7/xwRC +FMd0l5OjUIUj/BElktaTiXA0E8uDfOd8hIBzASGpyjlNLYa1htMJnSKHIy3RX9l9hw1KxWTy2G0E +4uZIMsbzmWJ+bPvwFRciO12gLZMsl+OFAvhKgoi4PX64AyhiPCsbGLDBMWTyDJsx1CvTZFQNVEUx +zzMJio4aQVJ20mrHvGjQi+hwz1kqifmCwxbE6aJcHgGEDYHKHjfjcNAEHWekrBQo+P1Zj4f0ekiK +kDBUoChVlNMIpoD3x4kYtNJuY3GfG7Su1xvAsBBOqBStOZyM3U57PKLVijmdpMNBEJgKHlkSczQd +Z7k0igYCckwQtcEh69CAy+vy01QMaJ1icmp4nCDTZjMOGtjr4YfNyPCQ22nx2ofd9mGXz00H/VmB +DZGYSGJBp1MG922x0v9cWm63CRga9rhEqxlzGCuVBKtddHlDdqcMHEeSWj7X3d48mo4XbGa7gPtF +UhdIjYLLAYwacJpNPtynm03IrjtMpiEPjoZsNgYOaHm3V4HzYaHy9Y7PF4CzCqjldHZGVWvhQIHy +KV4X63XSY51VltIA7uCjUDJLcBVWqMr+CkZEnB7ZDR19O/zWH2gFwmOJ7GqmuNwc3VH1UYsFOE4o +pLs+r7x7l2XYSLSQVaXRHzvaaB8gyNTAHvfwkCefGsXQ0J4BN4ym3c6iSNAvV1Lp6Vh0zGGlTQNO +3AukKdislMclez1BFIuBa4avU0Mjg4PIkMllMjvNw65hs9sLvpWMs8aD6zGSjCeioIXGOSHDsBmf +T0OxCGlMaw8gqO7yBnbvtgwM2OFLrRaaQMMcneK4DJRfMTdbrq0NDnmHhlww6BSbkgMd0V+Hj0W8 +foEJN+ozDJ8ymbxms8diQbxeOZ6aC0bHpECNYeKJRCUUzrk9HPyuzQaAGfQgEUFqZPJbPhgIs8/j +AiPdhI+y2SmLFYOq8/qCglQQhbLFCEYjAcpQVAWE9PmCcMecTpHAY2qwTrIxk9njdit+f0MJ1Egq +6UbCBJ23OWTzMAHlZ7eTu42VC3ar2Wsxe+1WjMBC0G4+JAAg6XBIu27Hfbhcfo8n7HIZmQMkmfQi +ms0KUkH1IEEjSc9Mma083CtNb8fTPR+mwpUOm7wUqkEFDuy2Dxhr1XEw7x53QA/2vW7NbEbhsFjw +wQGXxUrBHTYmGOCxoNYPRaZcboVhdFWrEUwCats+TA0Z89sRHAlWC0ssHTEPeWhSp7mi0x20OxWH +kRaVUUKjUqDl8QZxPAQmpdLaH03NYngSJ1N2h2wyIYqY6Y0cRJHQnt0OnIxRVEpgM6q/6EOCoN73 +7LI5rfjMxH6CiJqHKYKMI1iEoNJ+pZPKLgtC1WKmrMOkD1GgNUxDbq9boMg4J9Y4seFXRzi+aERQ +In5RijJSzDSMWG2skQIqlKRgPRwdrXe3krkJmotzUp7hckqo5Q91STbvQnT77fWt0Owu9+01/gM+ +AotiWBTxhUQhLwdqg0OIUQaIhFFRv9Yh+JzNJcKPiWh5YemwoJTNcA89MopBqYfAE8HQOJ0c8OO+ +zZ2p+S0oLQRgjUjQdI6isrxQEeUWVDvHREPBksfDDQ66YCx8PoWk47xcC8enFLWPY7FUciyo1eBa +DAp28SgaAmDh+QJ0oter0lioUpyhmCSMoNmEDptptyfsdGtOl6pFeiC69gw4waGQQP020umgEK88 +DINuREQGKSoNIOB0wVnFUV/U7QkOmRGrnUXwVCDUTWUnWSFrd4hGvplHc3mCIO8pOg7dYTKTHFug +yeTuOywDu0F/qIoywvMVjztkZC+bSHATHBuH8/G6ZbuDd9yeiOL2BIxIExTujD4xdajamvfhIThz +hs5SRIIikiSRdLtV+C1gVa+bdzgANo3J2B5fLJ5enlu9r9TYdnpUuAmckEYxIzAN8caNBVZqLRQs +y2JJFEoEHnHYjTmoVqOw7UODHvOQb3DAYCK3S1DVsg8NQ61yfMYK8sMOFCMYS892w/+Jer1BxBu8 +419McAK4z49jmnmYMw0LQ2Zu94BvzyAGMnJz/dTUyokhK2Fx8BRflcOT0fxKurIWjI9xYn60tXz0 +zA0fHbG6OKtTcCNRH5bk+EZAm7E6FcAEr1u5bSj8NJ1i6BSOww2J+vAYIAlOqbQQJbgUSsdpsSCq +ZZyOU3zOr/WiqUVBrgJ0s3wCwY2FYH6QOkoBI0NeTAXmJQgDowYGnQODbpudhfJjmJQk5CkK2BYH +TgGIBh4HbHd6gl4sRTJVTqyKUlnyV+Eydb3qcnMWCwofBRiCEwmSSmnB6sb6KY5PDpmQ4WHUh4RJ +MsMwBYYt4lQSbh3Y3sOHLiTTXaN0h1GvSwRNxQslaEO3SwZQlZQyQemDJo/J7LPaSJdHwqmEP9hA +sBDDpaaXjsuh2q49zl27HE6HhGI6jscCaj0aG3U6xOEhhERVmk3sGfDePhA4vN6IqrYieocXMqJU +cHlk0zBuc7BOt4QTSfjqYm3v+OJphocak1qd1VJtDUFCwxbaZCIsw7THLVFECBhzaNBNkNF4aiaa +mvHhcWP5lTvAKbVcfbszuSP6SwBWJF2Ae06zaYeDcTlZm4W6vdBPBX4fAtVnpYwFJk4R9YUQj+K0 +88NG7gTj9gYXFk8rcnbXLqvJhAGKKnKLwNI4lnS5gC69DjsHHziwx2qz4qBVoClcHpXz10CiJJMj +Ab1iBn/kU31UHOcywcQEJRYwOq6o1bXVs8cuPuKjdJQIy2o9rI9H9PFEYlrWRgaHSYaMTvT2S3Jp +zx6AEQoqGccSwVC3P3WqVF+PxWqHjl5i5AIlZGLZiXRlOVtbLTQ38+0DYrCD07FEpP7E4x/uzx2A +lvR6JY/X7/VpDFeMxGYEqe4w0uBVAA2vEZ6TwoiMD8+QVEENjqjhrtMtmkxu1JgRZKzO8Pg0DI/D +wTBZUSrmCvOimA1rlZDeQVCNF0t+rcsrNR+VdHpVpzsAZwuq6fYi3ADD5TV9hKGSIBTVUB5B/T7E +T5E61JXdxiE+jSBjIJ8wMkqyaVbMAQVDF1utJKh3yzBOUwmGTQW0Vm18B2XTJouRkgEg6UNV0GZQ +fk63HxiHBrWJQmtju3a7BgYRKA+3SyXJgiDUQJ8IUpUXyxSbQckYzWdB3LqN4Cmd5XOCUnE6eIGJ +XLzwgCSnATRMJp/HowAd01ScIMKgtRwOjmNTLJsgSR1OJp4eT5UXxHArlBxnxQJORoOhBobppiHU +Msx4PRqOp3iuLgptl0sbtnA4Go5EuqB8QEvDdQ0NegcHvHB6BJELhnvJ9AxYDAvYFmM1GY94gsai +MKvo9mqCXNHjfdC0kpAMqHGrzWu143YHZwTI+IwXr0BbDo/EygWcS7qxUCgxLodHIonJ1sjh1tjx +eGGW45LJZC+cGCEp6ETVhymA20MWAj6zVl0RZCMnx4eEKOPuxSSpUKgsRZKj2ezYzsl7GX+OVbLF +9lq9f7AxfjDXWEuVVyg+T7GxXnvh1c995cjZ6y6viKGqIBREqRZPLmYLGyxfUZSa0aSobiwExtKc +1FbCU/HsZq17Zzg54wG/iSqhUA1BwzanaAUHSkQEuQSajWKzgXC3Upm7dPnWxPydDhd4n4KWmFBj +k7zaDYQnwtFZUCYuj5/isrdTdMLGGgdX0GE1ogM8bn8y3pOkPNS2xcJQREQNlBk+x8tVOdgs1dfS +xUUfHna6ABVxq4UEXScHKrHcbKaxTUkVzl+V1Q7oN5uNMN4Vak34RT02EU9MQakMGHHuPvgWQACb +DaxKnuNLLF+kOSPQhhHLQqDFylVoZOvtMHyMSMAV+QPlsFYbG13FMD/UM4CVKIBUSEGBmczo4KBb +4LM8l4RvtFpQhgonUt1IaoQSsqreY4QSw+aCoRbNpIwkKyM1N4H49NtpAKrNCJGL+6VyOjUBvOBx +ywgSsAOPD6EUmcKJFMVkAPYB04BWXG7pjjvMg0bSDoirFM/nJX8Jrh0IN6K3wJcPDlqtVmAKCQbF +AZiPRcErhWOTlc6hYGQknOwLwbocbvsj3UhmSgq2QV30q4v3X396dO4Q6HMwLwiYFG9AlMuBUEtR +W1Y77bLTOB51OCWzmXR7BBDqeqKfKiwk8rMkE1bUbHVkzZhsLOeMtQbRXqa40OxsjU/vbB66xoox +LyqEQg0jN1Usw1khUDaErkV70dy0w+M3mXE9Ot0YPd6c2IlkZymu4MXjLgSwqJAtzA== + + + SmqV5NI0n+ZEkK81JdwAHg9EG9FMp95djGb7OK40Wivji3dVekdZucH7m3DYnHKvs3b52vsz+f6w +lQL9iWIlDCsmEgvZwr5YctZQcXxGCVZBxgyDELXTWnx8cvbkzulbpeYmSkSWl3cmpw5Cj/NCKltd +KHa3SyMHx+bPLW49lK8eABVK0WFRyeNMFFQc8CZO52xG8IVkszPG8nAz5vEA9YdcbmMJp49McYFW +rLweSi/6yLQPVxW1zMtFwDGaywhywa81MuUFVW+BhgFsAWtmtTIuY4YD4/X6Pd6AeRi3WsEdKzaL +zwWemtSB5UPRvp6cpvgSyRb8wV65dTCdX7PZxcFBrw+NMVwJJ9OCWEINqRyjGCiVMiAhRcWsFuNt +ppHY4wFzl2bZfEhrg4G94w6TxYwOm3zmIQSgDJwFy4ETTzNsniRiDhtwtGgz8BwFmUexaV4qpQpz +yfz8+Nihu699MBxrM0ImV9sbTcPAtdojB0f6RzKVVZtHNpsxik5QwJtoWBSKFJM2ymkYSjqTKUzh +VBSuVxAygXBLi/cTxQU1MqoopbHRjUs3nnF5ZbhFyfxiwWj8+UJjPV9f15OTCKrKMlBSy2oDa0/h +RBQKLJaam9u43Jo86sXCdhtNUBEXolodvNlKAsgISjNV3Du3ekWPjYSj3VRxGqPDZiuKEloo2p5e +vfPijadOXLzVnT7C+XPpWGVz3zlFb5isNErFE7mpZGGWV9qp/EJvYkMJ5p2uQKa0qUWnSDonyQ3B +X3N5FSDcYnm+1lqDswIDDhJdVmv+YJ2TCzaX5PYqI5P7s5UZNyZr0WZ36uDY8vHm+GapvTeameb8 +BZaNfvRjr56+cAMlVRCHWnSm2Dmaax6QAyMWKwdj1G0trW9e3LUbTGtQVLup+kZj9mR77oyeX3Jh +kWCo/OxzL29snR62UOBqQ5F+pXt48+hDrdHjRnDcoEPkojSdGDJjw1YaKpbhq7zcAncGNsHloEki +RNExD6JCFxda2/Xxndmt64sH7m+PH2O5/J49SHdkOxTu2oyoVQy+Au4A0ER74mQ8Pecy0j9E0Ks8 +B95HAWcBeszm0kDQIpiRwg3qfQD0jwnDfRriDZBEHGS2D4kAV3o9oOdDAJ4EEYChtENxemSMCoPH +iSTHi40ljNY5qVBsbWeqG5H0fHPkUDg+acThWmkcVSQ54/XBnZcdRoCnZLHwbrceAMspFgAwRS6j +6VUEkz0+6fY0sHS+utKbvbO/dIZjE93uWqmx5KM0UF/RzFQoPsaIlXxltT5yIBwfBZXC8YVkZkaP +jUbi/VC8x8o1LxrlOOjc+MCQd88Q4vGqqcxMIrsQzy+HE5MEFQOwypZnRbXk8amivwIEVG0uHti5 +cuKuB2ZX76TFVKsxe+Xa48mskeydK68fOP6+qw+/OL5+XQqPo1QMhoah0pncvNXIecN9Rk6g5nDJ +GBFTwz0jH8BI5OZ8Pt3pEr1oGKWScqgZjk+ky4uBcL3Rnjtw9FIgVCfoiA/3E1wa57OcP5+vzu8/ +cTOVHzMej6Chem8HaNQfatkcss3BI4iSSY52uptAiyiq00KeEXO0UFTCY0p0NFma6c0cOXPt/d2p +Q4Mm0odHg5G+rLZJJg0eamiIBkjxSwVRzOzabbc5BTnUjyRX/KG+EhoFOQRem6INqPRhobUDF09d +fWzl4OX+/GktMQVQP2QG78NcvOfD2eIcSE2fL6pqXcQXo5l8KjcH3hb6yOPmc7m+JKTANu4CD2im +KKGmZ1djudVEdhnH0l5PSFEaPq82uMdhGsJvh6CS4CVBFDkcxgqgbn8N1Cycm3GxWBBqIxCdlDRj +YjCUlqTVCWOKWloMdDk/4FiZwHSOjlBkGEoIBwhFUxRZgsOHZnxYCmDWbucqxflUvm+k6g2j4IV5 +qVpsbNT7h7K1OU3NnTn9wMzijhv1x7NTs2uXJhYvlFsH+tMnR+dOyVrLbCEDwSZYXR8Qrk+GW0rQ +RcnfhXrg/cVBAGFj7xs9qDUpLoPRSZovYFRa8BurI2khywg5LTLCcElRSNQ7K63xA43x/fn63OzS +ibGZI0qwpkXatc5WvbvRHt9U46MuNGbEPjvFiNbO5uZMw+SQCeeEkqKN+tUO6CVerAEgu5wSSca8 +RgQlzvCFSHKqO32i0jkYz0wpSn5r+8T73v888CbcQxTTpEC31Njad/TGqbufbk8fg9J1uPloqhOM +9dyIenuzIWLYxvlQHYwJ4gu7XAInZBEjl5hwulVOasSzc5tHr16/9fGT9zwbKy5ZHBIr5OBWuJEg +jBSwGI6lRLHGCzUwOAODHoCmUHSKMpLhZTBBMHZA1n4Q7YQOCDA6sdXtrycyY+HEFCO1SL5EC2Wg +ks7kGZRMWW2iqo9Jas1IV7ByLrdq5NsPoohPzRfnEa+8Z5dp9x1mJ9wBYxH0OCfXESwyMMQ43Bq4 +KrPJeAJmt4kOh9/h9IOHQtGIEaONR9LlBRrXM+lRnAhbbBRcQiy3osZm5VAvXlyBPgK2lYznVA2C +ycLVgeYHqHTYeYddcDtlsC1w210OEXQplPrtWEI+FGo6jLgqDwyExc7BmTBCXjK2zKhEovV6azUY +qnNcamxmZ2LpZHVkbyBSo7koRuleVPN4AopSIbCQ08GCMpQDY+n8vkpzZ2z2gs8If2YYOhEMt0Aa +2Z0c2HMvWIZAV9V6oH45MdceWWs0lykyhPvkXGFyfu/5/ScfOHTy5qWbH652t0WxfNexazceeL/g +zyJYCCHiDFiGzGJ7dGdq7i4US+8e8A4ChhBJVR9VoJHRKHS3dZgGsQ1ezGXseST5g62A1vaDuqOT +OBEThWyuON1fOUkJBZcrUCytNVpH09m5ydmd6eWTrFRwOIWgWrj3kQ8FIiNDQ5Tbo3EiaPIexRad +bgWkPtCHFumCg7M5GF4oRJNTidxsd+LA0bM3FzfPsf5KKNQ6dvwq+D6XRwmE2vHUVDo7n8wsckLT +2A/LRtFUBIQW8NrgEOjnYKqwWO1tJwvzoNBQTI3F2w4nZ3OwUFrQBKuHb/aXLtTGjpJcfvceH+6L +HLnzIUpIASNAwTs9ugdJyIHRbHEzV9oeNJ5x2Z0OkqQig0PI7c3dRDe4daao6pO81IBvtFkwn08G +m2yzsggaIRnws/XplVM7Fx9zwRWxSQQJIogxe03RWoreCyXntPQizmYIPFLIzzAcWG8/DzjP50Sp +JAiAVCm3SwbvPzBgGxx0DQy4zEbaOXk7skx0OwMEFsXRoNNBC0LOH6rHMuOx3FSpvRmKjYIXjsRG +tGiFYAIUq1KMJghpXswG1Iauj3lA1jp5hgyjWNDuoEGgcmyapIyIP69XY+ksOGvwRNDsbo8M4AmE +NWxhgZo5vphMTwVCNQwLkHggGM4H9Fys2GtMbI7OHi1WFvL5mZXVU/nKJMlE9VgvW1kX1FYkNZ0u +rSnapNebQJCILJd4IQPiyg7e0MreFg9BmkyBv6DpAoaGQV0Pmhy7B6wejxzSupHYTKGyNbd5N2iw +gFJY27hLS/QBvhxO3nN7cQdNZ/TISKmxMjRMm00kz5YAFa12dmDIA4fdyXNCPhjuolDqXgFaj6Ki +TqcAQs7lUzzGLNBsq7N/cvYoeC5RyjY6WzSTdrskm4Wx3A73tlkpmo44HDRGhNzeIEVnQ3pPgpMJ +t1mpxPnLrd4WL+ZYLt7srNRG9sK/oHTG5Qu6kYDkr4Zj4LhXjKAhMIBqMxyb0SIzidyCpDSttgDU +ns3KtBvzkxN7jZg4M+byBHilligtl9v7/cHOwKBPC1az2Y7Z5Nmz2w5oAMJAj3Ylfx4awW5l3G4V +Dl7IcVKeZhPgy1Kl1UR+pdk/kSquqpGOB5XVYKXR3varNR8WcTiDYFodxmZ5lMVCDA/j5mHsn/sy +/DMNj8CSqFcnfXo0WJ6ZPUiwUVZMNSf2Hzrz6OHzT7RnTyrRMYpNhJTMwvTm7OxxWam4PKLDJSDG +28YwhgZ1rYqhitNJBvwZv5QBw4LhCa8vabMHbhcwbjfe2ZFDQ4CNGKAouBtBrPN8FXyEFw1wfKLW +mZ+Y3VjYe2LlwIXV7XNbR+6emD+erq1idLRcmty7fooT4m6vIMh5WWnSbFVWRlA04XYHgIvBXHvd +CuLVUDSOIhE3SCyPDDeZY9KCXGS4qF/J+rAATkYIOoXTKV6pqFqtVl84evy6FCiJUg6cBcNl5UA5 +GpsIBNo0kwUxHNHr5eKszcjBdlttvMeriVKVE4ocnydwPRSqAOrCfwUdBZY8kZlv9Q93p46sbV+F +v0Pvt9tLy+un/xku50MCmDEVh0Y8EsvGcDRQrEwJUgZADAoP2k0M1GKFhcb0yeXNe2Lx3srS4S9+ +9ft6tGexyjRbA0+RLy+fvvj4ifNPSsGRPQModI0gFOBboK1MRsYgY7OpfmUkGO77lQri9YNwcjo4 +p5O3OTirkzdZBbOxkYeihlqCnLU7aTDRNhtpsWAWY+4ZhxrTOYD3YwSdFRRwRhUwXNnyfCQ7FstN +55sb4fSMqLVBIbfam6sb9wS0htWI4DbCT1g6g2FRjzsAhAgsaSSTG5uj0ca1u1SP048jqq4V273F +UKRebczPbpzO1maytflofo5VWhiVDAfL68snFpYuorc30XC6OJJM8EKZZtOSVCSpuCRmcrkxggiB +1/YAejAVlqtRTM52O/zZGAUrBT0OtHL7bbjo8YZoLiEoeRjfWn3+mQ9/5qXXvzU+dwj+BWAzmp5s +9w+U6yuj3a3Z6QOqmlUDBSVQkf0VRW0RZM5mlQcHjC2WTEMIlJbDzg0b77A8gwPOYTNqHcZxVAsG +m92RrdnFY1YHA6oGMTbm00S1ksovZoorSrCBE1q3u1qqzLmNlH4ex0GRGq/AwJhn071iftw06DUP +oTgWAX/nQ9ThYcrhgJ5SWDYVCjegMIzHg2RS8hejqb6iNXixwAllgO5uZ6U/tmW1snAaNBUFJnU5 +eJ9XpoiwD/FHY00WPPKQG0VA84R5qeDXmioAiFzEsUA2VTt58m6AR5av5Qrb+dJWKNRJJvvR+AhB +Z0CEy3y2kB2HthoYdN3esyApiKOzC9dnVq5KSsNkIsAyALO7neyu3dbdxiYavN0RIogsGC6MjiC4 +6nILe/bY/wluDJ+J52fB9IHXjuUW9eQszeWTmQkt3vSQfiVSL3U22mOH1/dfO3HuibuuPrN15CYr +pDk+BTIDQcB1BoctxOCg22xCXE5AVIaikw4jJ4cFKnE7eRILYLgiqqlmd+nIyWv9+f0e+BHIMbdQ +ahwA1FXUajjSFpWawy2TbBKnIl4kAJBOswVBrFbqm40OWPW2xcpjwCwMoHqZpHIud9BiVywO5fYG +fxJO6NCqTicL/eL28OFoY37l+MrmmVJjfn75yNaR8wG9xPLxcHxE1ZsLqyc6/f0YEUF8UiCQWlo6 +msmMwG+Bg3a7g8azRCTG0CnEE/C6ZbPJN2wE5Rlhj3CNw2YfSIJItJdITcSTfVFKrQ== + + + rd/V7GygtM4Hq6Xuoeb4iUR+QQ01ZxeOV2oLAFNwQ2KJ8VhsXBQKQI42O20yeXfdYXXaWBQxMHlg +0GYyoV5PAEECoJdsxhsTgcRjdsOrer0+4NMU6IR8aTEYNN5ewflQRDTgLxgZboMegFO3U8DREIEZ +77gtwz6HDadwzW4HYMdMwzjICYlPiJwuiQmWTURinfNXHt/cf8ntCeB4QhDKwOnp/AIoWAKVWDp0 +O/kZJ4iY8TiULfJsQQuDDk/YLKQkRPVQCRTOHbusbq9Bc6B8zMZOWJjFSjrdIvCOachjteIgVADl +wNG4PQptuK04TsUYoQCtl6ssqVp+69C5meU7K7Xlbn97euXO3uxOPDfD8ulMtq8EC7dn5ihwBwYH +jBlHBGokg6kq2JZstb6OYGGzGfG4BZpNpkuzG0euHjn3SHt0+8KFhy7d+3Q40cOpBElnCColyFU9 +PlVpH+vOXtCSExyfrDf25morwUhbVusgpK02I984EOiB+9g94Ny9xzloJkiuyikjOJ2/HdMnsUwm +nZ+jmAjoyWR65MChc4+9/7nDJ6+mKnPBeJ8TiysbFxf23iWHij4iENK73f6+UmVe0+qZTFeS4jAc +4HwpOgV6xmY39hg1ds9xq0Z6AwbGMDCwx0Atp52RpYIa7NJsCSdSul5ZXD6cSLUoTtdTvYmV06sH +7+5MHyt1D0uhjtMl55Jjx8/cj9GhYSvmMiYng803AvRsw6zPrfr57NT41ur6mT17nHt2W+HzgQSD +kT7cEJyIA3aVS9PLa6fBCyO+EMVAO8doOob71GAQUD0GMM5RYVHKOOy03W7MnLGYcfgWj1tCPLJp +yOFDBI6LgRuCSssXx+ZWj04t7MSys9XmXkAqjk/PLp+i6bTDIRn5/1bWbuW9SFjw12kmCT1lNnkB +CaFuvW6JxMMECvoHhy81DyEggzk2tnuXZfcu8647zAN7bFDVwNF+IcOSWrUyHQfjYCMUOeP2+lkh +KwYbWgyU9kKzv1Nr753rr3zxS9/dOnwBPKMcqCbzU5HkOFy4Gh4nubTbK3F0dHHhTh8WHhq0D5sd +Djtmt1GAhKAqQc2KUlKQ0hge4YRCMNapdZa745ul8uSVy/edv/qQFm9QfC6RWYon56vN/Qsb1ybm +To9OHg2GO4loZ9+Bc1Iw4ULBWuoImgKeUtSu6G+7vSGbQwBTBg5l2C4PGxuB4WCRwGdF4jNadALM +2v7tu0ZG12S1oMVHMuXVWvfw5MK57cM3Tl59ptrbqrcWj9x5dzg5EdKbilpj2DT4YlDFgIeKv+X2 +ylab0XFeRJOljqqOgsH3+XSb1chk5pisxQIg4wWRiSAJIz/TGzBeDwm5oN5gpRTNxeBeedGorDZm +F0/2x/dBbZSr4yQbFqSEFqo6jUH0u1xBh112O1QKi9ZK893O3oHbD5FQ1A96ACVijFRmpBK0Xm90 +Y3xiWxCzPA9EWVZDFUnOM0xMCRrJSCQRKefHYBxtNtxqwaCiCBQaQfO4JKuZAEzTtVIyYazH4Wm9 +O7a2ffTi9rF7teQMyRYRNL60dPzzX/haPt0DAWmz0gydlISqJLUEqe5yyyAzFH9+ZOKQHmnYbQSU +k9WEO220zyNhXr8qpykqBMDOMZlhs5GyOzAAboJDvarLJvo8QaD+WLRz9d7HHU6GoHRGzEihRjg9 +kSotZAoT89Objz318W5/HYi+3t4EWoymJqG0GBHICyQEF1FLDz70gqRVdu0aGhywDA26huGKbCww +C89ER2oTO3deUbSyF1SBlOf82XC8lcz3m2OrxdYcxcej6dFCfV1S6pre06J9VswFgjVRKuvhkUp9 +QQ4m49m6pNadbhVIASU0m1MG50vTWUlugMPFyOSwXdwziIDo8qC6EuowfE7gM+urp7q9VSVUjqTG +y+3t7tSxhfXzh0/cO7a4E82MTc3sf+6lNwKRDqgjgDJBLuvxnqqNSfKIP9BFcc2vFGvNvaJcNJ7S +OJR/JoLCQZIZliuZjdfZ5JDJCzXmcvvhNHi5Fs/MNUYO+oMwLqn+6EahNM9w6U5vbXRiUwCX5PXj +ZBQckCTmbVYe1CB8rNsd8riCHrsALA9wYRoiVLXqV3I2YDELIwfbnekTufq6qncQPOL1herNJT1W +wwidoJJ6dDSdnw1H+pII/BiGinLYGZoKOx2Mw3jRFvZ6FKsxHcJP3165BlwpSzn4cD3RmVo+tbx9 +aW378tbBq1uHrvR7swwJtjRIU3Fjbqfb2LOJIJLGbA0iGtZa+cJcOFRxWEnU4yd8mtNK40iA8Klu +B20xozSV1fVJD1AeHTQ2kNqDuOyi3Qb6JAXCVRSL0Ugdw1WKjuBkSJCysez42NzRjUMXNw5dHVs5 +hdEG5I7NHBPUKgGdwmRwMkmzWY5LgT7vj6+Bc9y9a9hhobwu1WmHy2RdTg7xcOVcfePgKcafcKPB +aHYmoLfgk+sT+9PNvay/JEnp4zuXVjdOgbJCUcCNfCQ2MTF1dH7hzlhiQvSXG+XRD3zw+ebovl13 +2CxWwgVI4otEoqP15rYaHvV4lfWNc+F4e8+QZ9hKeYBlcCOzTgpUY6l+qTS5snJ4auGIFw+IKtzS +dihSk4L5cmPhwM49xy8+zkhA+rO52irJ5RE0jJFxNxJ2eY332uncbKYw60GkwSGEppNhzfCMKBJz +uUJDJsZkpjxeedDscrhoDNdCkX4sv5ivbxQaG+Cas8nerUefP3LqptMlqeFaNNPXkn1V7wJuIz7V +45H8crndPchyRbOZMp5XG88GuYEBL4bGg8HO2Oj65au3WL4ASlIJNUW16cVToDMzpdWl7XtC0eb0 +zL4LVx5tjWw4XYoxPdKrG8H7WIQkjfd9XjdPExoIaYfTiMgeMpE2h+zxRYL6RKm6Hk+0+2N7l/dd +OHjmgYNn7t84eiUU67qQACekS7WlVn8fFICiFsHtEmQCww2gtlk4h01wWBmAqUJ6UlUqu++wmIa8 +bhfvMt4Xcy4XKEOZZbNrW+ecLv+//IvdZCJBJ8tKO6T3Ybx27/Y4XTyCKj5codiorJVLnb1T6+da +kyeEUE8IVqKZiWJrHSdjmtaNp2ej6elEdkHR2ygVHrYZgahOu+BxijYLBag4MOiGSvChKoKFnF6/ +3c37QyUlWiF4PZ4fG186VWisFmpLjZGtShPMVB70s89YwJLnwX2TMZKKsXxSlDPt1tzps9e1SHNg +j4MgdDXUEOUSguq3U/tiOBVNZsYYMQUAYrWBgARi0iWlBNULIrCYa6+vH+yOLfswJVdZnF2/tHXk +/r377x6fO9ybOhBJ9RLR5jPPv3zt0Y8Zm4thkVp7e275crF8oFjeHwz33F5l2IIm4g1RysIY7Rkw +Qp6HLbLTreNULpEaP3vx5uV7HwPTanXwTiTgI+NioFprrTbaB8rtIziXg6pLlWYAqzEqStJpnEx4 +fYC9oXb/iBysW+wsiuvgx2+rOBVqGAAQJCtJhjL5UZBVTqcsBiqF+mpr9NDK5rmpheOgOf1y8tL5 +e19+/cut7rzVJrBsEVCU5ysoFoVhdThFgc+SZGQYXLZbEG7fK04qF5tbi9v35Iqzq4sHPvLRTy6s +7MztPbNy5Hp77nRr+sT81tW1fec39p8r1pfKlZkvfOX7Dz36ERwLBuSi318HBGOpRDjUVOWq1x3c +swcFxwpCaGjQ8Mu777AO7vEYRtKX8Ae7klLL5Wf8gRIr5uVQS1AbstZVo+NOtyQquVR+vNXb8IfK ++fryyOyxmb3nZjYuja2czza3lEgvEesf37lv6+AVRsyxQilfW0uXVqTgFC+Oejy6xUKBjbLboV8Y +8+1pbB4YNTIKji+Zn0wUxsqN6fWDF/Yeurhz9r75vacKzTXWX8XIGAgVXsj7fAGnk/F4g7xQaXT2 +98aPJTIzjAASXUCAdxAFjBU0IwloKTWD4dlEelEKVGBk7U6OpCMOJ2d30AwXV0L1VG6iWJ2BP1Wt +xjB6sbbQ7G01umvx9GSmNJ8tzwVC1Xi0fvDw2fm1QygejCXHc9W5WGY0EG5zUtXh8kNrYIh8+ND5 +YnEK+MtqFT2eGIKkEF/K7Q1nsuPnLtzfH987PIzTbFpLTiaKS93JY2cuP3n9kRdn917FqUyrNnNk +56IgJaHGsoWlkcmzkwtXys3joUjP61N8iHLqzmuV2ooxh9lCg5v2YTFw6In8fKV7AKxKu7kwPrEB +eE5SCU4uCUo1V5gZnzte7WzHkz2AzVyur6hls7F7L2axMCST86udkNZzuwM2GyMHyqXmXkEughqn +uSQrZXyYqqqlYnlaVrKj04cPnX6o1ttOF6dFpQBnyNCxsN44fOL6ox/41NzSCTBWarDHsnm3S/a4 +GKsZNQ8ZgfamIUbTR2Eg7rhjeGgQsQxTDitYBo3mSnD+CBIKBqpAxzgVr4xsr+/cPHzuidH502A9 +Ks3V1a1Lpy8+Njl98OzlR6ZXjycrk6MLx0AxxUoregIo5typu25NzB+T1JoWHSs2VrOlRUWfQInU +P3dbGBr0EriO4yGXMZOWwckIJ+UFfzGaGY9n+1sHzp++8r5YvpdvzLYnobs30+WVWudIf/quXHkV +wYMoropKhRZyAa0djI7LobFgbIb3twgi5THeu7EkHSe5nMuno2TWiKJl0g5ja4NYMFRFjSer1O2F +56PtsaPj83fm6+uMUJTkbHdsI13ok4wez01Pr549dtetjaP3JYqzaqRGMCrPR+YWdpRQFqNUXinS +QsGATS5JE5FifiwSaYBudBmp+MbmLACYHq8WS/RLlTmON1YlEAQo9pqslv1qsdSYn1k9mS4voIS+ +sXjwofd9QNeLJKm3Ro40e0eLlbVwdNJuPJ8hwOKdO3Nfq71iMjaZNTJUlVA3lV+q9w6XWlssE7t8 +8caps5etNgJ6LVtenVw+f+rK00fOPxXLL3sQjcDV557/1MbGCbtL/ucOI6o2Hk0uMmzRZEIRr9zp +rhdqK8MWyuMJ+FBjvoHgL0cSk1qsL4rp85cfuvfBD0ajHcQXlPwVPT6WLy+ubJ49e/XJ3uQxVqjQ +dEb2N5zG5tHuXbsscJlWCwvoSlJ5pzO0Z7cT8Ujp5BjYyWET2AcO8UWBFh3OAEtnQNfB3VO0Rrm5 +Xu8eoIWKEii0evs6E4eAMo7uXLrxyDPN/lo41ds58/Clm8+vH35gbvniA7c+Pbt6IRBqFbPT2wfv +iaQ6Nifv8qig1gQuhngFh7EbkZLQa72RvYKQcrl4HxYUlVK2tlLubU+vnB5bPBaM1hbXj43MHMo2 +VjL1VS01JQbrjFyQwo1sdUlL9b2kRvApH1yd1ktWNlC+4vDoGJ3l1Xo0M01yGV4tc2qD5Mq8VKG5 +As0a9tbllqD1KCZCMCEo+PmNu+e37u7N3FntbmfKizD0sXhz7dDFSLYfz03Mbl7JNjeV6Ig/VAXH +urS8gxGKw8mm8wtqeITjssFQw+cLO50CTUe0cIPjC7t3u4eMd3MyL6YKlRVVa3k8QQ== + + + h42L6E0Mg9/F3W6m2ly4cPXRi3ffml87mclOBEMVj4fDUb8oZMBtmY29gFmaiZeqC6XSbCLRs9vp +gQEXuB6fz8gwIakwL6RJWqfJYKXUD2kZs9kD2n569dTenWtj80cTuRmSKXi9Gs/FHn70yZnZ/XaX +f9jCGMEyxvYQxhMYkHMEHqpUZ9RgedcddvChFJnyB+qy2pKDHeOtul677+YjV+65JQjAnsnx6bPN +0aPZ0jyAoR4bRdGY1VgCwLfaWxQZNZkwHI3yfJVlMhQR8SHanj0ep50a7Sx++KOfs5ixQag6KwuK +QlHb0dhUPNrl6dDYxKrszwBn0VxNCPZIQi7X55uj253x7cbIWjI3HtSqtcbS8v7zi1vHO+Nr6cJ0 +LA1I0gLPq4frvf6molaMqSx8lmNTDBWG0jKSAbwS/J3nEnY76bBToAzD0c700umj5x5f3X+lN7V/ +YXbja1/51uXrj6ixdjg1UWrvTxaWCvWNhb2XTpx/dHbtTLO7fu2hZwLRnssXjmSmS519td7xzZ1H +N0+8b2LlrnZ7/TOf/9YzH3/di0dsTuX2HnkKSqX84dFEZr5WX7hw8fragbva04fGlo53pg+mKjOj +s4emF48fPXXjwo0nM6XZWmvl3NWnrr/vI/tP3DsyfSyanuCkIieUJaXt9AA2MtDmXh/4o5QoVYNa +k+VznFx1eTRBLPlQv92JoYaoa/hDLUmu4HgM6EkJ5MenDwa0cjLdqDcms8WZYGSCEao0naepFDiv +f+4iDSWBIAGciDmdkskEVpqjyATq04DuaTpGMzGGjcuBYiDYAFU2bCXcHoEA++YD8y77A5lIrNWb +ODCzdEoN1Ug6jGDGmo7bM+4IjzGxKsyy6aDe8aGayyk4bDwgrcMu2G2MF3yfL1hurc4sn+iM748k +JwkmbXfwqr8QjbRxXIcyw/E42L2gWmfohBvqk4r9c5WW16UM7kEGdrsG9jjhRxxVScx4g0ZR0T27 +7E47a7WQxvaIQ97br2BYh40ShCRJhaBTEtmpZH5B5LVsfqxUn2/1t4rNjXCsJ8s5cI6Z0oTg1zkx +ENBykpJP5Rdy1XXwek5jgmtI8Vdlf/H2GlvCWAPoFkki6nLwcLFmkxeMMEmGSUqXAoVYdrLaXJuc +Pby8vP/shXtmlw40e3u3j91Y2rrnyKn3bRy4XGnMh/SyHmlUK9PH7rxbi4NfmBybO7G0cW5keidf +m4+kuopeymW6V66+78yVB3yEHo5NKFovnpnfPPrQ3qMPFCrzU6Orr772pQv3PhROdPLV+fbk1tj8 +gXPXH/3IS298+o3vfODFV0+cvP7iC688/OTzsdx0LDsdik/mKuvTi+eP3fX+pa2brFiWhEx/4gA0 +kcsTcLllgo6CeQzGpnpTp6OpCRB1I6MLspxXQy09NaroDRCTUqDe6h04eOJBwZ/S9Hw4WueVamv0 +8OjMWT25iGI5gsoFI31/qA3eLaCkoR6AW92uoN3hN94pWDmGzZSqK4KU9yAB0AOTC2ebY/sCkbYM +JjFQ8GEixYVRQvEiHM2EeCkpyHlRyQe0Ci9lXW5O8GeWN0+XqjOg/UR/xYeoQB9ejypJVcSrWK0k +gACUlsenMEJKjfYLtW0p0GK5jMjFRd6wlgG14nRIw2aKYeJBrc6LJcA3kJEesBgDiN3Gg85BoWJd +fgwN2aw06GpjZqBDpMko/Gi1UNA7Zgvj9ICqiTBChuISWrRRrC+geDQVLaYyHUFORuItLTqqaj1N +H0lnppLZcV4M+/26Gs5TjB4Mt7XEpF9rAw2xbC6q9xOJUZuVcjt5zBfwekGT8KYhz+1MIQ+KhMD3 +YViIF9OclGt21jf3Xzywc7nSWRD8iUi8Nr24k8r1CqVeKjvCiWkowkCgqqo1PdKCFs4WJyvNRb9a +YMQ8RuoEEwkEc3q4lCuMRZMtIwSyAvU2Bl0wMXOkPbKaipX6zf69996cWtwb0goTU9unLj9w6f7H +rt/64NX3vf/Sg7cOnb48u7hx9dp9x07fOzl9+M5zj0wsnZtavri8cWlq/hiYVoqJxSP1G498dHrl +2JAZt1gplk/LwWa6stUa2+HElCwmHn7kaU2rgEDy4noEjHNzY2XftX0nbk2sXBCl1LGj5x557MPt +/gbBpqVgixTKtNgYGT9+8ORj9f4hjNAuXLjR7K7YHIKxJbrD78PiFFtodUGHHFeDtbH+xtzK6fbo +gUpnVQyWUSLGy0UlXC931jh/we3l4bpYIS5IGYoNgwGh2GQw0hybP3H3rU/0pg4qSkmLjiDGIhHG +eKXrNJ53gWWoNVcFMSfLqWR6RA62aiNHgrEJigXrBPBbkeQa0JnLFaCohB5rJzJ90V/CiKixTd4w +IJIXBhonooCxxgIiszGZzWxMIzR2uAMxPzCAoKhu7D81hLl9mhrp6KmJULynhlv+YNPpUoP+JM3q +dieNU0FeyiQy05nSaqoIBrAi+1PJVEPVKx6vGI50Ku39hfpmtb3vdiilkb9ns+DhQDECN9zJmExu +05AbQAy8ME0CQac4Ot1orZBsRJLTYajk1rIa6wiBfFBvVkCy8lGXy5gIxArldG4pXVxTwz0M01Ff +IKQ3WTFnttJeRGPZFHRTNNmTlRKG604Xb7USDK2DKnA4jZkkFKGqop6JFHLpliTFQ4FUoz4xMr7Q +GJnI5LuqXg4lm6nSRLU9M7m0v1CbHx9fP333ram1U3AnVbXA0jqGypiXyUTLm1uni/VZ0M9aqJuM +T+qREX+ggRLA+ERACmxvHyZIneWremKm0txa3nf3xpGrs+tno6kxvxC779r93/rhzzYOnafFYrqy +VugcHl+/98KN57YOXa42Z3Q9+8T7P7R9+KLL4wdzF9DHM9XNzvjxnbNPZQozyWjz/vv/f5Les0mS +7LoS/AMDdFWq0OHhWmvt4eGhtcyMiIzUujKzRJbWVV2iZTVaogWARqPRaDR0QxBakBAzJAgQA0kA +QxAguRxyqdaWO2u2NrO23/Z60SysrKoyIsPfe+eee477e/d+/IkX344lFbAnCGbLamf/zIM773vn +9gufylW3B/2dD7/z1e78PoJoGUzTrE5veOnMtfc/+dJnVrfvgbG6/8SHGq3tqbA7DxaLiQSRB1TU +6ttbJ+5oSvWJx577yrf+i6LWOLlnB5vw7W5h59yN128++GRn4RKBue977s1n3v/RfGkcibGzEQr+ +RBCdIvOSPJgJe62yVy7ce/Lxl4BAjh2LHXsk9t73xI8dw5BMzvW3CdzZ3Lk0XjoFtlS3gffqJB3g +VDGBwNqVwWQxtO26TRzXMPg7n7f8cbl5YrR8/sTZx73SEkWZtdq6X1gOe55mDNCN0ZgQbo/ksoZa +xDNCOkGInJ5OkskkS7J5ii+DnWHYMsUW0xnZspog4Qarl85cf2H33NOj7bv5+mEiJRCYYlltDA9v +/T10+lImrUtitdLY5qUaREQhvwiXlMFUmO1oQga3GJbvwx1DqSfD/SRKpb4JctdQ6wKbRxGdISwg +n1JpxItuMklwnAeEY3qtycaFUxce39q/4fnzxeKCnx/RjCdLgWFURD5HE4bI2DwLHxHmIhR4K4Er +Q8jTlEngVjqlaFJRZLMc7YIlhwCXxAoIZppxeTEnCIFu1Iq53mh+uzfYgYwAF7+0cb07Ol0oD3Wz +rGmBYwVZKzC0UvjsPspJQkmDCxbyFGVjqIIhIqSnoLCoWAvJlJEvb5Yau443XNm4vHP6Tnt4yDBu +qzK4cPFurb7KUEGxvJYvrzj+vGbWLKcBrhycrKrVaSY397A5BWhFL7sSFLYMsy8KgaX63fZksnwY +nlJsHeQbB73lG73JlXJjI1de5YUCS8iHB1dOnr2rajWQgrazwLCgvgJdbSRibCJKe0bj5Zc++oHX +3wYvE/ZXjcqJjM9IrXLzsFTbcc3KZ7/w5Vc++FYixk0dzyTisqx0q53zk4OnUiklneBkAdaxT1M2 +kAakJJh80H6j5SMQQhzMnpTb3b7Q6W4iGR1DbRCxvFiGycFRIRUn4pEMjpCaqGIZFM9QopRvLpyz +c6u6vcjLDZF315cOz51/LF9Z0u12rgRmeYdkqgii8LSlyXkkxWdSIk16LJWT+LLnjcCX4UTA0QVT +qRtyZaG7tbVzI0PYkFZIys0gehJoP8EqvFurLSXiQmSWDFswR1gCt2FORLEgiDkARi4YqHqJoNRs +MGj1D/PlLdtbXBhfDAorBGEN5/c6nU0kHVYmwXCw6kEy5RNEXVV6cEmpBO7oeddux8E3pbX/eAKY +yTjhSXzUTiQkywkjlOXKbnac9QYc66fTCshgng9IwkolWZ4JdyQylAWgJQkTyRiRKAsRwVJGIoqH +p7MTPJLkRcYVuIKkNCmmkE4LlfpyoTbBMLCorm7WJLlgaJWsXdXkHJJkVSkol+dxDMKKoSkD4G0Y +cMEVGE4iwaeSEsPk0IxJEjZFujBLREbRJU/iPDAUGKp3Rqd0q8NxeY4vkIQLekkWi5ZRYUkzlaDn +ZjIQmwzlTE8hs9NoMkbylKjwRsFrt2rrEKfT0+jcLINheUZo0GyBojyO0wUwLZ2Rn21OT2PhuTB/ +ZbRybePwiZXdW2AxaIAT7ZCEQhNKmB0IHcalaGU/18/mBoB8Uw1so8CzNiwEz4AnLVK0TVNWIkbR +uEpmBBrjdEljSVoWNJ6zcqWBqFcJysVx3dEKZ/Yv3rj5lGWDSMsXSuuDhStBcYemPQIVM0kmFadx +RKEIE0cVAlVZ2uW4oqr1Jb5Cooarla8d3XrulY/hlIWgMklaGBAXZrEkvIxkgo5HSASEZQLckIZi +1sMiD3Imo0lCIev3Od5jaKPRWq+1tvLltWx+2fEWJaBE3Mq63Wy2D2+GVQjyS6XyAc30CbyWTmmx +ORRJEobiqXLueFhGBgEA03SZYxsklc9kbBx3g8JElCogVHDChzwe/ifpgzAGYgwLgMygaIonwDtH +iLAqwhxNUkBxJYZ0aFKLRVDXaJTziyRuERmNQC2WBiVgoRmx3pjk8t1EguJZR1HyAp+VeJ+ldBxh +MklSZK1KqYUk0ngaY0jINVmOy8HXJeLc7Awai1AgfaeOJ6NzBIEa6YSAwXoRBokAewDM1PHSaVOv +oGmB53IU6dOUCxEB6xidzURmUskoyRJmJKxQgYM9pHHHdxueDdFdpjDn+PEUpMKpqVBLPzwGSyfi +tCq7iuTQlBqL4uAWRbFimF3P6wfFkWG2E3EGSUM+xaaOR9AUSZGwQLIkOJ3WUrk8tO0GRRoZhInH +0XSSZ+kKTbo0qVcKw97i6dkocEUmOpeOzaVZQpBZzbOLYSWiXFXW8+mQ6nPD7lodVJCcI3G5lO+7 +TgMyEUE5kQiNpAQUkXUwL3qdInUInHSSQdMcjqrAafEoR6JW1qr1Wkut1oRnddcu8ZwHGhU+SGIq +jqjHjyNAWRgSDm1mOhFPKijmi1LLNBdcb2w7HQKTgHw2Ns9rJpiRAFScpneCYLHZ3A== + + + 8rLhncNUkud5TxSzAPXwuVjYgJImwPvjCpJmYhEkFUMZXCYycKliIgEyJmsYHUUOiSKTUR+arAFw +jiD2/NxueMiFsFPhgzbgVSYym8qkBbA5PF+wzKokBg9LKySTUXx77fSlS0+wtJOIkUiCxVOSJgYw +KAJV0kk2MoNQhCrywDZqOslRmMQRkkArLKUSGJGKJWiUgH9CJMpSWRSK4XPqOJNJi7BGxx+JJuao +RJSMAAyOJeaOp+MRGs9oIuMZShF0SyVfv3LpLohMSHZIQgRWQdMKlpZ50gH4xeZw3x3ksotExmAg +R6Tl6Cxx7L3xWATWRYdvnDoW5WhTFoNUgkvFYYoosG/RWZRGNYXLM7iNpkSRzWlKd2YWOX48duxY +BIbMUIZlgPw2fNO/evWWl23EEyySlknK5viiIDUYtpCI4Y6avXHh3ttf/F4a0977npnpqQSW5jXR +t4y8ny3rkn39yu3Do+soLkfm0IcP5cPn8ixjSaKlK3Y+CwpzTZFqHJsFjYdlRPh/GmclVjGVAoGJ +eIbG0wxH6blsR+AdLAMzkNQE3s8CJsVUhkkjBGQEXa4Y6kImbUImmp1Dp45HcUyT5YIg+HhoWi0c +d2jCNJQ8RxlYhjPNSqW1jZPwjUomHe7PfPjTomPV4glqZiYNbjqTUnk6h2fURJwkcLEYlEteTuXU +dAJPxAmC0Dy/X29vA6LSKRGuqDfYC/LjsCv0LApwwlGZDjNgoCtNhswCkEq5frUwwBAaKF3hTZZQ +WVLjSQVNk+lEBn7/9Rs3GFKKTKdjs+j0sfjs8VQ6zoVlHnn34YNgFc84WIpGk2hsLhGZSWSSqK8b +7aLfreYd3Wp1Rqqei0bAQ6XmwiXGyYyWSUqzU6njj0SOvzeSivGKWJWFIpYSJcYKnErBq1lGNRmj +cESmMMg1SgyI5Vh05ngiNptB4rTMBRSmJiIoIDweBeQLDJGl8Fw6Ic9MpWaOx3W5CICcnU4BDiHt +8ozr6lWesNMxMTJNoEmILHZuGolFSDQF5CklY7jEiTLHGDLTKrijUV+QZBwMklNoNfpBriSIGoZi +NIb5YBqbC/lid2oqOTeDoCnBVoKcEWgc7yrCoJrf29sKStUUQsXiJJqBHGoqspn33WrJrxW9k9uT +F559sLCwHokgkbnU3GxCZBQd5JGpW7JCZrCsrlQDVxMBUVEslZAZrJxTO1X3+tmNK5dPbBxOWj34 +ZaplgtjQQMA8NMUUXImpmJ6tW4bq2b7IuqZa45ksyJ7EHCoxSqPS6g4WTTNfLQ8EwaEIicblTIqd +nUaOHYuH97LosFwMTF06ToD6HbTHG+sblqoTCJ2IERRhgCrws3VJzrGc22ot2XbVNKuynE8mGAwR +ADMcreiiKXEOicmQsiWhLPFZXdAMjq3lLN+0dUlxNU2mSRlAxuGTQWF3a6iIwIoskZHwFE+jKoOb +kMgAHsAhHCjMjIgmk3gqgSWTjqwslL2tTu7cav3+xeGd80uvv3rv/On1omNzjIajEuQ+kXQAYI+8 +Z3b6eDIFLjslpiIYg7Ayxec0w1N1W9YoCN4UrouyzHMc8CMnirSi8b5r1FBEmJ1OHH9kdupYDOAB +yXEWXOcse/wYeuxYenoqk4gwAH4kjuNpohRUGVxgUM5RckQaND/LUzlFCJJxYnoqlogSLGiYNIUl +EjKdzul4vyyuz2d315v9rl+v6OOOd/Og9+DW9tHhwkLLnW/4hWzO0rMUKU8fm4vPJck07ghSTmJM +Olkx8P1xvt/2XFtwLNlzHU3ii57cq+t7I+e1p0699vz55+5tPf/EiU6zGJlLRmYREgXBmrMkxZNZ +XyJyMr7ctPYn+aWWVnXwSV09u1p87emD1x4cfueTN3/zo4/8/Jfvfu5zT53aqZV8XldEjgsIPEeg +nso5tZwzbDmr8/nlXjHQxarvqYKCJDNYCvEUZb5VmUw6hye2Xnv99d7CGCfIVJKAC5iZAr4SDHOB +48rhrbljUwJBlF23X6s2SlkKQ0gEx9K4KmoLzeqdG1cWxyPP9Q4PNyuVIkmwmQyjqjlRzIFy44GX +MCACAV5VL9cu1SAR1j25YZHntmrXzyyv9QsLJe1oufjiYyc+9OyZz3z42hvPn3tw59T2cqecdZkM +jqeoTILhCEeTKyKtigRt8lQnEJea5qRpbS2417ayz56rfezpjS++cfRHr5/9wy++/Juffemt548u +n1wed+u2pNIoQyBsJs0LnC+zHoPgYKobljqft1quuNZ2TiwWNxfKR1sLTz968s6V9efu77354qUP +PXfnzsUL41a7kstaCk8iCKivTJKPzZEAp9gcDYw6fSwWnU1hCQJPIBbH1Fx93C4HuuwITK8cdCql +op0rOSUGE6aOxyBgMwkKxJZJIVkmPvDQyyvmi1e6T17sPndz9O5Hrnz9U3c/88GDz74w/t33nvyH +X7/zp1979p0PXDm3O67lcmAfUrFUJhYRM/GqjK0WiLVSaq+F3dqy7p2t3ThVuXmy8vjF/nPXB68/ +ufyRZyafe2ntr//stb/79Se+/enLD84VGw6JxBOJGCowusioLEroRHrsYpeG/M1V+ZXL5Xdf3v74 ++yZvPT3/uVdWf/6dJ/7hN5/4+Tfv/PJbN//7T1/9n//jZ3/29QdvPrP96FG3nvcZDKJV9FW75mnz +JWlvYF5acTaqxFaLHpeYvaF3MAlOTvx7R+1PvXL697/91i9/9bUvfPZ9rzw4efHUkqkwyVg8k6Rw +TJ2dTU0dm8Fi0UBCywpWN/BAjAdSclJVt/ru7si5uOq89cKpt1659NqD03/09q0f/+CdD796r9/0 +ttYmm1vnTpx5YNpNKpXweLwgE0OPurxkvHSt9+zFxpUl5bVb7Z9/76Wf/eC1Tz+//fkXln/7w5f/ +9e++9M+//8yPv3jln3758l98/fa1HT/LZ4hkWJOQw1UWoxQ8WRBTWzX6mdP573760s++/8K3Pn39 +E8+OvvahtR9+8crv/+KVv/jKzR+9e+6ffv3q3/zw3meebT17qXp+o1LzzXoAubLgmmWNE4sKNs7h ++03hif3gzcdXXr3WfOV69Y8/e/3XP3rjn//+27/7+Tu//O5T//43b/1//+9f/+FXn33lRuebb535 +xQ+ef+elUxVXT0VxSLJgYyXWINNpBlJ+JmYzSZeObNbYO7uFR09ULq7YN7e9l28P/+SPnnn3g+fe +fePRN99/r+rncFQEBtYppmXya0XqqMc+vWt89qn577596TtvX/zJl5/4+x+/8T//7c9+97OP/eiL +V/76Pz/zz7/95Nc+fvPsWqUCDpJXfStQGcbl8HmH2q3h1yfsE1vGBy/mv/3hvZ987Ynvf+bq1988 +/PPPX/n7P3//v//Vp/7lN2/9+vtP/PZ7d379x/dfv7/e8cMkCCIknUAphAxUq23pO0XutTPm27fz +n36s9p0Pb/zmG9f+z99/5G9/9uqffv7ir7998x9++tzf/vCpH3329E/ePfnLb1z6z58+89iZyqCS +Q5MEgXA8Su8vNk+Ocvs97bE9+0svTX70+Qvf/PDm19/Y+d2PX/vl9973J588/4OPn/wff/vZ//U/ +fvgPf/nG7757///4w5vfe/fK0RJgIRGZnUOSOHC7J4jrVXnsIiMrfmeJe+GM974z3gdu1d99Zf37 +nz7zjTd3fvL1u//2d1/67Z++/Psfvfqvf/P5v/jGk1d2WxvLk1p9RBJGxct1s9okzx61qUeXuM89 +GPziqzd+8+27333n5Lc/dviTr975l9++/Ytv3//eOyf/61eu/e+/ev3XX7v1jRdan3uifGVRBlbR +OCk2m5p+ZI6MxQtCai2fuTYSH9tzX7ne+NSzaz/91lP/+Jcf/t9+8tIffvjCH3704s++cuNnXzj/ +px9b++RjtUfX9cU8U9SosJyoaAuMEzj1SXewPy6uVfitEnF7mfv0M/N/8s6ZH37hyp9+/tzPv3P7 +9z958W9++sovvnXnF184/Tc/ePSffvn8735w95sfGn/8dvDylWa/aOGIoEhVkfct2ZivOH2fWQyo +q8vGM4fGy+ecj96uwGz81X956pffuf2zr934v/7xy//3v/zxtz968jufuPbKk4cSxVOomFe1osxU +ZHTsk3t1+uaS9trl5jdeP/j+Jy79+HPX/u3XH/9f//7jv/3RSz/67IXPvrB7drNWNHmJYhhCsfWS +q5d8LchJQl3Dt2vyjbXSgzO191/I/+BjB//tu8/8/kdvf/HVE194Yfy9j+785EvXvvbmqeeuti9v +NeZrTQdiSimzlANeTGTMqlvqZP2aSi/lmMtL3rVV796294n7vR9+5uKvvvPM9z999dsfPf35F0+8 +cWv4+qX204fFw5ExKMuuyqMIrwo13+5qrNL0zLrJtQx6u6E8d7bx9Q9u//lnz/7ld+785vsPfv9n +7//HX77106/e/tkXz//TT1/811+89qsvnf72K7WXLxW3moqAp5Ek4ZnNajCyJc/j6YHDDE1s2089 +vi596EblzTutL7+y/W+/e/uffvvm7374vv/+yw/86x8+/ZNvPPa1N/Y/9eLm3mLeM2yR82A43eq8 +I0lFlT057y/nia1C5tI89+zJwhuPjl6+2n/mVOUzT45/9c37P/nKY998/eCLz6989NHx7fX8dgNy +KqEyMkeaoGQi0xkB51U8HbCpxSx9at67tFo9v1i8u1t7/+X2m3cX33p8483HN66O7Wsj88rY3W5m +87JqsKLCSKD5NSmvCAVLrdhKrlMotly9aYr7Hf/aSvnGkvfmo/1vvL75l9+4/I8/f/kvvnjjyy+t +fvm50QePvBd2zFdOVw5bqkenBYzUlZLrjFjaBxvIoKyEIjk207eow5Z0dcQ9f9L54KXiF54b//7P +n/9//u0r//CrD/zme8995YOXb2+3Vuo5UzZRzCQxkUojfLivi66ZYt8TVkrKfte6sVm6s1d5/nzr +j14+8dWPXHjrwdpTR+21ti3zeCaZSESRDCIXg1Gvc6LgjwzBthh2PnCu7kzund9YLtE3V8xXr81/ +6cOPPnVh8e6J+pOnm+eW/UnVLFkiGByB8cJyhZjHsEUw8uCgS0EvZ2Q1gvQ4tmHrTVfpZqUT/eyN +jfr9g8Gje62Lq5X1Rn6tnIdlLJmyxFA4yqTTfDIp8UyRJQw0kcETKSGDehy/VCmdGtdvrOeePsi9 ++/zy9z959iuvbv/w3Vs//MyN737k8Dsf2P3K8xufute/s2kHMgqmXRXMsPQxnWMpLw2GKMO1s/lR +wS8L6UkWuzDUb606j+9433nj8F/+6lP/+NuP/9evP/bdd669fn/t3unm7tAHb2xoJc9b4Fif51wS +k3TBHlY6FU1oWmw/KzV1rmfLqxVvuWBuFoVb64UHR4vX12pjT+iYaknRLFbicCGVEKNz3MwUKEDK +lPMywYiZjIYTZdNsBX43CPq+V9OFsszVdanrKTkOAy1YkNRBbagKPrgSEpQ8rlbKIw== + + + hnKQJIhthkRYg9Nbufru0v72/PLA1fbq5uN79TMd9dHN6uXl0smmfqpl7FTNrYrTNaUMyIK5DJ4x +RL5BYGADEXCasZkknQontqrJA09tqPhqUdhvyHfWvY/eX/r4k5svXRpdnrRKgqDgnGtUg/LG/PJN +gQ1MtSAyukDBhJi2YhqC6ijGoFZr551GVmlk5UDnXU2yNUPgVZJWwapHIgSGGapW5gQ/nuTQjKrw +WUf1Krlqo9jiMpm8xPcDr10ATnN1VtZYCQwFlubASWXSQjzGRKMMQeYL5Z1SbSfcQqZXRM7mCclR +AwaDNM3ZorvU3Vgfbo/by3kza/KyLee80MIw0zOxRJLDyDwvdlW1Y+ltgbEjM/HYbAJ8va34WT3w +dbfmWoOyszMf3NipHY29axuVmzuDg35ppWxNil7Hc/EUNj0dTafCs+2RKDk1nQK/yXLVcmmz09hp +FIc6x/sy1XWFhkbVVfzssPTa3aMPPHX51uH6brdV0lWVoRmCEUSfIDyccBMpxfLGvdGVbv9SNb+i +887uys7dm0/whAzrJVF6Ti/Vc61OqVtxKzpr4HGWSOsxsKVTKIAqg2ZTKTuVNAg8q0pFNI7Tacj1 +dCxChLe/UhyKyCRm8nRWYHwGl9MxhExzaFJE05IUPrFyeCavh4dZFtNpDWxvKsEzuC3Qrmu1Da0P +gcNhosFpC9U2mUACNVf2Wp7sCSjP4xpHGomw0niawD2OKcaj3Hv/09yx986B32Rw3dOyvpHncJ5F +aZNVcooRnsWlMJcjXZ73JTsrFVMRKh4WhBk2Buf9YMlxF4eTs9l8h6QUlstadq/W3C/WtjjepSnV +UnOLo41YkpiZRWIJUdL6tr9iuUtSWFmrpMqVyfJZzenG0gbJhIcyKKaAZCwKd3jKSsXJmelkKi4y +ZE6R2xxXBZrCcDeTsRSpDLIknpDjybDVEUUHlt3xsn3LbOSDvhxu+QgftJGkBz+SlJaqtXWz7WQX +bK+nKnlNrxN0HsFsDHcyqEPSAUn66bRKEibPe4ZRVdWiYbTy+UU/N3CsBk/KCq/asLBKMRpF0kmK +wG1dH3rFfZIrxxPczAw6NY0AMEi6qlvD8EBinI3FWIryBSZHozydoS3RalSAl2yc0Ck6Kz6slYcT +YcFz+GwEIoWwNa1ZbeyLSjuNeAiiY7jl5yZBYSUW4dJJmF5f1eqGPcCIXCptoqijyB1ZbiUTSjQi +sGy93jplexPNmCfoQiQKyBF1ITCUPHg0QW5mSxuF5m4r7Ei7+rDbuMax2fnhGSmsXm673iRf3C7X +DnLlvWjSnJplpmcpBLHjUf6R90bmZgnNWCg0T5Wbh7a3DOidPp7JpNRETH7kkfTsLEmzJdNZCooH +truczrjxpDE7Fz6WEjkfwDwT3iWLzk5nUnGOJh1La+pSPjaXScVwBlMZwqBhudNqeGQpraNkDsGy +j7wn6hY2GakiKYWTBzeHK0ckn+fVOs2XFKOhWx3XGw5XLqYJDcE0Xio7+SEllFEywKiCao36Cxdv +PPaRev/ETJRLocATm375tGItM3wNxaxkWqJoT1ZbgDec9Am6pJqLtr8GjKgbXUWppRAzg7kY6XJi +w/TGudKKZvUoJp/1x/XWCUWtm1aXl+uKPSx3z+abJ/3ylu2PZbU2Xrul6D0UNzWrzss1MzsW9S7J +12ih5viThcmlE2cep7j8XIxNITovNcINflyJlcIjPJ7dGY2PDGded/qCPiC5JiP0FH05hQDt5BA0 +3BOYSHEYpmlaQzUmLNdMJ2UkJetaW3p4okE1B6XmiXLrJCf3ObmHUfkM7gpyneXLGGbJUhVB7WTS +oNgCrzQpvhFNWTOzHMsFSEaKRsNCsjiZk5QuLzZEqUkxJU6oS0rbcsfxhIpiPk6Vaa6BU0VObFJs +aXaOnpulTXMgKfVkWkxnNFZuMHKLEZuGO1L0cFsmQWVJthJLmUnUxdlqtrKvZ9e80q6b35meYaNR +URDritbIYA5OQOznkUwA5EzRxUzGiUQ4hq94/rKXXcLwbNh7NG3xSk/WR7bVxVENYHnsWDo6R6fi +PJJWCTJIh+d/nUwGEOXF5yigNZb2nOyi5a/o3pLqLtF8fXqKErR5Qe3ki8tXrr3QHe1nKJvkCwQb +ePklr7AWVgyz58Vws82KX1xME3o0LSUzDi/3uqPr3eVHa4PzrFJDCUvSumZ2zfQ3aLGDsxWYfyc7 +yZc3LX8R6CWdsTRrFFSO3PwJSR/SXBknA7gAxZjHKTeDGpLWBlSUmweN7plq6zAobRZL66fOPy1b +XU5r1xYuruw/uX30zPrhk/X5c73Fq4bRLxcW947uI6RDcnmAlpnbLLXO9CY3OuPrpdYByQaiWtes +gah0GaEG+JSdkWL2V1evnLr4gmp2Z6J0Gndz5d3G4Gq5eYWTFlCylCFyOJN/uBdOQzEtEnZhNsLa +v1SO4aooEbj+sl9cp/gszmRhEQV9pHlhh2UnvwYYQxBzcXLe8UYw3mhCBEpkpTYnD1R7WVBbOGGh +GcW2OqazAFSMYkCAvm4v5kq7heqJYmU3ntBUfV4zJ7I2hO9CiFwccWaiUgbP+YUtVqiF9e3pnKC2 +VWes2BNB7aYyJgDbzC4RkDXCSmg9Sqg7+U3JWDD9VcEYInhOsxeD8k4sCbA0AFoM21S0oZ1dghFh +eA7DfdNdhEQMCIxE+QxqauagUN3j5X5YsyXKwVWlEBeYbepY7NixxPEZJo0XNHNkZ5dFpZOIiamk +oihNEUKY8OEVFs+k8oY1krRho32m3jmw/REt5EWt6RaWCT6QtIZizgMIFXOQL691R2fM7HwS1RW7 +T3EVgi6yUi1NlTC2izON/9jDn8YcjAo0d9HJb/QmN3fPvjLavI8xRYLIVoPJ7u4NhPITaDaNBhTb +MtzVcvdceXBecwdhY7XqmqC3NWcgG13Z6KnOMF/bzZXXOKXi5kdnb7584vLTveXzpfZJM7cBmISB +zA8OTxw9DjOmGO1G/1xreGOw9mhzdFHLLuFczS+ubh48Ue+eTKXtfHFz99QTKzu3R2u3Di++YAVr +QGKAH1nvCEoVp12aL6/vPb26877e8uP55hFFl0kmp1kNxenPRMVEUgPuMu0N29/OlffLzX2CsTS7 +E9T23cIu8ENv6cbSzv1y69D2V0Fo6c4QJT3FaKn2yM4tQ15QndUkGh5287Lj9a2bHF9MIbDKWdtb +rHRhBlZlZ4URu8m03Wwd5oLlaFLDqDKC5kim6gS7udpp1VlD8EKpvHrp6jNIWNmPn4spQFwSUGj7 +9InLH5SU3u1HX/riV3/QaO/ORuUE4ij2uLtxe+X0+wbrd+1gPZWxy40dCI1YXJuZZQi2hFLAq/1a +50K2sJeIGxnEVNQmxFQ0RgF3zUTlWNoUAUL5vdrgyiPH0bk5AidsBPOQTBYwiZOFFJLNEAU7t1Go +H0CCjicVJNQnBYqtBNVDki7R4LDEOpCJ7i53h9dXDp4S9JpfWKx0TrQGJ7uj08X6pukNYDJVu9ud +XIRVC9vmal0vv90cXG0uXHWDDRhmAjUILgCaggzLyS3ZgshaY6WBlV0drlwfLJ0lwr3Hy5Y/0Zyx +oPb17IpTXNed3tbOtdOXnrFzIzKsKl8BJdxfurJ88oFT2s4Gw42Ncx95+4/6yycROstr8/X+xfmV +O5Ote43BIcX60YTAihVGqOBsllGqCJ2TrfnJ1v2d0y+0h5dkawFSZ3/xqqj3SL6iuSvt8dVseVez +J8BXfml1NoqnUDZXHhbqEycYo3SZ4juGvVys7Z48++TpC0/PRrlESpXk/mhyd/PUi17lLKcMBLH2 +3Ps/1+zsI6gLrLix/9hzH/jsc6+/u3vxOSO3CmrBshfe/OhX3NziXEzGyLKZ3Sp3Lo82Hj8493Jn +eIUXy5PV87XmRjTJI4THa8Ogfn7r5Evj9VtLGzfVsFBevdY5GS4i6mr2yPBXZWuRk+cb3QsrW7dw +Mg9SGShacyaqsxBuauUaoNkOj+7fe/ZNSW+RTMkvbPtFMMDLvNpnhSaoEVHp9Rav5Eo7M3NSMmXb +uaVcdavcPmwNzwEvJaLg0teWNm6AAJ6ZYyHX28G+6kx0b5mRuhTXno1Ixfz4scdec5zue98TicxR +FFv08nvD9fvnb3+42T+TTBl3H3/Dzy+lUTsN6l4bYyCciDyMJVvc7y/eO3/jrYOLL1l298LR3YXJ +SVBcljvwC6udhVODyYX5lcvFzp6iN5qd3fboPM1XJLMt2z1abENila2Rk1+v9484uQZqTTbmq51L +3aX7C1v3G5MrktkJ/NHJc+/L11cBBk6wWm6f2jp4/PrtV68//uZk82Yuv7Q4ORotnbPchXLzxPzq +9XL7TGtwZvvgsXM3Xyq1lofjUxvb9+zcCq+0GaVB8QVQYoIycPPbkt437c5k86Lq9FAq5+RWISlo +3orsTBbWHt08/Sxg0g3WgsbB1unHTlx+sT6+Bj4phfsZ3LOy842FkylcNLIdTu1KxrjSPlVsHuje +GEYxF2UZrqTb86rdkpwF2dmw8jt+eS9f2SLosJtVvbVtej1JK/vl5f761VJnr9zaq3VOVZsnCNoH +evRL234JVnmSrWyCkDaDXdtfb/TPuvnlVEbrLpwart2wcqtusKpYfd1d4KRmobQBqBaVOidUtk7c +uv/8O0e3Xlk5eKwzvurmJqJYvHDhiQcvfCaFugSTzxVXh2s3F9ZuDlav9ldvgEi7d/+1ra2rJJnl +hGJv5erawYPlnSf6S4+Otx6I2jASU3mxjuJutrieLW87xQ3JngfxU2qdLDWOZmZFDA8K1V1e6sxG +iLkoPTPH4UQJ5hmMgG2NUin1+FQa5KukdrkQdQ1WaCURB6js9PkXi+V10KsEHQASIDkyXA3SNCiu +bHGz1j0JsSzLlZ31c9XWCkm7ptVrAOWefnBw7tn+5JJXnKhGfXH5aLh+PQmijs0a2YVa5+zC8r36 +/MVq76jQ2NXNXr29a3kLTrBc7h4Vuqf03BKvtuvNkxuHz3jlFZLLdUcXqq39pfVLl288u3XqMb+0 +YhjtzfXLyxuXZK1RbWxdvf3KxZsf2Dv77ObpB+3xBcup3Lz+9JXrz+M0kDDQV0d3R4CBUuvICrY5 +qVOprN173xtBdZlggnJj3ylse5WDztL1C3c+vHXq6SC/ce7Sc6v7d0SrnWvsGcGOYE6cwl6pdb67 +eEOxFjS9eu/JDwEnIESWYIqM1GGVnmj0eaneaJ3szR+dPH1jdecaK/clYwiEjJABzubt3Hhl715I +m3yuVN+oDU4Wm7vt4bmgtofTVZItV3unCo09lPQlo11sH9bnL9cXri2sPdGYv2xll2W1efv+Kxdv +PK+YXRBXrNAAg9AZXijU9rxgERSsIJU3d29t798qVJbtYARozxVWGp3ti1efPzj1GPgF015Y3ryx +deZpv74nu4uyswjy9dqN5xqNFTSjaUarPTzT6B8GxRUIN9FcTGT8SEzT9A5OeuON6w== + + + Z25/aO3sc+X589XBUbl7RjKWIzEDdOzSymVJbmIYmHcXyXgMaB5zUZR7KOrPzFAZ1FbUPpDSzJyQ +SnuSMpTUkZvb80t74MviKQUCiqAK4Bp4oRoWkEc0mAFaqBruOChvhdGhh8pTUSqq3s2VViEYNasP +8lhW28X6vu5PZiD5Ui5Aqze+3Btf17OLtFhJZAxJrCyMzhtWR5RKQHSrB4/D/O+eeXbnzIvzG7cV +d0Aw/mj1CiuApPHDkDd6hj1fqW1Wm7uy0WLYrO/388Veo7NWqK87+WURZJhRqdRW3dwCJBFRbj7s +W+FhrGv442xpJwhpZDNXWcQp27SaN++9fvr6K9nqblDdCQ9NewNdb+7sXNs6cRuYFnR+c+FmoXlU +G94EDmFBi6a1Un586dozjd7O1CxBcVWgl0r/nF/ZgdAuFFfm+yfe/ui7L3/gUynMz5B5Tuq7hb2V +/QdHj35svPdA1noXLtz/xOe+2eqdAI8mGMu8DhJ6pb/86O7lD8CqYYSbBVuUX2JFwFuJ4is0V5HV +XvEhO506f79YXV3fuOL5E0nvgtdAyXwiY6XBb2q9dv+86cyb7oKVm/Bqc7x0eW3nTr6yy/Bh46R6 +cydfXOJg1YKtEmjX3lFQP1CtISwx2IRibZtmyw9NnwpkqHkbhdaFfOMUJzVoNt8fH26dvq3YnVl4 +A2JwcrvaPQcfyRfXLKsf1gdjrGJ5jaSKsZg6MydCTownLJIqVWqn271ritavN7er9RM45qVTOkj9 +SFwDpKnGKFc6QVJlzVlQrC7EHYQAJ9VAootaX3UWCa6WIXMUF6hGM40ast4stfaCynY2v9lZuN5e +vMmbvTRu5qrrdmE5hVk0XwWbJoKb65yynEV4m6i2CNLpzJ/ujM8WGtumPxGtLiEUKLFaqO1U2odA +DuDQVbOnGf1SZa3W2soWlxKIJoh5vzCieFuWA8Pu2dlJvQfWch2cESvVM5inWWPZHKRQWbWq+cZm +b/H86t7j4807yYyaCbfiN0arFxi5BtYpLAwudzvDM/3J6d74SJRqglDTLfBfubkYC1EQlDdOnH4K +NIYXrOBhcUI2EufBR7NCIZZggTec3LDeWO33t4/O3i1XlzK4b3nrjr9tecuKNQ+WAfjNy60sr1/d +3n8Up3MoWciWT9ZHt4PGGctfsoM1RgoL/u8d3Gt1d8AsZ4iAERqN7tmdU+9bXLvWGUDq3Oj2dj76 +0S9Mli+jdDVXP6gMzpd7ZxrD8zDhJJ1fWzr66h//5MkX3waxCt5TtZeCymFjcLHU3Hf8Rcvunzn9 +2KUbr3ByA4iUFOqiNrCzK7Ixovk2QZXy+fHSxkVWquJMDaOrScRNJA1JqTe6e2t7N0kmK4pVTe9m +g5XlzVurG1dZoR5P6pGoYBq9jc1bvFCbnmYiEUlS+oPF65XGKVkf4mTVz44//JHPXLr85NQUCr4g +hZVorlMo7pZKO7Y9EvkCDJ+TqziVxQnHdAec2BCNISm0QGYXa6eC0n6uvAVzDsrTKywpYUH+LsVX +Sa7Kq91ibW95976VW4zEObgeSe9xSqPY3IFRQLYlmSAs9dY+kPQm0JQbrOSb+83h5fHW46evvtxb +ukSweUmrhXBKqRjmgbPgxBbJ1kB2AkRxxs36XfBZyYwJKhQmJIXa8BV2bl11lli5IcjlwzN3NavN +iWWIUzAFgHBBrNQae1unn0TDFntFzegJYh3EW6G2li0to4T7sLBzB6e8ZEoW1bofLMwPT7j+/FxE +mImIibRFchUnO6Fpl+ds02lX2psrW1cn2zeKzc0MboFKMezRw+oQPMQFSOXJ+u3t0y9o2c1UJohE +lVxu0S+uIIQNEAUvn0w7NNey/A2nuA1Rg+H2cOkCSEQ8vBucxwgfGLjW2O8MLlabZxEsQIlCrrIH +ouvhXQUbxe0MElaBO7r4zMLyOYbzTWeh3j3VX7zolzcxugBaEfTYwvCo3tjGCEeze05hEyJxafte +sXkqhebicTXrLQyXztJcgeXqirlgeCu83M8V1vuji0FxjSS97c3L4+E+z/kZVCeYnJ2bTLZvre7d +p5hKBnVTaZOhijRZSCS0TMZOpOA9Yccry+kWCwssE8Rism6Pi/UjJOMkYkJ0jkbTmsj6vNzhpDbJ +VoGi/eKSYQ8rrTNy2Mhmsbd4A+yYmV1KZYxMxhDEMqyIlR1LxrzuLLdBM6zeGixfla1+JMaJcoNk +CzhbkJwByZcQyLNirVDZqHZPclJZM1ud4blsecMprLil5XxzHRIZQEs2OuBikmlDkDpgUbXwpEYP +p0sgeADtnd4JMKcoHTBSM4PnQRBqJhjVIQyNlRpwheONmwjuilKlPzpb65wGmWE643xps9o5AIcu +q3VNbwOx40ROMec1D5iwglEexWUpNut58252kEix8SQTTfCzcxxKFMFzucVNji+JjLM63l9dv4CS +NoQep7ZoqSFpHc2YF+VWMqVoei1fXrKzAz8/0t0hSlXjSXDlfqN16ASL8ZSAEyZJBsmUxfFNmC4y +bLyoCkLp1NnHCcqfnsZTKR0jc4a9MFm7M167p7sbU7NCLKnDcsQS0sMSNBpBZkWhYhqDoLip2QuK +WiuUJ5zgE7QFYUKyFc1c8POrljcBO4liZqW2XuscwGoq9ojX52MpGycKitKHt+G4J4vV/uLZzuIF +kqmAFqKYMtg6JKXtbl0eLeyKgq/qlaA4rnd3RuuXQaHFk8bMLBuLqzxTFbnq1HEqGpV5uQVc2hme +t9xRJmNFIgJBBvnyluWOj0+hszNhhUC4YNPsW95KrXvZLZ5yCju8XMZJU5ALvFiCkBSNHisBe9TS +RBHGC1OKIEq+vF6o7gfFEyBvIAOidD6FZcGx0oyPETZkt9bCxe7iVSu7qujzTm5J1JqSWml3T/RG +53Ami9EexmTBLZ68+OzlOx9c3LkLbh1BTTChwGkYnY8nNQTLA3e5/sqps0+Nlo/cYDxeu8zwtVTG +BsCADhGUrpWFyz43WLtHsRVRyLfaG54/z/Ag3gDVLi+3DWtiOWOWL81GGBaStdpVweU5Q8jycUTD +yWy9sQepZGYGmZlJxRI8GHCULOJcFaULsKwM5QXZoW40owlRNhZ0dwXMQra0jVG5eEIFaHW724XK +OIMpkDSTGYdkatk8iLo1WNZoQo7EeNeb5/jy7ByfSJk4XRPVUbl2qt27UK6fgPRBUblOb9/JzoeV +wNNaCrFooaFaE0Zq00ItmRTGozON5nYGs8FwobgPGIjGJFGqZ/1xLCzAiJNhLaAyDUNmCwiejSbD +Rj9BYSUorCIZa7R69fSNV4vtA5golq8DSiMRhqFs1+0A5tNpg2arkjrvFzYlpRGeiUtLghCsrJ8r +lRZ4zpG0KoLneLnrFzYkuUtTpbmwfghfKq+2+/vAxomEEonw09M0gee93JqTXUFRJ5kQIZZ5oUJg +XjwmQWirZpsPlUkW0jrDVUD5o5iHYVkVIt0Za06oSBlpQIH6wiygIILKgWyj6SIvtg0PDOwp3Z0g +hBFPsQQNnqUpK5Wwc5zWB4foFTbADPaXrvNqL5FWRbkCVNboHW4d3Nk9fS9f32SVRnt4erx9wymt +zyUElqsFxX1FH5juRLF6qtnK+qOFpcso7sUTku0vldoX6v3zqjXm5C5Ol1HCY8M+TWUc10jCVfQF +v7A9Xr3ZG14EawChHYkJnNAE88VJ9c7oXH/5NqQnzRoCuWFEPpHUUNxBMDOV1tzcWnt8pTW+0J1c +zzePMKYG1gZy5WB80cktA0VI5pBXepq1+LCnCQS+WyqOrtx4Fv4eSagUV2fFFvigbH47VzqpGEOQ +KwRZMMyxIHUFuWu6K/CGuRg/NRU27Wp29nm5gkKwoC6O+7LSorlyGkCSUFBUX147W66vpFFdt+fL +rVPZwoZuLrJ8JxKTp6aw2TlKlqozMzjDBkF5vT+5ev3pz6wdPmX7i8AbOCJ1+/uuD2Ie8ldYbARG +h2RMAZQMmYtE2bAgT1hv3IpE5alpMhqX4KcMk1PkPEuripKTlDIkvkQyrOl97Fj6kUcSsajAUGE/ +rFRaiCcYisklkmY65YEZUTRwjrm5WZalPZZxY1FibpqIzHIsDzk0PK9KEL6iDZ3sJq8MENxPZxxe +alFcOUP4QFmyNh8Udwv1k3p2nECM6Rk6k3EICvxykRbCSj7Z4ppsdGnOT6coJEmSpK5odfCVzfAZ +zePzazdRugx5k6J1Uy+aJjA5aLMGmO7++PKZG691Vi9zZh/Eg2Z0ZLWC4aagdNrzFy7deOP8tY/0 +l+6HhcIQzXHnVWuBYkuAPUlbENRRtXXOy23iZA5Ji4YBZDUQlRq8MDI/F5UTaUM0Bs3BBTdYE5Ra +s7+fLa5kiCwwG04VdXtSbp3NVU7AROl6ZfvwscHKVYIvsWpHcias2hf13sLypXr7BMPlPW/QnD8t +G0PDWZPNCSe3NLNba2wPF8+x4cm+Ur68Xazt5kprMBsEUwYlPBfhGLqkq+1kkgO/hgErUiXHX+X4 +lqYviHInkbL8YFVRO/G4jGJZmm8Y2bWgdlBpnWb4EnApXFh/fE4C5RlWPmzEkg6MKI0YJOnzXDA3 +iytyJRcsGFbLz6+A+Q0bUsQYTS5bRgfEJIJYQN2S0uX4GoaDBXAh78/N0brR5YXm3JwAwQXyg+HD +vmM4GcTjbDSScZxWUFhOpIz/FNb6Y5NJYDwBSdspQFpMnJ0jKrWVxZWLkO6PHSfgDaC1aKpMEUEq +IcMvP348nUwo6ZRFMvmZGezhY1MNki/FtRixAxKdFjuKNQHfF0vJgtzy/OXe4OJg6Y5ZWEugdjRp +UEwthYTFXWnWb7QPT5x/qbd0RzL6sThJ4xJDmywHmCxodt/Or6oeZMYFXqqznMPQKkUqLO8rRlsx +OvnyBhhGI78iZyeqMzacAc0CZ5pgloPK6vaJu1sHT1r53TTiMnSOF0ooboEG9nLrhr2kWct+eV/W +x+kM+F/F0MJ+XtEYkUE1QWojiEczZTtYsf2w5rMgFurtTYYvgBeGqJG1QaN/odw9r9iLsO6qWq62 +djS7m8zoij3uL19bP3gS6Ks9vCgqTfA4zTp42M0kYgvyfK1zfvvgsVMXnl3evZurbKEZI5ftb+/d +qtY30xktbEuXVHEyr5sDgasyZDYeo1y311s4KyhtmgO6gHmzOaFN0jUYBawpiJZGY7/VP1LMIfg7 +kinHwg4UIs9XWt19goaZrAHeZGuRYEOiBpEfVsufo3g2K/JZjvNKlXXdGRJ0HjiQFyAD6tMzZCpt +ZVAnCuRJ+LLcYbgG8bAaoa53MDyIxgDP8KssQFEq48KX0lyRE/J+sJTNrcKUvueRVCyuwczPzgnR +mJZCvTQGrqEGRsl2FiCrppMGjgdI2oE/o2E7DzbMApinm/OZjBtNm49MoZEIDSDhhDLQeLG6f3D2 +pYPzH1rcemD5a/GkwvBFFSST0hD1BcFcVOyVYuNCb3w37DeEqoZV1+22V1ijlfk5xA== + + + n41qjjHstE4GxVUU12nWZYSKag4XIMtUtpKIEE0QkDdVCwR52KIIIC3LlUZvv7t8RXJGBFdBsCwM +E/QSRlqO03b8kVPYgjmHnJhIwqqJLBcSDs3V0ojOcGUvv5stHorqIs0WIlFiajqZwQxR7sXiYbVb +lqvAEof9Spy+ZXVIOpdBLQA5rA4j1ERt3i+dqLTOysZySDUpEdh+e/cuwIxXKjhTSGEBggcMX82X +Qd7nwfmWwwp+F7oL+43OnmR0U7gHWsK25yvlNd1oRaIMSDVQbjhZZoQ6CKSpaWp2jrHMTrO9g2S0 +sKYBYohKZ7h0bbxyBwRPJCoyTH7v8C4QINApxVZZvmVnV5zcihbeofKiUc50BkF5FaW8qTkmkbZx +ugoKUJS6FOFwlGOoleX1i4Y7TCDO1CxPMJU0FmSIohtshqJolrD0VrWy+7A8jnT8ODY9TWQwn2JK +GcydnWUgshx/sdQ4KDdPc2KdpIoANkjxQLMM144nTI6tGv56rrGv2sNwH1HaiEVFAJLA1ArBJBIh +wsfWxzCKKFFUHgHThxqgxCBxJMPNLTZwPi8Wi9XN9uCwvXCyOzryisuQ/Sm6KP/HSXyxVG2dnGw+ +0Z/cqvYugGIBnRAW9JACjHIUY8HOgbBfN9z9RutSt3/R9haTiARvkDQwjz4RWrMyRmY1s7e+88TB ++dcgp0TDXo2SIBUo8KpKW/dXCa5eahy1Fq6yYhuseqez6QfDNOYkwfambfDmLNuot85WOxdprgFK +AMmogtgE4go9WtpAUAdEb1DaXNy8m8ECAvcFsQ5Sn+Kq4KFAPzBcVRDDAoDROAPBBXaju3C0efJJ +WmjPRPhoXGC4nO3MAwYe7sfoA2g3D59b3X2CC3vrMKAkq43NamMDpK+XW9XdNa90CGqTYusQsDOz +ZNg/RetEIuzsLI2gHkaVNXs1KB/9x0ajaJRGEFmSiqBYUEzDCBcEvMC3BKEDIRDuVEEdAeww5mK4 +B/EFCIklLYbxs8GCqFRAXIl8OZdbLVT2IMWjmJ9BNBIzFLmoqnkcV0ShAAjPF1cKlR1R7eN0ZWqa +iUVpCjdo0gUCQTGHpAqaPtCtEYb7kB+PHcsIfLFWX2cYb2aWghwXS9qsOsrWL9UXLhhWL5VgA6/b +7h+AW3zPe5GZOT6SMHCmKZlrjreZjIP2Q1SlNplcmTqOvfeR5OwsT7ENy1/JoDZEMU66NJtXjZZh +NsGBSkpAhK0xVBx3HGcUlDZUs0uzOdVou8GQFYswdphJnAjDWdTaJBdIasd0l2RjUTaXQW2CcgA8 +QJQp5sDJbQAFgVp2chNRCZvV+sUVQe9FUnokLpFU4GRHstryc2u13kVWgVzczFD5WAoY2KGEKsGW +InFIyj1ZXwRVQJAlmBywXSClANuAWFAXsRibRo10xtb0sSjPS2qfYKrxhE4zxQzuRxIawdYh0avW +Ejg4wFjYZSaCA4Q4vgDESzIBI/U4pS+bY7e4GU3KU2EPRAlMDUqA08+Lag+gLsqNRucwKG3Jeock +HLBjIODBl8VT1mxUTKVNoEdFXwS/PztLxqJMLCGmEJsVOpq1EolpybSB4i4Z3k8oxGN0OiWALQKV +KMhtMEQgboFSUDwHjgPsA+hSgq6oxrjSPA/zD9rjYRsvYWl0VCqMMVRLJmSgRxyziIevWARjcHGh +s/rh1z+pyIVYXIrFlUTaERSAUIBmwjIUiQRt2j1RrMTjElxtNArCTAYRxTBhU+x4jAGLR9FVTupy +ch8ja3NzTFg/LcZIQsDxxUeOo5GoZLrLqrvkl7YVczIbUd/7CAqajefCOyTxuOh6Q92aAOsmU6Ht +gmhiWF+Uqm52zIKlpSB1Gv9ROYHAbUVtmfbQy02AbSSlJmkllDBiYfs8nmHKYfsYpcHwOVBcQtii +tymbQwzPh3V45I6VXV5Yu7W49biT34Sl56UyLGIGIIc7aTSLEEVWaFvuxMsvqXrHdoaaNUqiNsFW +MkDFYscOdlV3FXIWKBOGq3FiuKkv3AOZ0MHaIJmcGm79Kk1PIdE5QhBBOasM20TxUiQGV2jiZAEA +mcby8BFBXWDEHq/MxxHr2Ax5fJaIJQSOK2GoQeIGxKZsjnR3idfmUboYTUpJRMdBKgtVyF8AYMOe ++KX9bLC5tHbHz6+B3pP5PIQhUF/YZRWSC9tw/fX58XVJW0yl3bk5NpVSE0ll7uG2ZE7s0HxTt5d0 +G36qzcyQiYREUFmc8qMJGcGzYHXBYCr6yMmugRWdngtryONEnmIKqgFmeSkStjSVBbpYyC2ytAvL +nYjxYfXmuBCZYyJzfDopmUqpHAxbjeVYNCyEFfbXIAOwzDBds7PATgkEUb3/n733+pEsS/PD3iVW +VYa/3nvvw3ufkd5nVlZVlq/qat/T3dMzu7M7OzNryOWK5BIUqSWllSBRBASIEARID3rQi971J0m/ +EyNKgCABfBCgxCLvROdkZkXcuOd83/cz556Mb3CLaNaquqEPgAwwsIY5EoRmuSyXdlhTbznuihMK +mo5YyAk2ZmEeSU+3AqlYrdqOPV3tvgEQsVyIHytVT5L7prVALKpVZzg4+bN/+Le93tnOjlIqeZo5 +luSc4z3yKTQa+WsIXesgqxkWnrFlGF3d6Lj+KE5XfrgwrUFOGlbeQJKRJRfyCR5NRWsJUsQLoaoW +ukn2EghSoRvdJDsczF5O168H82d+stYtzH+f5SOa8WGHTXOiGXPLg5w+RHpoZp/0LBPIKuJ0/VVr ++KHZf5+2X1oeXjhQ1bZhDUDi+KbTe5W1XgTRCR7w8qwQVyuqxMdRAHkcR/FJlt9azj7wLWtdpcUN +L3U8d4iakpSupA5ND8k21axl0boumlc8slErLi8/c/wp5IflHxoe6VyftQ69cCHKcHlmEK5anSuZ +dD9HMowYDj5IB69pesGwjm60QHaageFMkMPVut+gYk2f5sUl6g4qi2EiRe1jWjRzqmggOL/W8HVr +MZi+7QyeGmbvq5/9xbPXf6jbS0Ub686Ckzt1hnhbzRgyBPdCVJzl7kEJyELWqNs7JalcNlxnDixC +CpEt6sasSE/z9Mg0x3XySX06TTru+dWqWK9qQBVZx+VNgS2Ot2K5vFzWNps3qFPQJSxeteZyTGRq +7SxZ4gyPn4hPdmRRbAIV6zWvUjbqeALXdJ11HG3A2pWq2mhYUFNQZdC6stxl2UwQ0kHv6ODgrSx3 +arXQ9o6J0ZParFAISpeRinLDqmI22NB1lq3uRRATcwTJxJBeMLZhNEFeg+mHVu+VYS8se6abI4oJ +SxWlUjM5Ple0PmwyZkNWE/LJQkbPdBe6BXs7s70ZI6Y4OYyPqnQkCUXtqFrTJh2xV83OOWlPY41w +qc3eTdI8g0Ain38erbPWSad/qzvTOmnCFcA0kU9JUtsoJUOH8Zl3yX20IyQ5RbkYoAmXpIIoe5Y9 +se0ZOLEojix7TPqRcflg9jFrPw/ik7x5rptT0FPgDPv9U4YLZK3b7N5m7ad4L4yCE7NKQ4cQ1c2Z +pg2AMxAPDNtiuDZKtUFF1ZrJcn6nd2zYw3JVo+jIi07SFsTDdd6+gR2rbz+eUZTbeOsa7UASe8FB +3r9ZHpDFEOhYlHMzX/3yD//6+vYr+D4F2OXt6s5S1gchBEbzlOcz0+y0++f1hldvOKgdCCHFWET5 +bdF9Wa0anjk83v9MlnIkEs1BYKQ032qPXh2efx8lu5WyoMuFIhUoZ0w7tDfEValiC9Iwad4ABqtV +SxTaGB1mFVNh6G2yp1RqFZ2r4exto+ExdIyHLGKej5DMAp9DbjVoH54OOurJE6HR8CW54/trsJtt +T3mSt9CZge2sBBkObl+zVnio1oIWcpqNyHK0PYMukrW+7ayTDAZ5An+ham340zA6GM/eN7vPRGXE +CT2G64rSsE5FNJtCTkiQE+bI9Zdkw7bZx/mhrskGVL3XHjxzwz2IWwHvQiOBdVWNCe1qTSecJa3j +2fp9b/xKIzfXWkBIx+6PxperzdvO+E4xx/h9GK1Nowd1BFHqO0PTaDp2QVrGqDlEKbnZZPQkKaUa +Npg9zw58b2YYPcebK8ZYVIdgYdUc4iI5IbadEa4zKY4hF213iQSw3WmcHYgqLEMBDdwdv857N8gW +w97dtoAEjPShMFFBgEQ3OMbZFKMfpPsUFz9+zAAAi+aF7c5hAOsU0MAE7Owefrk5+hpJK0hpp3eN +KwQS6la/QXsQFe3exf7pl5ev/hhmGaObzD9AJfJSk+FT5AnArVpzTHOQ5Lv01lduq28B+BVlqDuv +VjMkZL7er1VVqDtWbMo6JMdu2rrQtz21YSscOG4hB8K4HtTygabNIRiQ4bZNFp3qNZNns1JZYlGS +3rIzumsNX7789A9/+PW/Hozf7OxoQDM8qhUTwgz4RlEQY9Px9PV09c4hG6q9g8MvoviA55t1Oq5z +TVHrZ63jm+c//4t/8t+STziUe4IEsboo2s8dbw9JiGJBIilaD6NwHMjXE9QCJ2Dy544/N0k7lQXs +HsXmmrnyo8sguqCYjGy64FJByqCLgugQmAOssLy5ILd4iSyg9cbP3AjnR4BApoWuo17wTawoqRNM +4ubhwfn3aQsAtbD9haa1Lb3wnI7tgMjIvZve6FmzfSlKTUGIPXfq2AOOd2o1FuqU40MEZbb+CChg ++RjlZpE/xhlwrAs1omndID5oDe7SzjXAgWJ8BBqpxUuJ4YxlfUh0TgHAOY3zIzyB7L6I1t3xi6J7 +A+ZC0UFKuf4hvBvPg2hsP9j0x+9Md65ZQyfa1Jj4SUkUuMjzpgzjUA29Udfwvq63HE5fF+2LbTvm +YjC59AIo1dwCLmkTcD0Ew/nzn27f/UlniKxbnJx9g9pBkofZsemuUM6aNoad5/gAXtj1ZkG4CxWH +PIGKE6WWoo1UfQgVtLPDVasaiKPW8Bp0IMgFKR+xgBFo9W5VtQe5HsdnurGQSXBTmnbLJbZcFjgm +VuUh4Fc1R73pm+u3f757/uNs7xO0JUUlT56AFsmfBsD68VziuLOsOJvM3sFggv3hOKDKzi6/z4tT +io45qes1b/cuf/zuj/7jP/qzf/75V79hhFSS25Bz8DWOtwbIIKm23UX3nGCtWeC7uEZFDdI8rgc7 +jOLCNcO+yXoPyClt1+1ZQoU95KRhjiGNeCmTlQ44KyctNt4Y9pThM90c0lzA8CDKsW6sDGuN2lf0 +iSghwXoWuaPdBLKp5ny8/DBev0elb8eVQsXxYgycEaScEwBQUy848vw9oAd8XL2uGnpHIR1vMZNT +C76g82ww/VzXhxTIvaKohDfbkpJpVl93p1aw8aIj21tzYkzRJukblR/P9z6Ndj8a7krSBmShQ0w0 +s6MaZFcb7CR8xGT99XT9taR2K1Wl0XAUtSspOcN6UA6iMrADJORQNxDltFQSGnWdI3+wYJI/ZLMA +I1O80PanYbKU1Nzxx73R26z1LG2d+/ECDkg2uoDKIFx2+hcsHwpinhQXfrIH0BP4Zg== + + + o+5VaxrDuIbehSssPWFB+p6/tJ0lK3SqDSg3lyg6DrJELZUVCF1N7xkmZNXGtJeq1tt2ZQXshJWK +SlMex6U0Qz7kEOZI16ZheIrouOFukBwYNmgoLVXNcjWQlKnjzfICvLyp1zGNTdedymoHlFqpe6o5 +cMKVG+yl+RnwB/AFLZcW12l+TD6XXmvRlMNJPVWf6casQVLIw4PhEj9Yw+8AG/2CrBdRDDSSW61D +bmWms3HjMzs4MN1dBIKD2JPaSEheLCgmwgN8Z1jkM34lOeN4X5RDcVtE5O/FjAFSEX4cVg7Kdrb4 +7Om7v1qe/xzyFQIYmaOoeG1fs7pOuByuPuWDl25yoJgjwCwNmUEHmBAQH8Swokxc/zyIb9PmrawR +8K/UZMMcDsdvOv2XbnjEiR1JG8EFt5snrjuGxoMtHU3v+rP3kjZh+EJUupDZ3cGzON1A+OFf/XD3 ++Pz7py//2A5XrJQyYuSGsKUbcBNGpxnjvPOiNXjrx2eo1kpVpmgL6gsggxrB22EmLe9ANRcQe747 +Ac6oaidvHu6dfBgsXuvOviAN6pQPW2c7423jbJ8X/DDam+1+vtj/crH3haj2kQY07QN1kU4Aokbd +Z9nCC5eSUlAguIpKPvJR7cjkY/rEatWsN0LX2x0uXjNiXqkZtYYJ0BZEeCUXzyfLViWN3xY+ih30 +ypH1877lzLZ+JG/QMcu3ZW1cdG4w0nLFgG3s9l90Bq9D0vYigb6t1rUG6dPRYylvZ0dkmKQ7uLl5 +/eNw+VQ2Z7zU5YScF1pxeky6+sptNzoczj/sHvwoyDAvU0VfyNqI8Dvl1hqYk+5w+GLv+Puj6z8e +Lr9sMEml5pAL4wsesKZ2ZWPihmdJ8zptXdreCthIhEHdpVl4xkEQnkOqbT9dn6jHOuVsW+rEQDw4 +a8WYKDpqvB/He60OaXYPqo2S8+7gLoz2YUgFKbTdUdY51byF7i3z/rPj29+0hq/JXbm6SZprC5Hv +rrL8ClbCCQ/c8NDxdoNwI0vkM8Yp2mtQPhC42b0Kkv3tDfexrI78YA82gRVbvNy33c10/eV4+RmS +EIBDPnDYhFSbFa390eLOTfYHi7frk2/WJ9/b/gGKGqFpd66Hs3eatSvIY9OemzZG0RVk0tZHlBD9 +/enuF1ev/zxoXjIckROyAj0wt9yh5fXy7pGXnKk6WRhBWaG4anX4OLI+QD4CPVmG6UEQH0MCWfbS +MueNRlCp6gwTikKLfJVyFCbA3w12TWvJsCnQaecJ45hDjRBigQKH0uiNn08XbwFoNGPwgtds7Tdb +Z092RIC/pLQpPhMVWNQRWdqtbj8D05z54XGUnOJ9TRss0KWo1PMO4bJpWLOyjGdirnh5CPqjmbxW +c8tlReZT2+qRmxpa3wqP5offnz79VRcgAAZXO5D3q8NPWesUpF8HFIhd2zsK0jOAD8WGyARF6XQ6 +p8Ph1XByh7mtNRKKyYFdwJZK3aD5SNKHUX7dHt1FrTPdXaoYr9Deyvh8azG6mgFA3pO1OS92qw3S +5wigZDqTrHOZdp7m3VvbXahaFzpBkEgUHB/CeB9wBBB23Ilh9VgxAuSiHo+uf3j62V/62Smyt1I1 +KLKCNzTNHkfWMTxwTZxfAoqD8KBWg9HWYck5Plb1puWOeSkHpoVkHRUmcclyKWDTcNamswqTQ0kb +wm05wbEbbOAaTBuCf5i1T4fLl1d3v7q4+8PW6E5QxgzfhHYNgs12JWruhift3m2Un8jmCJ63TrAr +j5NNDqlWnMjWXNRGhr1MMrzpvqjCJY0W+69tf5dhM5rJKDbTrRXMKQFqIavVFElOWp3jvHkWpiCX +IcPC0GWi2I7iwzg+oomhbsfpiRcdqtaU5zuVqlep2gKfuuaEYyPS7geerns1nN6lxRnEM835cbI3 +md5F4frRIwpCNMoOiv7zIL0xnQXLJqWSQtFBlp877pLnE47LoSRdQC74MTj2/H3AXaPuSFILqqMG +xGASUUN5jkWhUIRchncwhl500B69HK0+ZMWRaU41QiXNZvtod/8Nz0VAVJgRXu5qzpIWmjUqYISC +FZqmMZbkVFZTMLVp7anaRhCGNNuk2KTaMGW9r2x363FKodqz9ujN/vXvustPkDrIK1APqjLNLibz +L/30env/pQU0Q+EA1bct5pd2cIhwQ8sRZNZ6NBNQTIC01Mxxq0f++JrlM1T3fP12sr71krFqDQDa +afMZyEhRC9Ps0qxHMY7njfFaEH2DLCzHZDVbarXb56rVcf3+/vkXUROGq63oI/KX5g2fZmM/3pgu +VErOiTkEvBsfJs0rIr0E1EWMUXvBNErHXjCU9S5If3P8U965Q9C3rY58J1ipZp+TMl4u0s7p+e2P +hxffZcW+bXWhRvxgd7x6r1qkoBiuBZvjBPvT9YeiAxzwGQhsoYXktPwDzVnRPCYcSsk0zH6a7cH+ +mM4uUNENTvaOfx6nZxDAitKrN6CyRra9lBXY7Y4gdnVjVzf3PP+QZdOdktigHNOaNugQNkrSxv3F +q9b0Q3/6mWmvSmWtVFIx8zBfujVhpQ7OgLKK0gsfBKGPYArKVU1S+mBV3ZiwXO7FZ04MkOmDRgUu +A2ZSDW+rxsf1ul+rOjQDPUPu+0NIqHqH45NyRYV/tKyl663I7Q8ZSBt32hcSZB7r01JO8TkndVDF +mrFOsyuOT3VjYCETzHGDTstVn6JAqd0oPUk7l4o5ENQm+fMBdz2efzi8/kUxfAG9QfaxiAWJmtyU +IaukvuWdueG17R/qFgRGtl2DHWbF9fEVMOEFRDVkWB0Cj4cOhyVHjkVQ8s3um9Hsy6g4Esg2MFcQ +E0UfaPaEk/I6ZbJCFiQntr9W9e5OWSY7jijSQw2MD2rgMDSphQKPinPVmZVrtih1UXcUncpKDwYQ +BKeas6L7Ala90nAAwnF2kjafQm9E6Z4fTkU5CbxxURySdQl/VWeScs2r0xGgxrAnjBDUGTdtHu6f +fnZ19/Pt/m2v1oAQjQN/3eldi3ILjiZJT4vWTd6+CZIj5M+TJxTD+IYFA5uxUsuJzpv9j+PVd06w +R+5bcXG5orBciJBpRAVFFWjpigaY9YI911+xfAKE7/Zv4O9KFatGJYzQKdVchAbKNoqPQrI75QoG +mZMKRuxX6bzSSBVtNZi+b/cu4C8EIQFPHV/+8OL9X3SHz+HFylWrXHUEsQ10JWatEZjO8v13f7M+ +/4Xuris1r1qxLXvR699B5f69/7D++IkoK8PD539+dPPLMN7HdYJxMA+mM0JiN+gEUkExDjqjzz/9 +8J+mxTPL36VFXEwL2MLJsCrQXSvN2qA64nTf9gYMZyPiDSoV+YHnHs3Xn6xo3eCCvDg4f/qToPYV +YyRbAwoaRhpCtqFOdWtEukJLBTTtcPrNbP1j1n4KuQsJJIm5Bw+bHQQJTlKUG1DIwyC47nQ/88Lz +ag3iM8QAu+N3WedOMoZ1Lqpv94SQ2a6plaomikVaPG0NXuPKKTYoV3VitPkMEhS61PB2W8NXJze/ +XR7/6KVnFN6iYmvqsF4PymVy9wRTKsi9KLt88eE/mu99w8AlOZP24LbZvfPCQ9jDGu3V6MC0ZjFp +xJzCPpDVMH3c7DxtdhGREVmHkQgOaOZA0tq8jB87kjqS1YGm94kVaricAD+1gMhn+RQ/NihXFHPL +mrrenGw8dqZBet4Zvyu6t2DJClkSh3oPofw5jnwUEuR6taKLUisIYNUP4P5qDcinOMsPIc4rFdOy +9/Yufxm3rm3nQNfnmJMkXIxHJ6Lo7ZR4WV/Y/kXefTdbfe8EB3XaLZXkPNu/fvFzw4GVcB+X5Goj +8MJjqGVgBUw6ZFVC/q7q1I82NcpBPfLyWDdXs+WXx5e/EqTOk8dkdRReRnNmkCU7OyosANJGtzF7 +VzBoFOT9+DVmdXnwXdy8qTay/+3vyHH3//cF/H91PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7ttx97/+HTkOpL8jx9/T +9fmXb2Yvf/by0dXqkT5e5y/w88nL73729ttHB4/0F+H425/NPr7+2cevvnz57U9SB7+KgiSTwpO3 +Lz+XrN8/U8KTpMNvP77/+CV+efr65edvbcnDU7v471EkxVK0/d/VT4/8VpQ1g7SVFEkry6JWIbWi +VhoUUavZTlrtZhpLX/w/PqmZBHkepXka5VGSSp+TJ5HfZe12q9XMiiKT/t2r2u242Y6azf+XJ/3f +3u7zf59r+vzRh0eXj758dPyoLVm2dHWJUY3fPvrm/xxcTAa3nb/Fx8/fdn7/7eQtZuT/mEy8ChOw +fBTO3v7w8fXbk+VEujp49FTaziY5g7/9DtfS+r9Ggm+fSUkUS3FUkJd/+Pd6AfnHf/eif/f/LSnF +NcbN7eVm0vYMj3R9e4Uk/B2pSNtJ/Ohq/R9ICulXwouJqnc1o6+RhixdTujJ2ky3F7I6FEXysfyy +2vH8tWnPdGvESwXNx3iVIBei0iYNlIXYMDq2O4nSXTcizbk0vNaYmu4ewyf1hlavKyzjkK5S7tSN +9u3wwHB3FXvCK02KDcJ44fhjQWrZ7m4QHiX5pWrNBbGn2StJHXB8TjOhqPQUY6KZkzA7ErRepW4z +fCYobZaPKNoXhMJxF2l+boe7mj1m+FhQmoKSalab4j3F7ETFadJ+1hy+c5NTvJwRM5pP4vSkNbpL +Otdx8yLvvrCDA9kc0UKsGkNZwyRkDdqrNyxeCEQ50fS2anTrlIX3EqUuxSY0lzJCLpFubhNZ6+nm +SFZ7gtxvNm/j9EJQhhSX1CivTvssH3vB2nbnNOvTjGeYE8tekA56DOlnxPGJZY7b7StOzATST2pU +b7jlioZ/ZdmU5fDIVX2mmnNJnUjqqEo6AYX4JS+0BKGl6WNFHbBcJsk9mk3Ih1ELOccXDJswXGya +U8dekG47XFGjglJFw6Nas+p1DCRR5KaKBGBCinIEPqpW1VJZrDVMigkYLqGZVJT6otjB2RoUrjxU +9AHLp9WaStMBLrJaNTkul5WRKA1VdWpYC8uezmbP8/Y+w9q82DLtZZAeWN6cYnyqYXNshhMqxkxQ ++g0maVCBpg3CcM/3lgKfRdFGM4esmCIleLHQrYVhL1W1FfjjBmXhgeT0giPD2ZN1ZNcSyUl6eSst +mnZFufCivbz31E9J503JmDBSLsrt22e/GkyfCXLOi7njHbR6H+PiuaxNWaFgSI/yiA== + + + 4ULSjJ4NMV7S9lefsEKLFZp1yqvWbFw2nkDaEhl9TmqKas/x94rO3Wj69vDia1HPWDG0vGXUuu7O +PiadZ4q9UswZInJ58Yv14Zec2mowgRMcDmdfNvtvFHMpmwtObNFMgGnkhZx0YKTcclWnmIh032bC +ShXRMVg+k5Dw+kDChEttTuywQoeX+6LWJR08lSHmEBmIp+GFNBshUWt1gzRXJa0zY5rxGw2XoUKW +iZBgSCSBb3aKyyI/q1S0Slmt1+1KVS+VZQQRgxXkoaovBWnMCQPT2FjWbr3hkY4YQiErfYQMgMAJ +wIe5Hx7yUr5TkZ6UeCQnMMVx1ra1QrGQs9VdmiYfZr5T4qsVWeASRRmp2lgSm+WKisvg+axWNxuU +jVyimaxSCyg6YVjSYUq11wRYKBujqGISqjrPF1F8kaTXcXypG9NmcfbDj//s5PqLx08atrdLGiyO +Xmj2jHyKOIqIIy0z6rRLPhabxvTmbrhyvLmMDJfbp6ffetGqwQaVhinL3aL9ImneykpbkpNGw9q2 +RloBYTipw4gdWZ95wWHWvLScOc+Fnjdr9q68dFexeoo5xswbzjJMjjb7n4fJniDlSMsgPvXTc8Wc +s1xLVPqcSPJt+9HiWh0j4kIUoCijdrqyMgGyyfJIkAqKcUm7E6ODnOeVdpiczXZ/WB19P959y2uZ +YnTcaOXEu1a8ka15lF+PZp+1uk8Xy3fN3gUQWBByL9yLm+eWvxHUsaRjCCNBbANeSPvUugUoqNU9 +QeptG/t6CFCtbgsi+Zz8OhPU2JhBWMWxKM+8+FLUezXKxDzb/kGDjqp1Z6dsAGc4PmNYIFgEmGI5 +8pWhw3rNqlb0WhWh9Bk6cp25YYyRUZWKXq0Yv++BXqmqFBMKcs9y9jVjoxlrzzt1nAOaQVb0WdLD +qMXxCMFEkMe2e5AVt5LW26mI1ZrGC6QXmKz0BKEJKMBlb1vEJjs7AlKr0TB5LpakES8CQnOGyRRl +aplTVW2bRheFUK651XoMlBZI8/EOJ085gLaY4bTlikywTmjq+hhPkGRQ3igID4fTd362efyEMr1J +UpD+AizpoNQHGvBiu74lApQVZkBScMImS0Lc9OzZ3v5HzezTXCTKLY20LFnxMmbSBYBIUst1F360 +ywm5bo8kvS/rIwF1rY22TW+9ND0Yzl4G6SbON26yVsyR6S2daA9fZW0gyt1W68KNllXKrFEOz7dM +ay3JAwQUGELaJbCAL5S/V6cCiilUbY6p1k3S3ghzKytdResa1sh0Z5pFPj8/LK7c5EjUenF+FmWH +hjfzoqXmjYve8/3jn4bzj5h/1AjAxHNmQNRyVUMKOe5eu/cW0XG8PdOaSnIHsEM+dZ8JgF3Vuo0c +4LgCBCRKgKkcrMcgstJQkKaqvomyO5QMK2RJcmr5+zXKr9ScSs0FW+EkAD1OSMBiktJHvdNUAHSi +Gh4eJMeqOgdekzrbJkFWteY2Gj4y4UlJ3DYvyzRj2mDiegNXEjYoQGihGRPMNgiR9P8CMLIRL3UV +fYk4AtNUtcfxHvAHiU2zgKMUCCmCRvm8VFLrNbdWM3d2JIZp6sZCBN5KA5rOVGWQxJswWJSrKi6+ +1iDcR9HI7YFuH4XpuRdsAG6lslKrGcCuUlkol2VZavU615a75pVBnQ5QESxvbfuqjxAjyzvg5QEn +kgbTEAOG0WNZWxBiSe1r1soLjsMYoRwIYgpyHM0+cEITsQZrkF4YBumPhvOguFxvk7XPoHbKdROg +B7A1zDly2wt3nWDVzE9/90d/c/XqJ17NOTlVLUiyTZSeF62bTv+ZZo3JKHBmNhXEgW7uOcGF459b +7hGeJohNQ+u6wW6DzUDWFJNhJm13Y7l7urObZWcXlz+OZ3cURxqUB8lpe/CqM3rbHr3x4r0kPvjF +z/5J1N2r0i5LOrINMVeQB7a9hLzZqhQP5KJsm6/hzHjQhAigfzq81C5V+DppHJaypGx71bpP0TnL +tR1nZTnjUhXY4lBMW7eOHP/U8Y80c7nt5wLBhtA49bpOuj7V9AbtSmAWdYgI8lxBURFFgVz0et0E +AREBU7PLFbNW94GTSC0wCCCrCgCpKk92GGiwWs1pNEKGSQAUCAFyBrRYrmlVymaFFElrOXuqjqLo +Y9pR0ZKEzBnj5MAZUF6lYlYqFkXFAtduYBR1j+fSSkUGiO2UFNAWns9xSYmgpcFB7LHgI0+UMS1t +Qe7q1hKTpqhjaDCeA3ZJeCHD4FVFtWGWamapamF00/G7WkODLoVmID1QpBYv9U3nIG+9yJvPfX9p +6nm7eZC1zhRjhASDbJb1juct2q2r9uAFxcS2PTKsIeQiUR3aTDWWtnvU7r9JW9CxTcgSP9rIWl8h +oNT3o8O8czVbvv32+3+8e/pRUAvdmVrBnuXvwTL8vk+ZrE+Q5AA61IVuTt1g3/EPNGNhObvgStff +36w/X+5/1WBzis0lZWhaM9tZ4rWms0rT0+HgmRusOIn0Sla0IXRgnF+1+i/tYBNnx19+/ZfN4QUS +nuYSYJ3hrKDYgajQw0AAhsvxPSiD5xLSvNheAJcIlUh9SRk1KK9Bwm3gUa8Dz4EVE8Bms0V6DVdq +BvKE41sM3yaNS8SurE5UbSKKfYYp8K+lilSra9CiDBMAlyxzpmsjTR2axpxhc2AUC1Zlk0rVrjdI +17x63UGO1Wo2IitK7Qbtg93KZZFh4mrVKZXAmCbLgYxQsxDJIYhDAG2JHWSaLPeJ/5J6SDMSGqmj +qgNoZpwT+g3nxPUjtSC6atDzwKWaRdR7zSiXdaQToeOq8XukQv7Icg/05Pp7kGqQ98gxnBYBFcSi +UXeg2XBC0imbj8uYBKktqT3NQB6mtbpO+sYCJKU2iYW1aXXf9qefvOBA07q20dldvR7P70SlpRoj +zRzZ/jxO97v9GydcVeuu484sZwqNl2bnYXwZRteoWS8+l3XkW6Srve7wmmJ9qHFZGXT7b6arT8vD +LxdHn5vxQrfHk8X7qDin+Oa2Gcowys6z9vO888J0dnFJljMjfUXZlOEBJv0oPc2aT6fLz5P2NcV1 +BWgtuSOTgQByJ26w53i7xFGKbUysYU0g+wW5HWfn890vw/zMSw7bw2tebtZIDXag4uBEwLzgEUh6 +TZvijUAclaqpKd0kPYT5RUogIpB2jnek6TOmgereIk/DR8R50thopBprfIUwloQO5qFU0Ss1C7SF +a8OPNA1t1q7WSBehSg0hUxk2hAdHrKFUbXNRZJeGsWjQ8NH+1pH1kB6NOsxU1KBcvISiYdbgkVOK +Jmqf9AKuQxIHFDix4UP5C1u1AHhU9QmCDr+ATLCdFb5CIOFHvJHjrkEfIHEwYKPusmxWrdrlsgIc +I6KuagEJWYb0lCGoWIcdAxc7VSRY3cYb8VwTuQRRJ/KFqU+qDWSUjGwslxSadI0fQJSCdit1E5PG +CVGlwj9+3ICClSG5mVhVgZ9TUv7uQlQ7NCHl3DHHw9HzIN3HaR1vA+0tak3VbHvBUDfBWTFZK8jO +oXibraeGvYY1ZoV2jU45oQMdG0WHtr+oM46kIjMHjr8ynKnhLQR9yKvdKD9b7H0dFacswMGcSTry +duMnZ054bLr7sNt4Pg1xIhbIBIZPTGftRReGeyTqCwleSR1DyQBst31aOwyXongbNMRM1/NPSQtC +xgWegKwxXigugbSI7cva0A8O8uY1zSc0F0L2s6SZLwQ2OMWGtEAEDX0cx/ssyrAsQ3vj/FvTnTQg +fmoIegxnBwDBV0keWs6JYe7DektCr0aqmPRyRS2XyjBoQoOKObYHhUyCzpBW7PCzSFcgEhJjO+dj +QezWqRjaCUmiaRMoc0nILK3PceFOiUU2Iq84rsWy4KkWCJpjcwvmmnaf7NBV0kgXiBeJpKCgS5Fm +rm2vbWcX0QGHQjMTnb/taYjfVCoqLhtvQYZAuEzEAwDI0BnLFsg3XBgENqifUGfNJO1E6y5kGyoC +tNtrnV2f/axUVR8/YXEqkW+5UMvegBd8cjE1cLpfrvBPHlerZR6wxqBA6jZkJBQmwtGgLTh9iGrb +WrjOynbnCCvss+WuJKNXpw1BjlWtadkD4FVcXDjBLsWFhrtipWaVNHhqIsHi9DzJzwx7Wmc82CVe +LsCPNB/xShMOznB2W/13YXZlemtOLqL0GGmGWJMm0eYia7/szT7Z8bGok+6xyCteaTW4AK/ykhsn +urGQOdqQ5pFLUZqdBckhfAfxcZSLwgQr4eLxIyKFagU5wl0a1ixp3bjxiUwarJP2c3B2truwgk2D +i0s1Hb/R9BGqD3OlkLbLpHm9JLTwFiUSAgZBhCJimVASctQjIo7SBjJTjIcpRbYg7jyPkiyQM6Wy +SoQ3UIsNwbBlolss8AtRTTUbyAZWBQOKUosmnjElzEt6yCLfYEUhtAzkFc24tapq6jBH0y1TY4xu +qWxQjRAxhTvb2WkIfKzIbZo0CAsrIFACMq6mTlz/CJhMWLhh/b7xLmkJyqXwtoAppMqTHapcEZB4 +MLyiAGqzUEcwpIAvgjZKy4dZlrrb1Q/pCWmubWAsotyEUSKNEflY19sNSi9X2HKZrpRZmvJ0bei5 +C0EIWMoIvBEUJiCXpn2i95RWHWkgBKrWQrDA72RyYK4bNll8s+eKOaQZx/EnktbCb8hCDQQqQ6Cj +6Ly0vF2ogrg4pHkfE97YNpCloFrlIs6OgvjA8WZZ90yxRpI20Kw5PCmFTJBare5de/iKl8HI/dbg +ZdS81t01bBdFWnMOk/wq7V4D9KDTzHDd4CLS9LNOGq6BDePkBEiLIdjuFGkArULULxWybBqFx83W +jWoOWcbv9C/tZFaj9Srl1DA0jnDlZPZ+svuN4ix4MY+zQ0EB70CNGFC8CCVoK0/OLGtWqSkUZYhi +Wq6IqHSEGwlAWpqKOcODUhVOiOEiaSaBtAZbVatupYp49WDQKNppkAdZFmsQ9ULysFTW8GRdX0Ak +wHGwQkyxHoK4s0MET6MBetIlKaMpR5GyPFszPIAOriHewtqQoROqAeR0KhVJkVs8GwK4wFkMk7Kk +g21B2lOSFV3MT4F3r9b1WsMkXddruDATDAX5VK1hFDrLBVuJJe/s8MBhYNTWI3i+t/rq278mi2Ml +rlZTIfPwS+QtqLCGkzNxv385GJ4gqai6qEqBKqWwn9tsCYFUklgMRk/hxeBGkbdbxItqpP9v4LnT +7dKKUa/5LJNwpJ9yrukDsvSktGerV5rd3ykrVXhPIokj1Rh3+ne6NfPc5fXLP6hSGlnj4uGjm7Lc +NswhUsvxFv3O2cWLn8xgXt0mBiBalgdhdLY++Kk7eScoPd0YhcUJI2UUF4O5VMj48LA9eB23r/Jk +/+37XyedgydlYYvPpC04itF29mVtAjs/GL+Efq5UbGgG/Ih/db1d2GTSyV1sr/Y+qk5zp0QBK0jv +eKWpmYPl3qfl0TeGt/Sd2f7Rhwbn7JToUomX5Bbps6kOwmAfhIUykZScF+ItPckNAg== + + + KcQXI9tFOWM5N0iA29HvF7pLZXg9ONyeCQ0mQgilrjdTtO6THX5nh4NPB49sSadpmLsy0Q8pI0TV +urrFEwOYA7cFhESlQ2757iQtdquUuV0Wg9GAwEsISVUduuEpUst3FxxSSMp1fQhbByAl7apBZCBu +Ph0MbmS1BexCRSAVea5NbYsO4hwZpcqpYyPHkFoKALlWhegiLwStw1Een39TZ6xaRZa4GAYE2FUq +kYuvN0Aurbx5GkTLaoWXeFeVQ46Bs4BPcWSlYztzwJ1mTiGTaiDTul2pwL+4HAKhtExrCEgHBTfq +AY8MkTNSmCQbW0l0NJq/VI0eQJ4nq38o8HgrmAuWrJfOL1/8osG5stw0zbGidIFjktIRpEKQ0kH3 +9OXH3/rppk7kaI7ascyFHx40+081e9rYsrnmjquMo+idonUqKF0ORlhqq+ZkuXj569/9Z/PdO7yv +KvdEYBoTIEUVdeUG57Z3kLSfceoYdsyxoNCAtOD3DO8LHWto4yDepzgPM2wS4dRjOJ8VAmCvqLVF +pTntXf7uT/8lKwalEicKUZLtAWkRo3IFteNCqoXxGpYHmMMLEcf5vJCCFHBmDDwOdj9++5esBLeu +bu9JxfjK8wXoD1CTpJsXL/9wtnoDTimV2FpNRiaAXMpVA9iLGKn6AOAAXQc+BdpAG1crcrksQdE5 +5jwM1prZqzQsMCZwcqcsg0FAyobaNdSeY03CcC2JeRrv0owH2NnZYSkMnOjkAnWaFcea0f49DNbr ++tYeGsQngr752HV6njvatuGGRCSZgwSDIMQDAcIElso8HI1nLwGPjx/VyiWcHGZwCLCFa4CFrFRk +ikgpHW+N7zk2A3ZtbyLYnACt6+2UJWAUmFEUCwFOnM/hVsoVksBVAlyGICaCkJrGqFlcWMEuRD5p +r8lFDLkj5vJShqTSjKHtLWAhdWvMS80w3o9bp7IG897VjIGktlW9G8Vr1RxUKNCZRyQ35ZH+wmAo +ygIX68YA84zzc3JL1noAw2oDJ2/54X539KIYvXTTE0HrN5gAwEvMOGVVKVvW+nCjkjLSrA0nDcPo +IoxPIK4ajIN44Qoxb/UG3FZKpDId1mkkjFAqs/gq4jqT07x9kTf32t1DiBwoHAuhrPHlCocfMRWO +s9GMhaLDbyaQyhwf1SmDVBP8rzlAoqbpZXt8VyW3nEwUVKWCSUZ1S9WqTFG2YY/daFczJ2T1ifUa +da1WUxAIRJ8jK2btBp1C5CvKLIhuBLlLLCEFxYVw2BD2DYqs3Sn6PG0+g5sgTL1tLl8GRFR1jnbp +hivyWZbsIxkoKgIm8xz40aapAH6EYsh9MdOc4jk7kNllFe/LMKQtcplIR5W4XeAkuWujAHksY0g8 +CHmoeFC0L8kDJAkgi+fgRj2UHjxyuaITi0qTizH1GYi+XrUcfbJTkh49gu4inbWJOKmD+mUCoWRB +wwAdsxipPAJsAjzJokcVqZWR3s0MEikC1RKucVeGMWahWITEckaS2qS5hBVbDN/lpXGSPesMPySd +WxgWRe2CRgEjyGFANEiQYjOGK8DaeFORzy1zRHG+bnRNc2hYi6S4CZIzQe3AwkOry3DQcpOXCid6 +GrffuekFD7fI5bzUE8k6Q9FgLQbiUB12+m+d4JAX+xSborRFuQ1sQfljXBwHFbdQSJP3Tp0sEJnE +gzdsIK1q9QU1F7WWIMGRtYmuZkgx8kIiyBnNIj8TOAs4VkHug4XJXUWxCbKG1MSIttZ+qJlLQexJ +Ypd0ui/xVAPTqJRKNNiTYmPoSVZoSUR3+YAUBBQEUa2ohIbgExmcsC8pyL0WxbYkeaxrE5bzSXps +F0sRI05si3h3KE+p6zp7FARPReHZiIdorBlUHZQ04fg2x+U0DbWJhIFgLpC3ggQBP/a9PddeACLo +RlCvkV7Jjx5VIaKqRPOoOyUUGllKrRPzm8Fu0MRrmE9KElC0VvNqNVx2kMQbBAhZLbIJx5AbqQBD +DASvArVJ/CAPL2E2SyUINh3W+PETDgBOUT5ZoAPbwjzSwNKOrk8BKaD+WtXBC2W52yBLGWqd4Eyq +KmPf38cM4wJ0rVc0j3k5JQvvQlszN3503ey8sYMDGDHMRpqdGNuGxQi3pvVse247G1UbgSyqNUuX ++838rMECok1wsRcdDeefkuYN8odiYjc81qwVqUc6iIoXXnolqAMES5R7XnQS5teGCSXctP2ZpPRs +b5cVMtIdmIfT7+rmlBcwURr0HoRNg84bTFGnkzoFRmtrGvTPEHmCohDUQjWgrJYs/B0bVatao+aY +BAmzclUECZruXHemFAu8IguGjnfghyc0QU6XJXcDQbtduHueb9XqPnSygAqi7VKZg/8indMxUrAG +po6ORR6kUNTr/s4THuUP+Q01UiGrXuCgWDd3w/Da80/ISpE+ESVcgERcHuUA1SUiqHqOu8vQLs96 +utKulIUSvFtZ1+QFXgLGJLUP9UuHEBssl0I7gZsYOpOELr4KbBuF9vhxHexWrZC7k0+ecI8eMRXi +OgEdEcCkCmzhCvD1kx1ZELoch9nr8HwvivYNA5q28O0lxya/l471qoms49kcnkXkm6WSXCdOUwF8 +NequH5xilrbLFxYKGWlWIzcawMtenYQpY1ko1byMi6wYYCJEuV4nNyMgxhrQe/rcDQ/I5hPKkdWB +rA5ZMYclKVUV4CFqJ86OQXMU2ViSsTw4FMkJXnAkqaVrY9taWi5UvcwJPqKs2UPZJLeKDAh4b9f0 +NixZLIK2AYC4OG21boAQIWgVcyHqM4ZtH0zfH55+XgfxNVxkMijMJnuBwKdxlYzIaTdP6uRGXihI +Y8NaSuRG6kBWJgxfYP6f3f7y5vlP8GiQVeUqnLgvi7kqd/JwXxJTlhj5Dvh6pyqUa7qijfzwMMmv +HW8fKkvT25rRLVeVHUIBGcENviAPNiZbcbhEVfGvOrnLzwTw+JB8ujoV+F6jEaNmeTap1zRYM5gy +XNV2VwBZ3SrX4Aezdn5lma16HfgZ1ilcmFGtgWrxZFPgIlNpuuYQ9FSH4IcnQorWQLXQPDLRwAIm +cAZggeVk6VgR+iqgVZvKwoBquE+e0E9IYmvIBHxTq9gwBRBRDOw85pDNdGMFWqk3AnxtAAZrfqkK +m+ltb0AMfW8ftAW/iRHhQfbhAKx2BHIlkHAYO7keJH+C0qsQwvUk0tUdVOJgNuAfFRWSg6z5A1tw +WphljJ0iMQIRy1Uo/Ia3XbJAufmVig6yY0g3eWSsQJadkQM0XhUC3Hg4ULmnGlPonGpV4nlcAEg8 +5/B22xvx0Jxpeqw7w52qDBYw7ZlpTZAnDTpGOVN0QhOgVgXOV5UcF1ynQyCMbq4cb687fBO2zyG6 +kD+mvYByIOswKOeKjAsQxKYk9+qNkBc6HN+sIOERnbrNMIkgNePsZLF5P5q/gCMQeLLsA9JHRvFc +CvmqiIUmtSxziAkB7JAlWUi1Bkls25k59kQ3h8jhrQy2tsv7GTIfpAAphSlCwgCpoAl9bwE/hclk +MByykB6VSSN1xCWk6WBLFhbm+clj9sljplrRGDoBcWigezakG46hIxAKsQCg1wamy4VypuoOwrql +dbNc5p88biBL8Uu64ct80zBGW0nm6GoX0hHsDG8Lc4q3QDqVSgregtw1ICSI962XnuDkqiImspCy +bE6zbYrFGJelqr4D7m7Ay+dIfk0bef6u7a0ZjtzRIIvMZenx4xqolqV9hnLLZaQ3hgZLiHngt6uj +TV7MWTYkkMhAGDRlpU32R/HE9yHH4HlZspabkBUwUoAgX79atVDpuH4kKi/knJTXaA8TiHzDSxAs +fA9VGUZ7ees8TI5ZsvzoQ7bBftKsxfLwRxny34JGjSH4+3UGL7eK5oVmkOUgso8FEEruAiNkESyh +64K2Wtv1eUgXCLyRIHXI+qfSJTvuqECQ2kAqxBfwCCVPEomARoCC1Y0ZmAtxhNpBQFEIMI+yPvCT +AzfYFcSBqs3wWiiQCpIfgKP0WDZBemBOgCQU24QkRhw5FhOVGsaA3MUWuqo6VaQeTe4C4OI10M32 +XrMB+wPV2mAizGS7dTxbvXoCZGtA9za3e6V08FSlCuXvb+8uRQhKpYzyV/GV3NErKTs7cg1cRgXI +E3AcwIGF1m2Y0HIoZFAYwkeTDWBILdAQpItS2qFLO0hOFV6+QkYaNrNLRU0fP648eVyjaiSXcGGA +BTBmbXs/EdoJ/wTTgW9wEryLQDacLHVzDqkGGH9S1uCRif3ZegeQHa6WZkHrbVHoQqsA/SS+YGlv +5wkssEIkIrKIjiGcNIPsQlH0PqQOLxaiMtjeKSY37wxn4kS7VrCqESsKyZoQJal08SBhqiNvYx6v +IkYspLiQKHmB6ByTbKHsC2Kh6wPPm3jBzHIWojJU9ZFKVqKmopxEyTpOj2CQRbGJMFUpt0o50Ofr +3S9MewCHzotJpWHvkKH5DagFckN/QnZyakORbNuIdypWqWJxAlFK8FZAbzCpqPQNey6q7Z0yD+9c +rRnATNC0pAyhlkVphGRuUHAQOhhcVHrj2WeT2SfT2pMVcg8RhUO2oDTIrZPtVk9zu9euxYs9GCUY +dkAfKqtB0CNk2JahL20L9JEj8ciyw3azDVnBLinVCtntiaG53sIOVojRdiUzID69rNIwhnSTouFQ +yFaTBlkFDSoVa2dHAott9TBSy6pD+bBkCVQUclMbMLRZqwLWUvApHBy4hmHJhlJZbtWryuNHSKFG +pSwDgZH/0H6yPIH/IoaizKki2d4A8qpVze3O4Ygi98ExRhlD3t6cUqFVGGJCc5ZvkkHRZPtHnazz +648eUU8eMeSqCIXlgtiRyO61Nr5RkRJigrQsk/Jxf59aLNe23HXSPAuSAz9ex80j1YSLnxnu2vLW +UX6atm+K/gteGXFkYwkMIIzwGMEl914FVH1PkIBmAYEjuYn8tFz49BFijfhaLghrrZt9z58H0b5m +znVzppCb5kPHXS0WHwfDO9dfwsiT1ScOjqwDLQSRDDek6UPY9gYH4WGh9pE5vNQxnIXlb0xvF2YN +anx7z9fb7nQdS2qfgkKWun58UnRvZZOscoM6G1vcK9ds2EnL2zfdIzBsiSxaAtli219a3gJXW63D +iGWcQPavms4crAp3CSRHdgGEWbK9BwZkD2PnpDaSDWrHsoaqNhalAZIWLo8RkCRwAXmdLFYTTCCE +COIWclnt87hgJqP5tMGQDQzQmRycMo1SbdfpVFSHtruGam1QMVljpNzt3gMNqgmyFsZTEFqq0teU +HvIK10ORe+iEd8itJRHx7cCJ14jtBecCRiBXNIqCO4uBirIEeAG/t3xvWm/oAF7d6MXZEQoB+Im0 +VI0x5C5DzFHTcYZkbzPlI9CIoKxNRXXEkA20eZkgHpKH3HYEoRAY4VMARZCcJNlJmh8j3HDQDE3S +ldyKZTPEUbcxw6v+7DZuH8MNRfmR4a1UpES02+zdDFcfs96t4SzJTV4hTpvHuj0HPg== + + + KGRloIfouOFKd8ZBuqfqfcdfJu1T0yPb80x3FTfPuqPnrf5lkB0p5hQUFkaHMWSVOdGM6fY5cydY +9CfPTW/GSgUGotm7ln/kRMeGtycidlrf9pZZ5wxAlDSv0s5zzV7ySlezFioS1RgDELb3JZusmEla +Gw/bn/vxflxchOmpYS81bSIrQ1AnTZYs+gLZuBhAV7PQljIiC16GusjIbRS5ixPioZl4Cdkbz/DA +GU83+khgXmrq1hw+VDPGcXoYwIw7M1UfataEk9s18BoyUO76yZEb7Ylql8SIicg9UKUj47QmKGAT +pIeqNVGMIa5T1ltQEYLSsv2FF+2h9HAZktbHG4FekcAME/BcKAqwUZGuDXV9rGPSVEw7QLiPESFd +KShSJsJL8CP+NQz2QBaA+jodkQ02dAIGh1sxzXGU7Ba9k7i5F2bL+cGbKD8h+3+4pmrMNHMla2PT +HmfJKkv3ZL3PiDkiS5NtYA7Oj+EQUhOgl2yW84J4JkiJbrQsZwwJDR8Hw+56J2TjnIPZ60CTgPt4 +saWSAK2z3pkVrsPiJOucO9HKjYBdAz9dDhbPB6tXXrJBDgTRbPfoMydcS9CH7gIlH+XHfrpvBQs7 +JF6vP7yZ773V7TEHCHKWSfMUedXsXxb9p7q70e09UK2i5ZKKKBfAh6Q4iopDL9lDttBCbocb3Zlo +9tj0Vk50FLVukvZN3r0NslPPX+wefpW0ryg+U81p2rpJ2/j9RZCeqOZQVFtIFYXsjU/AtobZ6w5v +RotX7cF1d/g0iA+BKhSbmu5SM8cs2cGYbrdGhLBvENvbm78u+eMOqalqfdOap/mFE+4a7sQJ5nFx +aLgjXs5Mb44h4+Elh5iozvBZ0b2MWkeKPSrDvAuFYU1sf+0lR/hKBugtkuJkdfBZe3JrJ3t576ro +3+RkC/dBZ3Kbd4+RXabT643Px8sXefd0e2f/95vt+6o19IOlpIANHRDf9i8Cxm64DzYhhFKckCw1 +hrIBPMdk4oX9ID6Yrd5N1u90ZwGokfUhHDq5Zc+HstIKkt3+8sVo983m/MvbD388WL3TnLnhQQtN +ahSE0MSwF3FyOF++603uMEDLW9LbBQFRzDRzAHWkkR2806Jz1h0/zbtnYbwgf7AjIxN2VX3Cky1q +ozA7Sjundgh+WZM/ydF6qjlwk10nPvDT47R9Pli8nO69CbKFn87y3nHaPUm6J8XwMsj3moMLL9u3 +wqXpz4Akuj00vYkbrfGq3vDF2fXPz25/6I5vouLIDNaIRZTtxcVBd3KXD15Pdr/BnMgq3AfQI1eN +XphuQMdJ58rwN7q37s3eRtmhH68sH4k9i1tXfnbmxsdOeNjpnp/e/BAWx3U2QuCa3dukdeWE+064 +hyTHk3VnGqRHvJzSnIvsjbJV0tq0BmQsRf8ailExh168YYRUJJBLKBsIgBwDahn2lCF/EdOR1S4v +4jdpq3c7XLzpze+6k2d4YLowTFSQbAx0b+pnB352OJi96oyeIVh+uqHYQJILwwCYtE1nFWdnqNDO +6Ha+9+np29+Odt9iepuDp0nrAqHfXH27uf52sLqLioNm5+D46rOTp18vj94hVYCEbrxnhSu8RZzv +2950NLoGhCK1vGiDh+0TKlkdfT7ZfZe1T5d7L5v9Y1ZMJa0bpgfd0e1g9WaI7PIWnNRKm4ey0a5T +umq0szYg62Awf3n09OdPP/62t3g9nN2+/PCHcXbMcD0/vQzziyg/74/uNmff571nyNVq3RSEVFWa +frRoj67T7mVr+Gxz/t1k8xFxbPVONvuvDGfO8dBm0NgDy9lL20978w/z/W/C7GQ0fY4CgaHTzFHS +vu5O3q6Pvnv56S+//vFfPH/1i7sPv8j7p2G+N1zdDdev8v75cHl3dvvT7cffFcMrzR6qVtd0Bmnr +CAA1P/hsffJ5a3D16tOfbi4+14Kp5oySYq/ZOxmuX2fDu9bsTdA5D5rHw9VrSctozjadYXtwMz/6 +Zn763fT46+nR1+3h85Prb7vj06hYdmfP084VkCrrXo8WLzcXX+GFfoxcPWTEWDY6JqIcb+L8KO9e +jtcfFwdfGe7Y8kZxtpK0xHQ7QbLsTp5P9z9M9z5sjr88u/4REs6L99xoH3iL4Rfd6+7o2XzzaXX0 +TW/yFkgLrhSVlhusmr2r3vxF2jkPi6O4fdoZP/WyPdWduumBnx/G7fP+7BVmeHP+jRetZSXT9bYk +wAhEmjHLm1eH19+tzz4tDj/tXf0wXr16+/kfYWbAnm60Ozv8cP3uVy+//M2br3578+L7onMQpevR +4s5wZpa/0t1lWJwe3/xy9/Sr6ebd+e1PKHxOTK1gChTNupezzYfjp98fPv3Z5vTT5z/8/aOrL+Lm +vmJ0bfJXLdftyYvV+dej9fvO8HZz9o1kdCU5bHX2XX9M0abtjWabd08/+93TD7/+9P3f/6f/xf+Y +Nk+j7Or0xW+Gyw+atTSc3bA4N72NSLYtJUAqTohAhc3eYXt02Z8DHz7kvWvFHM2WL/7Nf/e/tEY3 +ddrJm4enVz/kbcQLwPhVa/QSwPv+s99o7oRiQx/Kqn+z2P9ydfjt4fXPV8efvvru73//J//CS/f6 +4+cXL3759O2vbt788vD6m+v3v37x5V9c3vz4z//2f5gdAH6H3cHpfP+z3dNv9i++PXvx082H3+xf +fP7i9fcffvgLEOvJ9efPP/v19OCLpHd99PTHu6/+annxU9be789PwuZSMdpuvJ92rzrzV53Zi8XR +p9XpF8XgZP/y7WjvZdw8zDqnVjjLuyetwUWrf3H+7Nfj1QfN6brJrDu+cmMoqzXB4fZF3r3uTV+v +j77ZPf262dtv9Q7DbFP0L0arV4P53WL/3cHZZ5+++7MX738FtPSi5WTz9uD8q4sXP98/+2p58Plo +/TFMj6+ufrh59QeSWljeECmxPvl6vv9xuHpz9fJXz9/8ya///F8dXX4t6n3kfNF/hrTvjF6k3bvW +6NPe+S+DcFdR2oY9sbzJcP40653258+K/nl3fL06/Bhmh2CxoncVJKvB9GZ1+H60eJHka8sZgA0P +L79PmieD2TNcrRfvDufP5wfv2pOnureb9c43px8m6+d+PJvuvc47h6P59dH119PNm/bwYn387i// +6b/GqYJkffH8x2cff3t4+/PZwYf+9JkXHULQrjcfP//2H02Wz2UtSovV5ujt1asfb979dPril7cf +/ywuTvPWjROs6pQJedAcvjx/+duT218NV58NN58GRFRcLndfbA5fCnLMiRmUdtA8Swm5X/fGzwm6 +JvP94/eD6VPY86h52Zm/LUYvxpu33ckNI0YM50N9GVYrSjdF52owfzU7+Lg+/W5x8i18X7N90Z1c +t0eHs71n4/Vdb37bHp5eX3z8N//2f949/SBpRbt/en33p9d3f3Z59+ubd7/uzp/vH7z5m3/+X/0n +/83/BJVy/vyHZ5/92dndH20uf7h68+vrt3+Sd69+9Qf/6J/95/+2PT2pM54fH7YHz2b7Hy9e/vT+ +23+wf/nV09uv/8t/898vj98jB/ZOPs333yHl3nzx57/4zb/68pd/2xu/vbr49Pzlz5EeYbqbdZBU +V6Pl2+PbX7z59h9/8Qf/8uDqx/cffvn85TdONCt6p63hddw8Tlsnw/mzt9/81bsf/hq80OqeI/Es +b4wz+MkG9lPSp6I26Y9fHV1/p1tN2x9k7UOEGNIiaUOCnhydfvFXf/1fXz771vAmhze/Wp/9MN18 +uH77x6uLn5Leq6Tz1HKm3d6tbo8UvdXtn40Wz59/+N9Jeu93OaozXfQfuIOkvXfnXF05p67u6pxz +Drt375xzUtaWhAIoIYkMhiFjbOOAbZwwYAO2xxHnCDY2GIzHMzY4jGfm3Dn3POe5X8nPUz+AQNVV +a33fG6rWeuvMwvbFzswJBtQLk2+1tq7d/TFWTMfTvdbYodbghBjqwLUlcnOJ/DyI0khiTI/3nF4R +JUIAznBTsezC1OLNJy88DGC+unJqdeM0L+ViqV62upCvr/dnTx49e8+1+z8EGLK8eOTuBz/Unz8O +nshPJsEsgF/OlA7Xxs7Wx04Fw93V1WN7Jy/G4lUMJlpriKFBID4TyyxMrV4Pp+Z8aFiLdIBPoQWk +ADB+PZSakYOtdGHm0p1PbBy+xeMPgOjCyGyusZOqrivhPkbmBbF24sTtd9/3dDDUYoUiVFS8vJKu +bvXnbyG5nAcJYETEg6g+RJbVWigGLbYO05RvHw1nlnA82eseDOglt59hpUSqMFtpbTRH1+udxbGp +HU7JWZ20HCgUqxuF2na6uAIsJun1Um3+xOm7lg5d8BPhfH0521iPFeYbE3vpxoYWH4dZPrl3/dbr +DwWiVZONFVVApIEa6UDRNscPw6DNzB750svf7k4clJTi/PKZgzc/OLl5ZW7r8s7ePROrV0SldfOJ +a7dcfBinU2qoAz9aqK1nSsvF5npneq/aPyQGG8eOX1lYOUHx6UxlId/aCKemo+mZcmt76eCdndnz +odjE5MxJks8Om3HAfFEFW1cnuCp4DV7pZopz6UynWp/DqIgEhB4fA07k1Xo0OdUaP6pG2ySXbkyc +lEJNigcVUSeEksmlWb1hRmwksisuXwD0ZCwxGtAbrcH26OyxWGGOADFJZEulpct3PKXopUxpcnzx +dL1/OJicFNSyGKhgTAbn8nAX4fgAwTVBzal6U4OuCXeD0Va2OAvCaXpqd3b+KCifWmd9bH6vN7PX +mz7anznY6q3oeuPBB578xvd+urJzi8MTwMgkzRWhbFKl7WQJxnyCIBNXLn/gmU+/WCiOgYSrdI9A +a1RGT3RnL44tXgERSNKgvU7mqos2Y0+xTPGFfGMrVVzsjB+9/aFPL+1eCMfbxdq826sSXJ7XWiRX +ALrJV1Y3D962vH5eEAvV5kKmMk1wKT+RorlqMDLIlNezpRUE1fVgPRLroWQUhi4QM9wZr3ZpNq+H +2z5UsbtIho/Gs/3u+O7y7uVsYwX8hcXOWR00Smo4FVRDtUR2Pl3ZqPa3JxbPrB27IwSExWeK9QUp +WBS0wtrRe6fXLhaaG/nqcqW9AXjiQcHUK7Lexeg4TkWjmUkog+bgYG/mSHtyW47UMDKgx+rJwmSu +uVrtHy50dsTQKEbGY/FWNNEDLyAq1VC4y7Fpv1/TtHptdKfY2QwmeuXOVqa6TAvpWHoMioGVi5xS +5dQqRkedXsWHBI8fu2bs7hlB/WgU2s3QOSwojZyfSGJUPJpolxuLQAGFysLc5tXG2M2h+GJ/4kyl +f1gKt8r15TNXn6Cl3D92dqBEhhWbodRyeeyWSHre5hIJOpYvz4OHypQXW5PHRmfPLm9cW1y9VKht +JvMLspw7fOy2Zm/V6ZX8dBIlExQP2DutxacBEILxAc3FtnfO5vMTGPhEqZbMzYbiU8BcwdhkrrYZ +jXYnZ0+kS7NQugC5FJsCkFSUSrk6X28v0XzKj0UwIgrlHdC7wfikqHVShYVYaiKRHA== + + + j0U7HJfu9ncLrU0p3OOU+o3HSmEfmuCl5tTiLYredCNB4Ecp2G6MHqn3D9VHD7b6hwWlkc1NnDp3 +L01HOLmWqW9CU1RHj8wfun1q5UwahCKZPH/p/snZHadhSKPByAwjZFFKd/ok8FaSUuOEAihSRswL +wW6yuJRvbkHDGgs10TDHZ8ORms1Bur2isZ9arIvaKEHXGB4kTd3mYFBM1vSinmyGEp1kaR5skRRq +J3MzoWhPVnLV8vT8xtlYYZKRCoxYFNRaIDQqB/t6ci5d3aCELNBxrjhX6WyWOxvl3g4TqPnIyI1y +HffhSirV3j1xz+aJ+0udQ5LWRDAYjTB4c2PXj0sxmVCng2HYFFBzKNFTYx09PfDTUUCV3uRxmE2a +z8YzU/X+MUDFYn1RDZUpLur0iFYb43SJFhtqtVOhcKfR2y21dmtjp0PZWfDCXlSRA5VCZS0YGceo +Aoh2SsigVKTWXqmPbrpRFS5ADw9wMu7HQrRUJqQ6YKDxvCJQU7SG26cWaxtTyxeTucV8abbd346k +pmDiQoHy0aO3xZN1m5sLZ2ayte3WxJnB7K3B6CTJV1AqKSvF40evptOjiF/PFucm50/XO9vJ3EIy +t0xxxXi8Pzp2GMUikWhvceNad/JMNDGtBtqBYIfmS3CnmeIML6VhpkgqFkkOQrF+u39ocukcK5Qd +diYgpe77wFPBYN3jC5JsVpArglyLpeY643tTC+dAsWczvanl06xc8iCSDxExPOT1Bt1uzY9EUb/x +bHNu4XSyMO/ygaeWPf6g2xd0esI0V+OVttnK7tvvBq+tBEZHTIixts0jgvLklSrD50Uuu7ZyLlYc +d2MyQup+IgpVrQR7itYmqYjVghN4LBAeFYKdaBoaZ8qPZ4CCXW6ZJKO8mKIZPZkeVSNtMdTS09OV +7rYe7cRj7a3Nc1OLxyg+glPhZHa8N35kbPpk1rAbY0Kg4SdjMJ7Z/AwQOisAX2xOL1/qTZ5Y3719 +efsqr2RK+e7u0cvZyjTQjct4dWg8WIvEpxJp8OwZpztAMxkfGnA6aZZPFlvrE8vnO+OHwV5tHr5v +MHMmmeyvLN/cHT/KyUWKz8CAwHm8qK4qPYbOO40XmhzFRGWtBIo6kJhEqBzO5sGwQwuwUhHBQzSX +qTZ342kDh1nBUBF2B4v4NVEsWs3IyIjLQInIaK68Umqsx0F+k3GUiFabm93x49AIOB0DGZApr8Wz +s0Z8Chv3IDDm8Uiqz0p5ks3cEP8FPT5ZbmyMju+xfNHjVTAsrIdb0MvQ76xQAK0CZjkQHjBMwecN +knRCUKo4k8OZgqqPNkYPTy3eOj5/S766BlxgtZNuD+fyMD6/SjJpLdZP5WdhHBS5ENDKZgsFfwjt +A6jOSyWCTJFUmmFyPrc01lk8dfZeH6YMDTmcdoJAgyrIJL2NICGblRa41Mv/8oPZmS2Lxe9HZD0G +Z5gNx+bSudV0ftkIi7AQkUgXdJTZgsPAekFoQd/xKV7Ja8Hy8sqJbHPCjfEEFw7Gm2q0zgdgRtJw +gz6PHIuOauE2cBlKhmHM3T4FxcMElRTkMmsMWmxz+3yhPqdG6pSUw9gYTulyIJcFu6eV/H5JlXPl ++kKxMqMEyz4sYHEwAL9g7hK5pUhiAJ0iafVsdX1s9gQIlVxlWg1XfLjU7c3u7l0SA5lhM0YyZT7Q +U0N9SanA+Di9GkjWdGGZV9NuNynJqXJ7tTt1dHb1bH92r97bCEWbsVj95MlLh09eM9tpjEzxclNU +2uHYOMcWfD7NC5OIh3BCh1mA2uaDLVbpCNpoprxdqB/C6JTdxahaLpYc5cQk3C/oUobNMkyWoTI+ +T8Ay4nVYEdSv0GxSDTbBqYG6cHsDglRRg21RrTjcfKowmSwvhFLjlJAC0+RDAgGtUm1ugD20WAmr +laTZHDRvPDVZqq5FYoMbW2BInIhmC3NmC8bwyVC0XW5vCMEWwWZcHsnp4oEH/YTuRUNqpN8c7I1O +n2qPHUkXFkmm6PLqMDJwPS437fUJFJMIJweTq7e2Bnvh+BQj5OHkCB6kxTQjpjgxpwZaidRUKj0r +goKiojyfMllQ04jPZSd8bpbEw04HZywmtNGymD9x9FI6WjOPIBQRVfUOwxc4rkhRSQyPWq2Mz6tl +0tM0nWX4rN1JenzQs+FwwrD8ranlXGs82xxrDGbnt46sHN3rL28riRKjpMPxbiBQD4e7FJ2wOSmv +jydJTZLTwXBVj9flUF4JF9Kl7rlL981unkhXR0kxRsupSKpW68+Hy323X4D/P58bDUerNjvKsIA8 +oHzEbHGh3D2sJadQJiYq8XRlVEvWtGSZVhNeKkBJkWA625qby/amcCmCs2Hj8TibcHmFEZPT6Wag +sBPZqcboLq/GCVLgpHAgVqYEXdSSarTIqqlwstafWpxe3wlmqgilqXorGOnf2KcgDg+7R4Y9bhef +zk7GUyByoH0C0MjJ0kIgNgCXhLEpHxHGGD2aqQpawoVyHlxi5HSptUZQaZuNMQ17/B6BJcMMFUNR +ze0RHW7Bh2qSWtESA5zLAnFgRHD7yLnF7ZOhVNXiQh0+QdE7odgYTiVGRnwmE2K1kX40iOERm91I +QnA4JU4ASu3G0tOhSF+UCztHzy9tHsvWxgguYnWRoBCUaI0N5N2oSPPhbHWWlQq0kIeSBo7GqXyz +e2IwfU7TWzYHAaXFcIloalQM5HilKCplWS0poVKxNV/sLOiJWiLTS2ZnMoXFaHzcaib33WQ9cMBN +0Uk91HQ76aED9pFhr9MuSmK5XFnO5hZoJm+xUGYTimIBTs4eGPEMmTwjZj/NldP5zURygaFyToeo +ahVJThYKrYXFrY3NY6fPX7n3oUceffrpTz3/uW9+99tvvfXOX//jP9/9t/df/dHPr939aGtsA67N +cmMNGIlHc6B1c+16ZdDqzg3G51bWd07efP6+hx65/YGHL9x73/GLl89dvePaBx65866HvvziV774 +yiurW0c2tk6WahOgBDAipARLAb3KCLFAIFWp9qZmFlfWNo+fPnnpzusfeOyRJz/5zIX7Hjhz9Z47 +Hnzi45/7zMvf+NrXv/fDr3zrux965nNLW8elQBrFVbeHITAlolcSybqshhPpYn98bnH98PTyVnt8 +amJhZWZtd/vY6See+sjPX/vFb3/3zkvf/OaFa3ePTawlUy23W3A7JK9bJbBwMjFaqSyQZNhupwQ+ +3husNPsL+dpEqjSab0xsHb310h0fuPehx7740kv3PPz4tfsfuePhJ7RoFaQUwJ3LwQpsRhRKslIX +pQJB6pF4NZVrlKrtZndmZuHgsdNXHv3g00889dS3vvf9X7351le+9e3zt90xM3+oUp3ixazXp3m8 +MkAQwyZAzcIJnU4BwyLx5KDWWU3me8l8+8TZix/61Kce//jHbv/A/fc98uT1ux+4cue99z/2wa98 +53sfe/bZO++57/j5q5yU9XgEt4ul6bCq1aKxMVkqJ1O9YLCYSLSarbnNg6cmp6eOn7z55lsvX7p2 ++/Nf+vIf/vTnf3vvz3967/033377qY9+slQaGzFhJhMFTReJTORyy3abYLMSiFcQhQxFZ3xICEFU +io4wbCyTae3unjx/+fYT565cv/fBxz/89JHjt/SnjzV6W6KUM9ay/pObp/VeY2JtafvUsVNXLtz6 +oScfefmlF3/1xq/f+f3vXv/1L998883/+vvff/eHf/3Kv3z96U98cuPQzeXWuhcJI95gFFy5nExF +Ml2wEDt7Z26+5dKV2x5//PFXvvb1r37rO5/90osfffZTX//2t1/7zW9ffPmr3/vOq3//+99f+vqr +H/rE54+fvZrMjBZK093BWqE2oem5XLYyPztzy7m9B++/8+Mf/9Bnv/Dpb33vW2+9++73Xvv5V159 +9fs/+8X77//5//zf//vn/4Ar+cP3fvrT+x9/qjO+Fo61ADBJQorp6Xqls7KyCsf2zu6Va9c+/LGn +n3vx88984TNPf/Yzz7304k9e+9mvf/OrP/777//nf//PW79796Of+NT5C7fnC2MSV2SIbCTcz5eW +/aiO+iRdTQNw7+4cun77HQ899vhDT334wSefeulr3/zxL1776euv/flvf/7Lf/znb377u9/9/vcv +feUbO4cuZPPTPF8Kal2OL4QTo3q00W7NLC5uHjm6d98H7n3sqQ9+/NnPPv/yyz95/Ze/+u1br735 +5m/eefv9v7z3v/7f/4Fu/fHPf/3FF76eK03anSxwosvFO4wVkipJJdRAKZ/rbmweuvfBB+599MFn +vvDsT9/45etv/uYbP/juy9/82lvvvv3279/5xRuv/en9P/1//+d//+7ddz77/HPnbr0tnW0zDOht +zOEgEEQSuHilNDk5vnr08Ok777r/occe+/JXX/rZr3753Z/88Ovf/fbv//THv/3Xf7397ttvvf3G +3//777/4za8+8PCj3f5KobKoBlsul7H42WLGOSoisNGIXq5Wp0CT9EanDx47ee8/P/j55z7/2hu/ +eucPf/jad771yzd/87/+53/e/9vfPv/iCw8//ui12+/R9SbHVVgiMGhPri9u3nz0xNWLZ++58+KT +j97zza+98O//9juo6Lfe/vUvf/mjF770qdtuO7+yspItNMPxDoqGfV6ZIYMCHdCVUD1fPrS1c9cd +dz3w4AceevjBTz3z0R//5Ec//PGPXvnay6+++u33//KXn/3q9edf/OILX37h4tW7FlaOtbqLipKN +R2qF0mg210ilyrOTSxsrawc3lu++fO5fXnnh619/6Tvf/fpbb//mT3/922u/efO1X//q3Xd/+x// ++dd3//3db37/G/c9fPfC6lY02ZCUrCgnFTFcLTZmp5dO7p05fuz4sUMH77p+5aWXvvjGGz9/853f +/ui117753W/86s2f/+sf3n77nTd+9w40y+tfeunFK1fvqLVmCFwnMD2o1eLJCYqMc7Qe1TKNYn1n +ffmJf77/a698+dXvf/e5L3/xZ6/99L0/v/+3//z7G2/9/L0//f71N372/POfeu75zx7eO6eFKyCH +AKyUQDkca0ZjtcHY7Mzk7PGjxz701GOf+ewnv/D851748nM/+8VP/uO//+tf3/vTa79+7fs/+Nr7 +7/3hd39496WvvvLE40+2OkuIPwjGzWGj3U4B8QUEPlOrzJQK3YPbu0988PFPf+HTn/vS8z99/efv +/fX99/7215+8/tM3337jvff//d/++PvXfvnj3/72tV+89oOnPvTY5duupjNNQYy5PQSUVkDL66FC +PFJZnl9/4P4HvvLVr/70tZ9974ffefdf337vL++9/e47v/7tm3/925/hPD/80Td/8rNXf/H6j556 +6smT525bOXiroBRNJtzjkj0uDkN4lx2jMHm0O33z6TMfeOD+L375hRdehtn8wk9++v3//O///P0f +//BTaLtf/AQm6rPPffLChVvWV3fDkVa5shaSEq1Kt15ulDK58YnRxeX56an+1vr0HQ== + + + 108+9NDl69dO3nruaLmUCgZEmmQQhEYRwWEjHDbc5cBJvxhTEuVEuVvtjHU7O5tr21srC7Ojp0+u +3XfP6YcfuHjblVuuXr966vzZwdR0OJKW5Fw4Btq75HWziIclUJ7CWBAuxw+d2dw8mEum2vn0obWZ +i+eO3H/vpSeeuOM73/jSLwFu3nz97d/98tnPP332lhPj0xMhPaEF8xRYV7+EorLEh48ePH3mzJVG +a7xSaU71uhtzE2dPbD778X/+7quvvPnWG+/+61vf/f4rX335s1/+4sc++ZF7H7v/wpHtzXZ7IhSp +uN0cQYS8iGKxga/B7HbS46JUVi0lYgeX5x++/eIrzz/78le/+NKLT//8J//y5z//4Quf//DV84eO +bs71mq1SqYbjnNOB0VQIDhRT4aBIlSWFWCjZLLfXZhaunDr81GP3fPoTj/7Ly8++8caP/+2P7/zl +r398/edf++RHH7x86VijVsRQFvUHSCLqsIOkMZYoW0x+AlFiWiGhZabGJpbmZ/f2jl689ez1K7fe +e/ulFz//0e98++UvPf/p55798Gc+/uiXn3vm0btvO7W7nUtXKTrg8bE+n4BjGsNGM5nRoJYl/FxC +T+2sbt11+53PPvOxjzz5yF1Xb/vok4/96Aevvvqdlx+559zHHrz+0UfvueXMse3VxX5rNJvtdvo7 +erhtNmNWC4WhEa9HcNlx1Mvk4qXdlbW7brvwpRc/+9LLX/zoRx596vH7nnv26R/94IefeeaZu69c +3lhaqZZrHK1iqOL2yE477bQhPg+F+hgS4zUtl0q1Ou3pmdlVmpcQP2hL1uNl3W7Gj0gEEXQ6qaED +VrvFj3plAgv4vQKFKrRxCCwtxcI5PZjyezHE6/f7cJYWGUbhlawbUa123OVkMGOfgmZ34SMmcLUo +7hcRD4MhgqyCSQlznBoQVcqPihSdjUVL+czE2OihI8cWV5YTiQTMo92BWe0omA6Qyi6XYHcwDict +islQqMiyYRyXeVaLahGwo1EtmE3E0olksVQdTMyEQ+FUJDraaNRz2RAnY14WXDOGBRkmrse6FJva +f8ABaicgl2Quo0vxZq5cTqTTQS2pBTcWFvuNfCUTHWs3kvEix6ocq1NUyo9odiths/itZq/F5Dab +fP9IsmLopCLkK7lBJloqJ/J3XLm4d3Crlo4P6tVGvjjTbc12qoVk0e8lhocspmG3zYINH3AMD7ms +FgywC/EqNB5WpWwEbFYsm0rkRS7g9/glVk3qxZCcKKTKY63JifaEygvpcDIkRilUdDroEQsxYiFd +HlWSSopSZJgw4uP8XujcSDRSg6YW+UyjuT63fH588pgixVC3JywpmXBSE4K4HwAThyoS5VKzdywQ +7Fmt1E3/jwmEKI5F3C6OQlWOUKJqNBNJJcOxbLwA8p3zEwLOBYSUJud1rRTWmy4XdIocjrZFpbr/ +JjuUisnkddgJxMORZJzns6XC+O6xq25EdrlBW6ZYLs8LRfCVBBH1eBUYARQxnpUNDdnhGDF5LWYM +9ck0GdMCNVEs8EySomNGkJSDtDkwHxr0IREYc5ZKYf6gxYq43JTbK4CwIVDZ62GcTpqgE4yUkwJF +Rcl5vaTPS1KEhKECRWminEEwFbw/TsShlfYbm/s8oHV9vgCGhXBCo2jd6WIcDtrrFW02zOUinU6C +wDTwyJKYp+kEy2VQNBCQ44KoD4/YRobcPrdCU3GgdYrJa+EJgsyYzThoYJ+Xt5gRy4jHZfU5LB6H +xe330EElJ7AhEhNJLOhyyeC+rTb6H1vLHXYBQ8Net2gzY05jp5Jgc4huX8jhkoHjSFIv5Hu72ycy +iaLd7BBwRSQjAqlTcDuAUUMus8mP+yNmE7LvJpNpxIujIbudgQNa3uNT4XpYqPxI1+8PwFUFtEom +N6tp9XCgSPlVn5v1uejx7hpL6QB3cCqUzBFclRVqslLFiKjLK3ugo2+E3yqBdiA8nsytZUsrrbE9 +LTJmtQLHCcVMz++T9++zWoxEC1lTm4PxE83OYYJMDx3wWEa8hfQYhoYODHlgNh0OFkWCilxNZ2bi +sXGnjTYNuXAfkKZgt1Fet+zzBlEsDq4Zfk4LjQ4PIyMmt8nsMlvcFrPHB76VTLDGg+txkkwkY6CF +Jjghy7BZv19HsShpLGsPIGjE7Qvs328dGnLAj9qsNIGGOTrNcVkov1J+rlJfHx7xjYy4YdIpNi0H +uqLSgNMiPkVgws3GLMOnTSaf2ey1WhGfT06k54OxcSlQZ5hEMlkNhfMeLwd/124HwAx6kaggNbOF +HT9MhNnvdYORbsGp7A7KasOg6nz+oCAVRaFiNYLRSIAyFNUAIf3+IIyYyyUSeFwLNkg2bjJ7PR5V +UZpqoE5SKQ8SJuiC3SmbLQSUn8NB7jd2LjhsZp/V7HPYMAILQbv5kQCApNMp7bsR9+F2K15v2O02 +MgdIMuVDdLsNpILmRYJGkp6ZMtt4GCs90klk+n5Mgzu1mHwUqkMFDu13DBl71XEw715PIBIc+Dy6 +2YzCYbXiw0Nuq42CETYWGODxoD4IRafdHpVhIppeJ5gk1LbDQo0Y69sRHAnWisssHTWPeGkyQnMl +lyfocKlOIy0qq4bGpEDb6wvieAhMSrV9KJaew/AUTqYdTtlkQlQx2x89giKhA/udOBmnqLTAZjWl +5EeCoN4P7LO7bPjs5CGCiJktFEEmECxKUBlF7aZzK4JQs5opm4X0Iyq0hmnE4/MIFJngxDonNhVt +lONLRgQloohSjJHiJgtis7NGCqhQloKNcGys0dtJ5SdpLsFJBYbLq6G2EuqRbMGNRBw39rdCs7s9 +N/b4D/kJLIZhMcQfEoWCHKgPjyBGGSASRsUUvUvwebtbhH9NxiqLy8cEtWKGMfTKKAalHgJPBFPj +cnHAjwe396YXdqC0EIA1IknTeYrK8UJVlNtQ7RwTCwXLXi83POyGufD7VZJO8HI9nJhWtQGOxdOp +8aBeh3sxKNjNo2gIgIXni9CJPp9GY6FqaZZiUjCDZhNqMdMeb9jl0V1uTY/2QXQdGHKBQyGB+u2k +y0khPtkCk25ERAYpKgMg4HLDVSVQf8zjDY6YEZuDRfB0INRL56ZYIedwika+mVd3e4Mg7yk6Ad1h +MpMcW6TJ1P6brEP7QX9oqjrK81WvJ2RkL5tIcBMcm4Dr8Xlkh5N33liI4vEGjEgTFEYmMjl9tNZe +8OMhuHKGzlFEkiJSJJHyeDT4W8CqPg/vdAJsGouxvf54IrMyv3Z3ubnr8mowCJyQQTEjMA3xJYwN +Vlo9FKzIYlkUygQedTqMNag2o7AdI8Ne84h/eMhgIo9b0LSKHw1DrXJ81gbywwEUIxhbz/bD/4n6 +fEHEF7zpn0xwAbhfwTHdbOFMFmHEzO0f8h8YxkBGbm+cnV49PWIjrE6e4mtyeCpWWM1U14OJcU4s +jLVXTpy/x09HbW7O5hI8SMyPpTi+GdBnbS4VMMHnUW8YCoWm0wydxnEYkJgfjwOS4JRGCzGCS6N0 +ghaLolbB6QTF5xW9H0svCXINoJvlkwhubARTQOqoRYwM+TANmJcgDIwaGnYNDXvsDhbKj2HSklCg +KGBbHDgFIBp4HLDd5Q36sDTJ1DixJkoVSanBbUYiNbeHs1pROBVgCE4kSSqtB2tbG2c5PjViQiwW +1I+ESTLLMEWGLeFUCoYObO+xo5dSmZ5RuhbU5xZBU/FCGdrQ45YBVCW1QlCRYZPXZPbb7KTbK+FU +Ugk2ESzEcOmZ5VNyqL7vgGvfPqfLKaFYBMfjAa0Ri4+5nKJlBCFRjWaTB4Z8Nw4EDp8vqmntaKTL +C1lRKrq9ssmC252syyPhRAp+ulTfnFg6x/BQY1K7u1auryNIyGKlTSbCaqG9HokiQsCYI8Megowl +0rOx9KwfTxjbrzwBTq3nG7vdqT1RKQNYkXQRxpxmM04n43axdit1Y6OfBvw+AqrPRhkbTFwi6g8h +XtXl4C1G7gTj8QUXl86pcm7fPpvJhAGKqnKbwDI4lnK7gS59TgcHJxw6YLPbcNAq0BRur8YpdZAo +qdRoIFI1gz/ya34qgXPZYHKSEosYnVC12vraLScvP+SnIigRlrVGODIRjUwkkzOyPjpsIRkyNtk/ +JMnlAwcARiioZBxLBkO9wfTZcmMjHq8fPXGFkYuUkI3nJjPVlVx9rdjaLnQOi8EuTseT0cbjj31s +MH8YWtLnk7w+xefXGa4Ujc8KUsNppMFrABo+IzwnjRFZP54lqaIWHNXCPZdHNJk8qLEiyNid4fXr +GJ6Ag2FyolTKFxdEMRfWq6FIF0F1Xiwreo9X634q5fJpLk8ArhZU041NuAGGK+iRUYZKgVDUQgUE +VfyIQpERqCuHnUP8OkHGQT5hZIxkM6yYBwqGLrbZSFDvVgtOU0mGTQf0dn1iD2UzJquRkgEg6Uc1 +0GZQfi6PAoxDg9pEobWxffvdQ8MIlIfHrZFkURDqoE8EqcaLFYrNomSc5nMgbj1G8FSE5fOCWnU5 +eYGJXr50vyRnADRMJr/XqwId01SCIMKgtZxOjmPTLJskyQhcTCIzka4siuF2KDXBikWcjAVDTQyL +mEZQq4XxeXUcT/NcQxQ6brdusXI4Go5Ge6B8QEvDfY0M+4aHfHB5BJEPhvupzCxYDCvYFmM3GY94 +g8amMJvo8emCXI0kBqBpJSEV0BI2u8/mwB1OzgiQ8RsvXoG2nF6JlYs4l/JgoVByQg6PRpNT7dFj +7fFTieIcx6VSqX44OUpS0ImaH1MBt0esBJyzXlsVZCMnx4+EKGP04pJULFaXo6mxXG5878xdjJJn +1Vyps94YHGlOHMk319OVVYovUGy831l86UvfPH7LnW6fiKGaIBRFqZ5ILeWKWyxfVdW60aRoxNgI +jGU4qaOGpxO57Xrv5nBq1gt+E1VDoTqChu0u0QYOlIgKchk0G8XmAuFetTp/5baHJxdudrrB+xT1 +5KQWn+K1XiA8GY7NgTJxexWKy91I0QkbexzcQafNiA7wepRUoi9JBahtq5WhiKgWqDB8npdrcrBV +bqxnSkt+POxyAyriNisJuk4OVOP5uWxzl5KqnFKTtS7oN7udMN4V6i34i5H4ZCI5DaUyZMS5++FX +AAHsdrAqBY4vs3yJ5oxAG0asCIE2K9egkW03wvAxIgl3pAQqYb0+PraGYQrUM4CVKIBUSEOBmczo +8LBH4HM8l4JftFlRhgon071oepQSclqkzwhlhs0HQ22aSRtJVkZqbhLxR26kAWh2I0QuoUiVTHoS +eMHrkREk4AAeH0EpMo0TaYrJAuwDpgGtuD3STTeZh42kHRBXaZ4vSEoZ7h0INxppgy8fHrbZbMAU +EkyKEzAfi4FXCsenqt2jwehoODUQgg053FGivWh2Wgp2QF0Makv33fnU2PxR0OdgXhAwKb6AKFcC +obaqtW0O2u2gcTzmdElmM+nxCiDUI8lBuriYLMyRTFjVcrXRdWOxsZw39hrE+tnSYg== + + + q7szMbO3ffQOVoz7UCEUahq5qWIFrgqBsiEieqwfy884vYrJjEdiM82xU63JvWhujuKKPjzhRgCL +irninKTVSC5D8xlOBPlaV8NN4PFArBnLdhu9pVhugONqs706sXRrtX+ClZu80oLD7pL73fXb7vhg +tjCw2CjQnyhWxrBSMrmYKx6Mp+YMFcdn1WANZIwFhKiD1hMTU3Nn9s49XG5to0R0ZWVvavoI9Dgv +pHO1xVJvtzx6ZHzhwtLOA4XaYVChFB0W1QLOxEDFAW/idN5uBF9IdgdjbA83Y14vUH/I7TG2cPrJ +NBdoxysbocySn8z4cU3VKrxcAhyjuawgFxW9ma0sapE2aBjAFrBmNhvjNlY4MD6f4vUFzBbcZgN3 +rNqtfjd4ajICLB+KDSKpGYovk2xRCfYr7SOZwrrdIQ4P+/xonOHKOJkRxDJqSOU4xUCpVAAJKSpu +sxpvM43EHi+YuwzLFkJ6BwzsTTeZrGbUYvKbRxCAMnAWLAdOPMOwBZKIO+3A0aLdwHMUZB7FZnip +nC7OpwoLE+NHr93x4XC8wwjZfH0zloGJa3dGj4wOjmera3avbDZjFJ2kgDfRsCiUKCZjlJMFSjqb +LU7jVAzuVxCygXBbTwySpUUtOqaq5fGxrSv3fMTtk2GIUoWlotH4C8XmRqGxEUlNIagmy0BJbZsd +rD2FEzEosHh6fn7rtvbUCR8Wdthpgoq6Ec3m5M02EkBGUFvp0ub82tVIfDQc66VLMxgdNttQlNBD +sc7M2s2X73ny9OWHezPHOSWfiVe3D15QI02TjUapRDI/nSrO8WonXVjsT26pwYLLHciWt/XYNEnn +JbkpKHW3TwXCLVUW6u11uCow4CDRZa2uBBucXLS7JY9PHZ06lKvOejBZj7V600fGV061JrbLnc1Y +doZTiiwb+8SnXjp36R6U1EAc6rHZUvdEvnVYDoxabRzMUa+9vLF9ed9+MK1BUeulG1vNuTOd+fOR +wrIbiwZDlaefeWFr55zFSoGrDUUH1d6x7RMPtMdOGcFxw06Ri9F0csSMWWw0VCzD13i5De4MbILb +SZNEiKLjXkSDLi62dxsTe3M7dy4dvq8zcZLlCgcOIL3R3VC4ZzeiVjH4CRgBoInO5JlEZt5tpH+I +oFd5DryPCs4C9JjdrYOgRTAjhRvU+xDoHxOG+3XEFyCJBMhsPxIFrvR5Qc+HADwJIgBT6YDi9MoY +FQaPE01NlJrLGB3hpGKpvZutbUUzC63Ro+HElBGHa6NxVJXkrM8PIy87jQBPyWrlPZ5IACynWATA +FLmsHqkhmOz1SzeWgWUKtdX+3M2D5fMcm+z11svNZT+lg/qKZadDiXFGrBaqa43Rw+HEGKgUji+m +srOR+Fg0MQgl+qxc96ExjoPOTQyN+A6MIF6fls7OJnOLicJKODlFUHEAq1xlTtTKXr8mKlUgoFpr +6fDe1dO33j+3djMtptvNuat3PJbKGcne+crG4VP/fP3Bz05s3CmFJ1AqDlPDUJlsfsFm5LzhfiMn +UHe6ZYyIa+G+kQ9gJHJzfn/E5RZ9aBilUnKoFU5MZipLgXCj2Zk/fOJKINQg6KgfVwgug/M5TikU +aguHTt+bLowbj0fQUKO/BzSqhNp2p2x38giiZlNj3d420CKKRmihwIh5Wiip4XE1NpYqz/Znj5+/ +44O96aPDJtKPx4LRgax1SCYDHmpkhAZIUaSiKGb37XfYXYIcGkRTq0pooIbGQA6B16ZoAyr9WGj9 +8OWz1x9dPXLbYOGcnpwGqB8xg/dhLt/+sVxpHqSm3x/T9B7ij9NMIZ2fB28LfeT18Pn8QBLSYBv3 +gQc0U5RQj+TW4vm1ZG4FxzI+b0hVm36fPnzAaRrBb4SgkuAlQRQ5ncYOoN5gHdQsXJtxs1gQaiMQ +m5J0Y2EwlJakNwhjiVpGDPQ4BXCsQmARjo5SZBhKCAcIRdMUWYbDj2b9WBpg1uHgqqWFdGFgpOpZ +UPDCvFQrNbcag6O5+ryu5c+fu392ac+DKonc9Nz6lcmlS5X24cHMmbH5s7LeNlvJQLAFVtcPhOuX +YUgJuiQpPagHXikNAwgb376JBPUWxWUxOkXzRYzKCIqxO5IWcoyQ16OjDJcShWSju9qeONycOFRo +zM8tnx6fPa4G63q0U+/uNHpbnYltLTHmRuNG7LNLjOqdXH7eZCFHTDgnlFV9TNG6oJd4sQ6A7HZJ +JBn3GRGUOMMXo6np3szpavdIIjutqoWd3dP//MFPAm/CGKKYLgV65ebOwRP3nL32VGfmJJSu08PH +0t1gvO9BtBsfGyIsds6PRsCYIP6w2y1wQg4xcokJl0fjpGYiN7994vqdD3/6zO1Px0vLVqfECnkY +Cg8ShJkCFsOxtCjWeaEOBmdo2AvQFIpNU0YyvAwmCOYOyFoB0U5EAAHGJnd6g41kdjycnGakNsmX +aaECVNKdOo+SaZtd1CLjklY30hVsnNujGfn2wyji1wqlBcQnH9hn2n+T2QUjYGyCnuDkBoJFh0YY +p0cHV2U2GU/AHHbR6VScLgU8FIpGjRhtPJqpLNJ4JJsZw4mw1U7BLcTzq1p8Tg71E6VV6CNgW8l4 +TtUkmBzcHWh+gEqng3c6BI9LBtsCw+52iqBLodRvxBLyoVDLacRVeWEirA4OroQRCpLxyYxqNNZo +tNeCoQbHpcdn9yaXz9RGNwPROs3FMCriQ3WvN6CqVQILuZwsKEM5MJ4pHKy29sbnLvmN8GeGoZPB +cBukkcPFgT33gWUI9DS9D+qXE/Od0fVma4UiQ7hfzhenFjYvHjpz/9Ez916592O13q4oVm49ecc9 +939QUHIIFkKIBAOWIbvUGdubnr8VxTL7h3zDgCFESouMqdDIaAy622ahQWyDF3Mb3zySlGA7oHcU +UHd0CifiopDLl2YGq2cooeh2B0rl9Wb7RCY3PzW3N7NyhpWKTpcQ1Ip3PfTRQHR0ZITyeHVOBE3e +p9iSy6OC1Af60KM9cHB2J8MLxVhqOpmf600ePnHLvUvbF1ilGgq1T566Dr7P7VUDoU4iPZ3JLaSy +S5zQMr6HZadoKgpCC3hteAT0czBdXKr1d1PFBVBoKKbFEx2ni7M7WSgtaIK1Y/cOli/Vx0+QXGH/ +AT/ujx6/+QFKSAMjQMG7vBEvkpQDY7nSdr68O2w843K4nCRJRYdHkBsfdxM94NaZkhaZ4qUm/KLd +ivn9Mthku41F0CjJgJ9tzKye3bv8qBvuiE0hSBBBjNVrqt5WI/1Qal7PLOFslsCjxcIsw4H1VnjA +eT4vSmVBAKRKe9wyeP+hIfvwsHtoyG020s7JG5FloscVILAYjgZdTloQ8kqoEc9OxPPT5c52KD4G +XjgaH9VjVYIJUKxGMbogZHgxF9Cakci4F2Sti2fIMIoFHU4aBCrHZkjKiPjz+XSWzoGzBk8Eze7x +ygCeQFgWKwvUzPGlVGY6EKpjWIDEA8FwIRDJx0v95uT22NyJUnWxUJhdXTtbqE6RTCwS7+eqG4LW +jqZnMuV1VZ/y+ZIIEpXlMi9kQVw5wBva2BviIUiTafAXNF3E0DCo62GTc/+QzeuVQ3ovGp8tVnfm +t6+BBguoxfWtW/XkAODL6eK9NzZ30HQ2Eh0tN1dHLLTZRPJsGVDR5mCHRrxwOFw8JxSC4R4Kpe4T +oPUoKuZyCSDk3H7Va6wCzbW7h6bmToDnEqVcs7tDMxmPW7JbGeuNcG+7jaLpqNNJY0TI4wtSdC4U +6UtwMeEOK5U5pdLu7/BinuUSre5qfXQT/gSls25/0IMEJKUWjoPjXjWChsAAaq1wfFaPzibzi5La +stkDUHt2G9NpLkxNbhoxcWbM7Q3waj1ZXql0DinB7tCwXw/Wcrmu2eQ9sN8BaADCIBLrSUoBGsFh +YzweDQ5eyHNSgWaT4MvS5bVkYbU1OJ0urWnRrheVtWC12dlVtLofizpdQTCtTuNjeZTVSlgsuNmC +/eO7DP9IwyOwFOqLkP5ILFiZnTtCsDFWTLcmDx09/8ixi4935s6osXGKTYbU7OLM9tzcKVmtur2i +0y0gxtvGMIYGI3oNQ1WXiwwoWUXKgmHB8KTPn7I7AjcKGHcY7+zIkRHARgxQFNyNIDZ4vgY+wocG +OD5Z7y5Mzm0tbp5ePXxpbffCzvFrkwunMvU1jI5VylObG2c5IeHxCYJckNUWzdZkdRRFkx5PALgY +zLXPoyI+HUUTKBL1gMTyyjDIHJMR5BLDxRQ158cCOBkl6DROp3m1qun1emPxxKk7pUBZlPLgLBgu +JwcqsfhkINChmRyI4WikUSnN2Y0cbI/Nznt9uijVOKHE8QUCj4RCVUBd+K+go8CSJ7ML7cGx3vTx +9d3r8M/Q+53O8srGuX+Ey/mRAGYsxaERr8SycRwNlKrTgpQFEIPCg3YTA/V4cbE5c2Zl+/Z4or+6 +fOyr3/pxJNa32mSarYOnKFRWzl1+7PTFJ6Tg6IEhFLpGEIrwK9BWJiNjkLHbNUUdDYYHilpFfAoI +J5eTc7l4u5OzuXiTTTAbH/JQtVBbkHMOFw0m2m4nrVbMaqw941BjOQfwfpygc4IKzqgKhitXWYjm +xuP5mUJrK5yZFfUOKOR2Z3tt6/aA3rQZEdxG+AlLZzEs5vUEgBCBJY1kcuPjaLRx727N61JwRIvo +pU5/KRRt1JoLc1vncvXZXH0hVphn1TZGpcLBysbK6cXly+iNj2i43BxJJnmhQrMZSSqRVEISs/n8 +OEGEwGt7AT2YKsvVKSZvvxH+bMyCjYIeB1q58TZc9PpCNJcU1ALMb72x8JGPffG5V743MX8U/gRg +M5aZ6gwOVxqrY72duZnDmpbTAkU1UJWVqqq1CTJvt8nDQ8YnlkwjCJSW08FZjHdY3uEhl8WM2iw4 +jurBYKs3ujO3dNLmZEDVIMaH+XRRq6YLS9nSqhps4oTe662Vq/MeI6Wfx3FQpMYrMDDmuUy/VJgw +DfvMIyiORcHf+RHNYqGcTugplWXToXATCsN4PEimJKUUSw9UvcmLRU6oAHT3uquD8R2bjYXLoKkY +MKnbyft9MkWE/YgSi7dY8MgjHhQBzRPmpaKitzQAELmEY4Fcun7mzDWAR5av54u7hfJOKNRNpQax +xChBZ0GEy3yumJuAthoadt/4ZkFKEMfmFu+cXb0uqU2TiQDLAMzucbH79tv2Gx/R4B3OEEHkwHBh +dBTBNbdHOHDA8Q9wY/hsojAHpg+8djy/FEnN0VwhlZ3UEy0vqajRRrm71Rk/tnHojtMXHr/1+kd2 +jt/LChmOT4PMQBBwnUGLlRge9phNiNsFiMpQdMpp5OSwQCUeF09iAQxXRS3d6i0fP3PHYOGQF/4V +yDG/WG4eBtRVtVo42hHVutMjk2wKp6I+JACQTrNFQaxVG9vNLlj1jtXGY8AsDKB6haTybk/Q6lCt +TvXGB/4knIhAq7pcLPSLx8uHY82F1VOr2+fLzYWFleM7xy8GImWWT4QTo1qktbh2ug== + + + OziEEVHELwUC6eXlE9nsKPwtcNAeT9B4lojEGTqNeAM+j2w2+S1GUJ4R9gj3aDH7QRJEY/1kejKR +GohSen3j1lZ3C6UjfLBW7h1tTZxOFha1UGtu8VS1vggwBQMST07E4xOiUARytDtok8m37yaby86i +iIHJQ8N2kwn1eQMIEgC9ZDfemAgkHncYXtXn8wOfpkEnFMpLwaDx9gquhyJiAaVoZLgNewFOPS4B +R0MEZrzjtlr8TjtO4brDAcCOmSw4yAmJT4pcRBKTLJuMxrsXrz62feiKxxvA8aQgVIDTM4VFULAE +KrF06EbyM04QceNxKFvi2aIeBh2etFtJSYhFQmVQODfts3l8Bs2B8jEbX8LCrDbS5RGBd0wjXpsN +B6ECKAeOxuNVacNtJXAqzghFaL18dVnTCztHL8yu3Fytr/QGuzOrN/fn9hL5WZbPZHMDNVi8sTJH +hREYHjJWHBGokQymaWBbcrXGBoKFzWbE6xFoNpUpz20dv378wkOdsd1Llx64ctdT4WQfp5IknSWo +tCDXIonpaudkb+6Snprk+FSjuZmvrwajHVlrgJC22Y1840CgD+5j/5Br/wHXsJkguRqnjuJ04UZM +n8Qy2UxhnmKioCdTmdHDRy88+sFnjp25nq7OBxMDTiytbl1e3LxVDpX8RCAU6fUGB8vVBV1vZLM9 +SUrAdIDzpeg06Bm7w/jGqPH1HI9mpDdgYAwDQwcM1HI5GFkqasEezZZxIh2JVJdWjiXTbYqLRNL9 +ydVza0eudWdOlnvHpFDX5ZbzqfFT5+/D6JDFhrmNxclg840APbuF9Xs0hc9NT+ysbZw/cMB1YL8N +zg8kGIwOYEBwIgHYVSnPrKyfAy+M+EMUA+0cp+k47teCQUD1OMA4R4VFKet00A6HsXLGasbhV7we +CfHKphGnHxE4Lg5uCCqtUBqfXzsxvbgXz83VWpuAVByfmVs5S9MZp1My8v9trMPG+5CwoDRoJgU9 +ZTb5AAmhbn0eicTDBAr6B4cfNY8gIIM5Nr5/n3X/PvO+m8xDB+xQ1cDRipBlSb1WnUmAcbATqpz1 ++BRWyInBph4Hpb3YGuzVO5vzg9Wvfv2HO8cugWeUA7VUYTqamoAb18ITJJfx+CSOji0t3uzHwiPD +DovZ6XRgDjsFSAiqEtSsKKUEKYPhUU4oBuPdenelN7Fdrkxdve3ui9cf0BNNis8ns8uJ1EKtdWhx +647J+XNjUyeC4W4y1j14+IIUTLpRsJYRBE0DT6laT1Q6Hl/I7hTAlIFDsThki/EhMBwsEvisaGJW +j02CWTu0e+vo2LqsFfXEaLayVu8dm1q8sHvsnjPXP1Lr7zTaS8dvvhZOTYYiLVWrM2wGfDGoYsBD +VWl7fLLNbnScD9FlqatpY2Dw/f6I3WZkMnNMzmoFkPGByESQpJGf6QsYr4eEfDDSZKU0zcVhrHxo +TNaac0tnBhMHoTYqtQmSDQtSUg/VXMYkKm530OmQPU6NwmL18kKvuzl04yESiiqgB1AizkgVRipD +6/XHtiYmdwUxx/NAlBUtVJXkAsPE1aCRjEQS0UphHObRbsdtVgwqikChEXSvW7KZCcC0iF5OJY39 +ODwd6Y2v7564vHvyLj01S7IlBE0sL5/68le+Xcj0QUDabTRDpyShJkltQWq4PTLIDFUpjE4ejUSb +DjsB5WQz4S477fdKmE/R5AxFhQDYOSZrMRspu0ND4CY41Ke57aLfGwTqj8e61+96zOliCCrCiFkp +1AxnJtPlxWxxcmFm+9EnP90bbADRNzrbQIux9BSUFiMCeYGE4KJa+QMPPCvp1X37RoaHrCPDbgvc +kZ0FZuGZ2Gh9cu/mq6pe8YEqkAqckgsn2qnCoDW+VmrPU3wilhkrNjYktaFH+npswIr5QLAuSpVI +eLTaWJSDqUSuIWkNl0cDUkAJ3e6SwfnSdE6Sm+BwMTJlcYgHhhEQXV40ooa6DJ8X+OzG2tlef00N +VaLpiUpntzd9cnHj4rHTd40v7cWy49Ozh5557muBaBfUEUCZIFciib6mj0vyqBLoobiuqKV6a1OU +S8ZTGqf6j0RQOEgyy3Jls/E6mxwx+aDG3B4FLoOX64nsfHP0iBKEeUkPxraK5QWGy3T762OT2wK4 +JJ+CkzFwQJJYsNt4UINwWo8n5HUHvQ4BWB7gwjRCaFpNUfN2YDErIwc73ZnT+caGFukieNTnDzVa +y5F4HSMiBJWKxMYyhblwdCCJwI9hqCing6GpsMvJOI0XbWGfV7UZyyEU+sbONeBKWcrDySPJ7vTK +2ZXdK+u7t+0cub5z9OqgP8eQYEuDNJUw1nZ6jG82EUTKWK1BxMJ6u1CcD4eqThuJehXCr7tsNI4E +CL/mcdJWM0pTuUhkyguURweND0gdQNwO0WEHfZIG4SqKpVi0geEaRUdxMiRIuXhuYnz+xNbRy1tH +r4+vnsVoA3LHZ08KWo2ATmGyOJmi2RzHpUGfDybWwTnu32dxWimfW3M54DZZt4tDvFwl39g6cpZR +kh40GMvNBiJtOHNj8lCmtckqZUnKnNq7srZ1FpQVigJuFKLxycnpEwuLN8eTk6JSaVbGPvThT7bG +Du67yW61EW5AEn80GhtrtHa18JjXp25sXQgnOgdGvBYb5QWWwY3MOilQi6cH5fLU6uqx6cXjPjwg +ajCknVC0LgULlebi4b3bT11+jJGA9Ofy9TWSKyBoGCMTHiTs9hnvtTP5uWxxzotIwyMITafCuuEZ +USTudodGTIzJTHl98rDZ7XTTGK6HooN4YanQ2Co2t8A151L9hx/55PGz97rckhaux7IDPTXQIj3A +bcSveb2SIlc6vSMsVzKbKeN5tfFskBsa8mFoIhjsjo9t3Hb9YZYvgpJUQy1Ra/nwNOjMbHlteff2 +UKw1M3vw0tVH2qNbLrdqLI/0RYzgfSxKksb7Pp+HpwkdhLTTZURkj5hIu1P2+qPByGS5tpFIdgbj +mysHLx05f/+R8/dtnbgaivfcSIATMuX6cntwEApA1UrgdgkyieEGUNutnNMuOG0MwFQxM6Wp1f03 +WU0jPo+bdxvvizm3G5ShzLK59Z0LLrfyT//kMJlI0Mmy2glFBjBf+/d7XW4eQVU/rlJsTNYr5e7m +9MaF9tRpIdQXgtVYdrLU3sDJuK73Epm5WGYmmVtUIx2UClvsRiCqyyF4XaLdSgEqDg17oBL8qIZg +IZdPcXh4JVRWY1WCjyQK4xPLZ4vNtWJ9uTm6U22BmSqAfvYbG1gKPLhvMk5ScZZPiXK2054/d8ud +erQ1dMBJEBEt1BTlMoJGbqT2xXEqlsqOM2IaAMRmBwEJxBSR1DJUL4jAUr6zsXGkN77ix9R8dWlu +48rO8fs2D12bmD/Wnz4cTfeTsdZHPvnCHY98yvi4GBatd3bnV24rVQ6XKoeC4b7Hp1qsaDLRFKUc +zNGBISPk2WKVXZ4ITuWT6YlbLt97212Pgmm1OXkXEvCTCTFQq7fXmp3Dlc5xnMtD1aXLs4DVGBUj +6QxOJn1+wN5QZ3BcDjasDhbFI+DHb6g4DWoYABAkK0mGsoUxkFUulywGqsXGWnvs6Or2henFU6A5 +FTl15eJdL7zyjXZvwWYXWLYEKMrzVRSLwbQ6XaLA50gyagGX7RGEG2PFSZVSa2dp9/Z8aW5t6fDH +P/G5xdW9+c3zq8fv7Myfa8+cXti5vn7w4tahC6XGcqU6+5Vv/viBRz6OY8GAXFKUBiAYSyXDoZYm +13ye4IEDKDhWEEIjw4Zf3n+TbfiA1zCS/qQS7ElqPV+YVQJlVizIobagNWW9p8UmXB5JVPPpwkS7 +v6WEKoXGyujcydnNC7NbV8ZXL+ZaO2q0n4wPTu3dvXPkKiPmWaFcqK9nyqtScJoXx7zeiNVKgY1y +OKBfGPONZWxemLX/n6T3bI4su64F/8CIXQYuke5mXu+9N+m9d0gkvPcooACUAcr7qq7q6u6q9r7Z +ZLObTdv0LdE8SRQpPlqRHFGkpNGTRm5iNG8iJt6bmG9zshSBQBRQmch7zll77bXuPWdvwgWOL5Gb +jucnSvXZzYPbW2fuHF5/fnHrSr6xwcgVlPCAUOH4HAyrwSANRXSOL9fbe93Jo3h6juaBROejIO9E +FWCsQDASgC3Fhm7Nx1PLoloGK+sPsgTlBIKsP0DRbEwxasnsVKEyB75rZpWm7UJ1qdHdqXc2Yqnp +dHExU1pQjUrMrR2cvb64cQbBdC8xma0seOlx1WqxYiUQkkFooFHp7JlbhcIMyF8+nwBBXjSajMLJ +cMRKZyZv3n6hN7k1PIxRTMpMTMcLK53po2v33nn2tY/ntx5gZLpZnTt3eIcXEwBjmfzK2PT16aWn +S40LhtONwAocVa5celiurvX3MI9QwE3DqAccejy3WO7sA6vSaixNTm0DPifIOCsVeaWSzc9NLlyo +tHdjiS6gzWy2p2iloX73XnRkhCborKy1DbMbDqujo7SkloqNLV4qADVOsQlGTMOopmnFQmlWUjLj +s2fPXH252t1NFWYFJQ+ukKY8y66fvfjsG5/5+sLKRWCsNL3LMLlwSIJCtG8IGRroF7QfHKBNexws +xKc+NTxwMjoyTAZ8wDKYFFsE1x+NGrpaAekYI2Plsd3Nw8dnb749vngVWI9yY3195+7VO29Ozx5c +v/fa7PqFRHl6fOkIKCavuGbHQYq5eeXG61OLR6JWNd2JQn09U1xW7CkET/5nt4WBkxEcszHMCPV3 +0tIY4bBijpcLbnoylunt7N+6+vSrXq6bq8+3pkF0n0qV1qrtc73ZG9nSehTTEUwTlDLFZ1WzpbuT +kjGhe3Oc3MTxJNR/7sYQVIxgsyHYRohMvxQtnQr0Wxt4ulFB+ndWyScHz8dbE+cnFy/laps0XxCl +TGdiO5XvEbQdy87Orl8/uvH69vnn44V5zanitMZxzsLSoWJkUFLjlALF5/u0ySYo3CnkJhynDnRj +qF8Vv9+cBRAmFDG9eK9YXmC5/qkEHAeKvSppJVkrFOuLc+uXU6UlBLe3lw9efvUztl0gCLs5dq7R +PV8ob1jutL9/fwYHFu/mteebrbXBfpPZfg1Vxegkcyu17tlic4ehvXt3Hl25fs83ioNYy5TWp1dv +XXn6vXO33vVyq1DUxDHtC1/8+vb2RX9I+s8OI5o56SaWaaYwOIhEI1K7s5mvrg2PkBCkwkh/vwEv +l5z4tOn1BCF1697Lz730WddtR2FdlMt2bCJXWl47df36g3e600cMX6aotCTXg/3m0eGnnhoBw/SN +MIBdCTIXDBrHjwWjkJhKTAA7OTwI7AMbhV2QFgNBlaHSQNeB2VPMeqmxWevsU3xZUfPN7un21BmQ +Ms4f3n302vuN3oaV7B5ee+Xu4y9unn1xYfXOi69/Y379tmo0C5nZ3YNnnGR7NMiFIA2oNZ71ohE+ +0O9GpMTtandsi+eToRAHo7qgFDPVtVJ3d3bt6sTyke5WlzePxubOZOpr6dq6mZwR9A== + + + Gi3lRaueqayYyV6EMHEuCYPRmd1EeRvhygHIRqkMp9Xc9CzBpjmtxGp1gi1xYpli8xTTt7ehsAhC +j6QdnDYA4Be37y/u3O/OXap0dtOlZbD0XqyxceaOk+nFslPzp57ONE4p7phsVIBjXVk9RHElEGRS +uSXNGmPZjG7UYdgKBnmKckyrznL5Y8fCA/1ncxInJPPlNc1sQpAeGGUdu4Gi4L1YOExXGku3H7xx +5/7rixuX05kp3ShDEIshssCngdsa6vcCZig6VqwsFYvz8XjX76dOnAgB1wPD/RomBGlxfIqgbIrQ +y8WeYaaHhiCg7WfXr2wdPpxYPB/PzhF0PhIxOdZ75Y135ub3/CF5eITuF5bpt4fo34EBcg7HjHJl +TtNLT33KD3woSSRltSZpTUlv95+q29XnH7/29DOv8zzInonJ2euN8fOZ4iIgQ9sbRxDP1z8CwDVb +OyThDg6iGOJyXIWh0yTuwFHz+HEo6CfH28sffvTHI0PoSYA6HwMUhaK1XG8m5nY4ypiYWpfkNMhZ +FFvl9S6BS6XaYmN8tz25Wx/bSGQndbNSra+s7t1a3rnQntxI5We9FGCSJvC8tlXr9k4pWrm/lYXL +sEySJi0ArX5lgIgI/s2xcb+fCPhJoAwttz27cvX8zbfW957uzuwtzW//+C9+eu/Z1zSvZSWniq29 +RH4lX9te2rp78dYb8xvXGp3Nhy+/r7rdEGw56dli+3S1e+HU4RunLr46tXaj1dr81p/89P0vfz+C +OaNB5UmPPAUhk7I1Hk8vVmtLt+88u7F/ozV7ZmLlQnv2IFmeG58/M7t84fyVR7cfvZMuzlebazcf +vPvsq5/fu/jc2OyRm5pixQLLl0SlFYQAN9IgzCMw8EdJQazoZoPhsqxUCUEmLxRhRPYHUaQv6uqy +0RSlMoZ5ID0pam5y9kA1S4lUvVafzhTmdGeK5isUlaPIJHBe/9lFGkAiGlUx3AsGxcFBYKVZkogj +sAnSPUV5FO3RTExSC6peB6ps2IeHIR4H9g0G5l2S1bTjNbtT+3MrVzSjSlBWFO2f6Xiy4w6H+hur +LIZJ6XYbRsxQkA+McoBpA37eP0pHgO+D9VJzfW71Yntyz0lM43TKH+A0Oe86LQyzAcwwLAbsnq7V +aCoeBvgkvf88pRUJKSePR08cC504HgQ/YohGoP0naCTpHn/KH/QzvhGi3x5xIPLkEQwTGCV5PkGQ +BoiUeGYmkVsSODOTmyjWFpu9nUJj2/K6kpQFzjFdnOJlmxVU1cyKSi6ZW8pWNoHXC/Y3uBqKXJHk +wpMztnj/DGBYIHA3FODAYIcGI8AIE4RFkLao5r3MdKWxMT1/dnV17/rtZ+ZX9hvdrd2jRys7z5y7 +8ur2/r1yfdGwS7ZTr5Rnjy7dN2PAL0xPLFxc2b45NnuYqy46yY5iF7PpztMPXr329IswblvelGJ2 +Y+nFU+df3jr/Yr68ODO+/t3v/fnt51624u1cZbE1vTOxuH/z2Tc+/80//caf/vwzH3/34uVnP/7K +J6+880UvO+tlZo3YdLa8Obt86+jGp1d2HjNCSeTTval9EEQhSA2FJZxygXnUvZnuzFU3OQVE3dj4 +kiTlNKNpJ8cVuw7EpKjWmt39g4sv8XLStHOWW+OUSnP87PjcdTuxjKBZnMzqTk82WsC7qUoK4AHk +1nBI9wfk/jMFH0sz6WJljRdzUFQFemB66Xpj4rTqtCRgEtU8jAokayG4EomyFG1wYoKXcoKSU80y +J2ZCYZaX06unrhYrc0D7CXIZjmogfUQgTRQr0Yji8xGABAC0IFih+aTm9vLVXVFtMmxaYGMC17eW +qlYOBsThIZKmY7pZ44Qi4DcgIyFgMU5E/aMc0DkIQGxIRhFj1EcBXd3fGRgQKMIFP/pGSBA7QyN0 +EAKqxqH5NMnGTbdeqC0hmJt0C8l0m5cSTqxpuuOa2TXtsVR6JpGZ5ARLlm3NypG0rVstMz4tmy2Q +hhgm69q9eHx81EeGgxwKq5EI0CTc4AD0pKYQhEQN4PtQ1OCEFCtmG+3NU3t39g/vldtLvBx3YtXZ +5cNktpsvdpOZMVZIARCqakXTqrbTBCGcKUyXG8uylqeFHErYOO2oeta2itn8hJto9otAlgHeJkAU +TM2da42tJ71ir9F77rnHM8tbhpmfmtm9cu/Fuy+8+ezrn33w6qfvvvT6mav35pe3Hzx8/ujqc9Oz +Zy/dfG1q5ebM6p3V7bszi0fAtJK0F3Nqj177aHbtaGAIG/GRDJeS9EaqvNOcOGSFpCTEX3ntPdMs +A4EUwWwHGOfG9trph6cvvj61dlsQk0fnb7725oet3jbOpES9SfAlSqiPTV44uPxmrXcGxc3btx81 +OmujAb7fEj0gw2iMZPLNDtAhFzS9OtHbXli72hrfL7fXBb2E4B4nFRSrVmpvsHI+HOHAuBg+xotp +krGAASGZhO40JhYv3n/9q92ZA0Upmu5YtH9IhO4/0g3273cBy1BtrPNCVpKSidSYpDerY+d0b4pk +gHUC9FsWpSpIZ6GQSpJx22vF0z1BLqK422+TNwwYKQIWGsNdwLH9A0RD/c1sQ/1thP0Od0DMnzgR +RRC7339qAA3Dpua07eSUEetqVlPWG8GQpssJirH9QQojdU5Mx9Oz6eJ6sgAMYFmSk4lkXbPLUESw +nHa5tZevnaq0Tj8pStmvvzc6gllqwQETHqQHB8ODA2FAYsALUwRI0EmWStWbawTjiFLKAkhurmpe +m1dzut0oA8nKuaFQfyMQw5dS2ZVUYUOzuihqI7Bq2A1GyA75qEjUZJgkiCY30ZWUIorZwRDn8+E0 +ZQNVEAj2d5KQuKYJdtrJZ1NNUYwZarJemxqbXKqPTaVzHc0uGYlGsjhVac1Nr+zlq4uTk5tX778+ +s3EFzKSm5RnKRhEJjdBpt3Rq52qhNg/0s2l0ErFp2xmT1TqCg4yPq6K6u3sWJ2yGq9jxuXJjZ/X0 +/e1zD+Y3r7vJCZn3nn/4wk9//TfbZ25RQiFV3si3z05uPnf70Rd2ztyrNOZsO/P2pz/YPXsnBMnA +3Kn2ZLpyqj154fD6u+n8XMJtvPDCp28++64vIAB7Eo7qvFhe2bp7+en3Lj58383M12sLr733tUpj +JRyWoKgkaeVqa3/r3PO3nvtgcv4qMFbXbr6SL86f6Hfnifp8LILEACqyufm55cuSkLl5/cHH3/5T +QcxSfFX3ZsGnm/GFncNXj+5+ttzcR6Lm0w/evPf8W7FkZ9hHDg5j4Hs4LGNojOPrA/1eq+SZ01dv +3XgOEMixY75jT/k+9Uejx45Fw5BrOvMIbMwu7HfGN4AtlXXAezkU92As4Q+DtUsBk0XgumkWYFiK +gn/TMc3ppArL7d7u8qkbVnIcw9RsdtqJ9/o9TyEF6MYRH9PfHknZipiAISbkR1hKDgXQQIBEyRhG +p4CdIcgURiZCEK9pBSDh6pP7W+cfLu7cac9fieXW/EEGiQqaVorC/Vt/T5w+B4Vkjs2k8/M0lwUR +EY+NgUuCoiKY7RE/D9xiv3wfbChCLtDfTyKkc7NA7ipijiFjkbBMIBogn2SyTbNmIIBQlAUIR7WK +3ZnTG6dvzK0cWk4jkWg6sTZOWDznKUqapV0cUVhCp0nwFmZoGAPeiqFSIORxTEVgLRQUJC7BkjaF +m8CSgwDn2DQQzDhh0qzLMJ6sZBNutd2Yr9YXQEYAFz8+c77S3oynWrKakiTP0Dxb8xQp2X92P0Jx +TFICF8zEMEyPRoRomAXpyYuPCVozEFRiqdlkftGwWhMzBwubl0utNYIwi+n66b0r2dwkgXmJ1FQs +NWE4DUnNakYeuHLgZEUphxPu0JPmFEArWvaEF59T1BrLeJroVErdbm+tf0qxuBrLr1Z7h9XumVR+ +xk1N0kycRPi11TPrp66IUhZIQd1oEiRQX54s5v0+0j+CW0r+0XNvvfTqu8DL9PurjvB+yCG4Yqqw +lswumGr6wy9+9fHLb/t91InjkH+U54VKprzbXb0dDAohP8UzYB1rOKYD0gApCUw+0H7t3jYQQhSY +Pc5dnD9drsyGITka0YGIpdkUmBw4wgRHkdFhCA6jEitGoQgMYSwXKzR3dHdS1sdoPs/S5vT42s7u +9Vh6XNZLbhKY5QWUyITDAo1rEh8LB2koyOKoRWIuR6csqw18GYx4FB5XhZzCp5uVubmFQwjRQVpB +MRMKywFA+35SoM1sdtw/ygwPov0WzMMkAutgTlg2zrAuAIbr1UU5iWCi7dWLtbVYak63xpqdPS8+ +gSBaq7FULs+GQ/3KJFEYWHUvEHQQJCcKVXBJQT9syDFTL40C3xSS/vMJIAQZ/ZP4Ed3v5zSjH6Ek +lTLtjm3VKdIJhQQgg2naQxEtGCBpor8jkcA0AFoUUcOQMjxCgoggMcU/AvdPZ/vpcIBmCZOh4pxQ +wIh4KMSkc714thuNAotqymqW4+OKlLb1jMS74QApcl4q1YCjIKwIHFMAvBUFXHAaDMfvp4MBjiDc +CKSiiI6hJpglBBJkzuIoCxiKaEQutzdkrUxRMYqOo4gJ9BLPJjQlTaJq0I8PDUAgNgnMOHkiPHgy +EvChNMYKtBK3SsXsNIjTkycjQ4NENBojmDxOxjHMoiiZAaal3HbswsmT0f65MGeiPXFuZu3mxOIF +YDFwACfcQBEBR4R+dkBkMC5BSjluzXbrAPmq6OlKnCZ1sBA0ATxpAsN1HNP8PgyHRRRi8CglcxKJ +4jwj0ZTmJuusnEEwE4ZlQ4pvrewdHt3WdCDSYvHkdL15xkss4LiFRFgoQARHcTgsYIgKRwQkIpK4 +SVEJUapxdBqNKKaUOrd94cHjd2BMC0d4FNWigLiiGomCLyXgx0eH0TAQln7ghqRIVHtS5IGHIIlj +4rZTo2iLwJV8cTpbnIulpuxYz7DGOECJsGabFduugReDVfBi48nUKk7UEDgbCkq+oUg4gCiCJfLu +8X4ZmTAAMI6nKDKPYjEI0mHY9OJdlksDoQIjDsjj/V+iDhDGgBj7BUAGIpEgjQDvPIz0qyIM4SgG +KC5JoAaOSr7hiKnkU7ExFNYQSEIiGokDJaBFIDaX77qxit+P0aQhCDGGtjnaITEZDhNQAGVJLZ0s +hv0hOBQlUJBrbIpywcf5R6nBgYhvGAPS98TxwMgQgkSUkJ+JgvVCFDQM2APATOyMb6pyOhJiaMrF +UAfHTBARYB1HBqHhgWBgBCURdbhfoQIG9hCHDcfMWzqI7hQWNY4fD4JUeOJEX0s/OQaL+0dxkTcF +zsAx0TcCA7fIsmlFrVhWzUu0FbXkHyXCIZBPoyeOD0eCKIaCBeI5xigXx1Oplq7nMVSBwsToaCQU +oEk8jaMmjsrpeKs6tjk4ArgCGhkK+YZCJMLwpGTpiX4lIjfDy7FQn+rdVmUqB1QQ76Iwn4zVTCMP +MhGCGcPDeDjIRMK8DMyLnMNQGQROKEBEQhQcEQGnjY5QaESztWy1OF4sdmlSNvUkTQ== + + + WUCjgjeiUREOi8ePhwFlRcP9oQ2c9I8GhEjUYbmiqjZNq6MbZSTKAfKZmd2VVGBGPKDiJLnseWOF +wpxl9+8cBgM0TVssawOo95+L9RtQ4gjw/rAQDhG+4XDQFyFgHoHApbJ+P5AxtqKUBb5PFBAkPjFZ +dcA5DFt13MX+IRdED/YftAFeJYYHg1CIATaHpuOamuFY70lphUBgBJ6f2tzfv0niht+Hhv0kHOQk +1gODQiJCKEAOD4QxRGRpwDZiKEBhUY5COAYXSExEokjQ58cjCPgRRCLPpVgm0X9OPUpAIRas0fGn +RvxDmH8EHQYwOOYfOh4aHcZhSGIJSxESQLekY7kz+1eAyATJLuxnAatEQkI0xNOoAeDnG4Ids+7a +YwikECBHhPiRQeTYp0Z9w2BdZPCJJ46NULjKs17QTwVHwRRhwL6NDEbwiCRQMQLWI0GWJV1JqAwM +ho8f9x07NgyGTGCKpgD5rTiqc/bsBcvOj/rJcIhHMZ2iEwyXJ8i43wcbon14+uq7X/peKCp96o8G +Tp7wR0O0xDqaEnPslMzp589cXNs+H4H54aHIk4fy/efyJKFxrCYLeswGCnNK4LIUaQONF4VY8Hsc +JjlSUIU4EmVhCIdDBIXJrl1maCMKgRkISAzt2ACTbBAiQmEEZASZTytiEwqpIBMNDkVOHB+BoxLP +xxnGgfumVYNhA0dURYhRmBKFKFVNp4vzMAo+UYBC/f2ZT/43YWjZUT82MBACbhoKijTuwpDoH0UR +mE14qaTlipQY8sP+UQRBJMup5UrzAFGhIAuuqFpf8mKdflfowQiAExzh8X4G9GShQKA2AFLSrWXi +9WgYB5Qu0CqJiCQq0agQCaEhPwT+/vnDQwLlhk+GfIORk8dGB48HQ6NUv8wjbT55ECzCkBEN4pFA +xDfkHx7wQ4GIIyulhFPJxAxZK5bbouyODAMPFRzqLzGMQhIU4AZPBI8/NXz8U8NBHy2wGZ5JRIMs +R2iekY5bWU3JBHwYHOaxKMg1gg8Qy7GRgeN+3yAUHsV5ysOion84AhA+OgKQzxCIjcFuyM8PnAgO +HB+V+QQA5ODJIMAhSLs0YZpyhkb0kI8dPolEAiCyyKGTYd8wGgkC8uQCPpijWJ4iFJ4oxs12u8Zw +PAwMkhEv5muem2RYKRqJ4tGoA0xjoRlLVE6cCAwNhCNBRhc8V/EkijYFpp6JLS3NeclMMIz5RtEI +BHKoKvBqzDEzSSebsNbnuw/v3202p4eHw8NDwaFBP0sIMpBHqqzxAgpFbVnIeKbEAkSNRIN+noim +XLGcMc+fmjlzsDyz1i1WwR8TNRWIDQkImCemGANXogqqpcuaIlq6w5KmKmZpwgayxz8U4Qghny5W +6mOqGsuk6gxjYAiHwzwUJAdPho8dG+3fy8L75WLA1IVGEaB+66XOzPSMJspIGPf7EAxRgCpw7BzH +uyRlFovjup5R1QzPxwJ+IhpmAGYoXJBZlaMMNMqDlM0xKY62ZUZSKDLrao6qy5xgShKPozwAGQV3 +6/HFuZbAAlYkEYiDgzQeEQlYBYkMwANwCAUUJsRGAgE46I8GAgYvNFPWXNndmcxd22td3h1/9YWr +u5vTCUOnCAmOcCD3sagBAPbUHw2ePB4IApcdZIPDUSJM8hjtSoolyjovYSB4g7DM8jxNUYAfKZbF +BYl2TCUbCTODJ/3Hnxo8ccwH4AGS4yBwnYPk8WORY8dCJ09A/mECgD88CsMhJOllCJghIpQhuEgI +aH6SxlyB8QKjyMkTPv8IQgINE8Kifj+Ph1wZrqXY6Ya9OF2oVZxcWu6UraPV6t0L89trzWbRbOSd +uO1qso2h/MljQ6NDATQEGwzncoSKB9IKvNKJ1UqWqTOGxlumIXF0wuKrOXmpbbx4e+PFZ3YfXJ17 +5uZyuZAYHgoMD4bRCBCsrsYJFk86HOLycK+grXRj40UpY8DdnHhqMvHindUX76598tmj3/zojZ// +8qPPf/72xkI26dCywFKUh8AuErFEysi6RqtoTDZivWrCk9mMY4mMEA5A0WDYEoRGMd3tlteW5158 +9dVqswMjaDCAgAsYOAH4ilHUJkWl+rfmjp1gECRlmrVsJp+0sWgYDcPRECyyUrOQuXx4ZqzTtkxr +bW02nU6gCAlBhCi6LOsC5UYDXooCImDAV8ZyS8ksSIQ5i89r6M5c9vxWb6oWbyal7V7i2evLr9zf ++uC1c68/s3P38sZ8r5yyTQKC4SAG+QkKMSQ+zeIii+AqjZU9drygdgvaXNM8N2ff38m+c2fmS69v +f+XVU3/4xVd/87Mvv/3M9sF6r1PJ6ZyIRwgkTEIhmqEcnrSIMAxMdV4TGzGtaLJTJWN5LDHbTG3P +Ne9cWr98ZvrBtaU3n91/5cHly3unO8VS2rU1gUbDYaC+oADtG0IBnHxDOGDUk8d8I4PBqB+B/WGN +IrKm3CmlPJk3GKKa8srpZEJ3k0aSiDInjvtAwEJ+DIgtFQvbxGjdihxMqM+eqdzaqzw4an/0xplv +vH/lg5dXP3zY+d33bv3jr9/7s6/ff++lMzuLnazrAvsQ9AUh3zALjWb46GQcmUoGl4rRC3Pa1VPZ +w4300Xr6xl7twfn6q7d6b9zrfv65qb/58xf//tef+c7nDu7uJPIGGh71+30RhpBZQiQjiIyEOmZ0 +v0UfTfKPD1IfPZr/9NPdt+80Pv948uef3PzH33zm59+6/MtvH/23n77wP/77z/78G3ffvDd/abuS +izlEFEQr64h61pIaSW6pru5PGDMZZK6Id5LEUsta7XrrXefqdun9x5u//+23f/mrr3/xw6cf313f +2xhXBSLgG4UCGBwVBweDJ44NRH0jHhdJCdGcAnvsqMcFuhlxrmYuto29SePthxtvP95/8e7mV969 +8OMfvPfaC1drBWtuqjs7t7O8dVfVC1jQb9FwnEdaFnYwrjx3rnp/L39mXHjxQunn33vuZz948XPP +zH/hYe+3P3z0b3//5X/5/Qc//tKZf/7lo7/8xsVzC45NQ0igX5OQgkUyiglwIM4G57L4vc3Ydz+3 +/7PvP/z2585/5n77669M/fBLZ37/l4//8uOjH32088+/fuFvf3j1g/vF+/uZ3Zl01lFzHsiVcVNN +SRSbEKIdF14pMDdXvDdvTLxwrvD4fOaPPzz/6x+9/i//8J3f/fy9X3739n/87dv/3//7N3/41YeP +D8vfenvrFz945r3nNtKmHByBQZIFNpYjFTQUIkDKh3w6ETDx4dkseXkxfmk5vTehH81bjy62/uQr +9z56eeej1y+9+fzVjOPCERYwsIwRRZWeSmDbVfLOovLh7cZ3393/5N29n3z15j/8+PX/8e9//ruf +vfOjL535m/9y719++9mvf/ro1FQ6DRwkLTqaJxKEScENA1vMwue75M055eW92HdeW/rJ129+/4Oz +33hz7S++cOYf/uL5//jr9//1N2//+vs3f/u9y7/+42uvXpsuO/0kCERIyB/BwqgnaiVNXkhQL26p +716Mfe569pPXZn7zzXP/5+/f+LufvfBnX9j79XeO/vGnD/7uh7d/9OHmTz5a/+U39//L57aub6Xr +aTcSQJAwRUfwlbHCettdqUrXl/QvP9f90RdOf+u12W+8vvC7H7/4y+89/Sef3f3Bp9f/+999+D// ++w//8a9e/913r/0ff3jzex+d2R4HWPAPDw6FAzDgdothpzN8xwy3tdHL49TDLevpLeulC7mPHk9/ +/3Nb33xz4SffuPLvf//l3/7Zo9//6IV/+9sv/OU3b51ZLM70utlcG0WUtOVWbKkbI7dL2KVx6vN3 +67/42uFvvnPlu++tf+edtZ987fK//vbdX3zn2vfeW/+vH5/733/16q+/fuGbD4ufv5k6M8YDVpEo +zjcYPPnUEOobjTPBqRh0rs1eXzIfn8+/f3/qp9++/U9/9dr/9pPn/vDDh3/40bM/+/jwZ1/c/bN3 +pj57PXtpWh6LEQkJ65cTZXWGMDwj163UVzqJqTQ9l0Qu9qjP3Wv8yXtbP/zimT/7ws7PP7n4+588 ++7c/ffyLb1/+xRc3//YHl/75l8/87gdXvvVK59MXvUdnCrWEBocZgcuwtKPxSiNt1BxizMPO9pR7 +a8qjHeOti2kwG3/9p7d/+cnFn3398P/6p6/+3//6x995a/2Tz5x7fGuNw2gswsZEKcETaT7ScdCl +HH40Lr14UPjmq6vf/8z+jz9/7t9//en/+R8//rsfPfejD09/+HDx1Gw2odIcRhCIoMtJU046kudy +TE6C57P84VTy7lb2+dOxH7yz+r9+997vf/Tul15Y/uLDzvfeWvjJl899/c2NB2dLB3P5RrZggJgS +UiRmAC/GEmrGTJZtJyvi4y5xMG6dm7SuzlufuVb94Qd7v/rk3vc/d/Y7b21+4dnl1y+0Xt0v3VlL +rLWVeoo3RToSpkUm6+gViRQKlppTqaKCz+eFB6fy33h5/i8+PPVXn1z+zffv/v7Pn/+nX779069d +/NmXdv/5p8/+2y9e/NWXN7/zOPtoPzFXEBg4FA4gllrIeG2dsywarxtES43OO8Eb09wrh+k3Lxe/ ++nj+33/37j//9s3f/fDp//bLl/7tD5/7yTevf/31lfefnV0ai1mKzlIWGE4l0zA4LiGS6w2nF0Pm +4tB+g7q/Hn/9UvvR2dq9jfQHtzq/+ta1n3x8/Vuvrn7pmYm3LnUuTsfm8yCnIiLBU6gKlMzwSYiB +aREOeWRwzMY3Gtb+ZGZ3LHFlMfv8QenNK2Nv35h588bM2Y5+rq2e6ZjzBTvGiwrJCgQHNL/ExQQm +rolpXXDL8UTRlAsqu1J2zk2kDsetNy/Vvvnq7F998+Cffv7oL790+NXnJr/6oP3ytvVwQX28mV4r +ihYeYqKoLCRNo03iDrCBRITkImGXhGoatlbkzrapZ9aNl/cTX3zQ+f1fPPP//PvH//irl37zvQcf +v3xwcb44kXNVXo1EVTTKYqEw3d/XhWdVtmYxE0lhpaIdziYvL6Wf2S1+5dHy1944/fbdqdvbpamS +ztMwFPD7R8JQmE947Wp5Oe60FUbXCLLhGWcXuld3Z3pJ/GhCfeFc48uvXbp9euzKcu7WZmGn53Qz +alJjgcFhCKtfrjBqEWQCGHngoJNe1VVsCUEtiszrcsEUKja3XLMPZ3LXVuuXlop7k+npfGwqFQPL +mFR5jsDgCBEK0YEARxMJElEifgj2BxkoYlH0eDq50ckdTrt3Vt2Pnul9/7OnPn5h/ocfXfjhB4ff +fWPtk5cWP35m5v2rtcuzusdHgGkXGbVf+hh3ScwKAUMEUSU71o47KSbUtaOnW/KFSePGgvXJ62v/ ++tfv/9NvP/1fv3H9u++de/Xa1NXNwmLLAd5YkZKW1aRIh6ZMNMrJjN5Kl9MSU9DIms0VZKqq85Np +qxdXZxPMhen43e2x81PZjsWUVTEpSBrJUTAT9LMjQ9TACaAAMZWP8QjBQpAEIylVLQ== + + + ek7F82qOlZWZFE/lZK5iCS4VBVowzon1bEtkHOBKUKDkYTGdahOYEQ4AsU2gYVKh5KKbWxxfmW/0 +6qa0lFNvLOW2yuKl2cxBL7lekDeKykJGnUsbFZWDgCwYgmBIYek8EgU2MAycpm8ggAf7E5uR+Lol +5kV4MsGs5PnL09Zb18Y/fWv2uf32QbeYZBgBpkwl46VmGr0jhvRUMc4SMoOBCVF1QVUY0RCUejZb +ihl5W8jbvCfTpsTpksLQIoqLwKoPDyPRqCJKKYpxRgNUBBIF2jZEK+1m8okiBUExjq55VikOOM2U +SV4iOWAooiEKOCkoxIz6iJERAkFj8dRCMrvQ30Imp1lKpxHOED0iCtI0pbPmeGVmujXfKfViqq3S +vM67Vt/CECcHfP4AFUVjNFsRxbImlxhCHx4Y9Q36ga/XBceWPUc2s6ZWTxkLDe9wIbvdsc7NpI8W +6qu15ERK6yassmXCwejJkyOhYP9s+/AIeuJkEPhNksqkkrPl/EI+0ZIp2uGxisnkJSwnwqdayRev +bL90++DC2vRipZiURZHACYRgWAdBLBgx/UFBszrV9plKbT8Tm5BpY3Fi4crRTRrhwXpxmOzKyZxb +LCcraTMtkwo8SiIh2Qds6YkIABUUsYNBPRhQENgWuURkFMZDINfjvmGkf/srSEXCPBpVadxmCIeA ++ZAvjIaoSICNhDiu/8TKoImY3D/MMhYKScD2Bv00AesMbppaSZFqIHCoKKtQUjNTQv1hT3RTVtHi +LSZC07BEoYq/X2k8hMAWRSRGR6hP/S9Dxz41BPwmAcuWZDtKjIJpMoKrpOAKSv8sLhY1KdSkaYfT +bS4RHMZG+wVhWvn6ruONG+ZYq3vKjpVRTCApW9Or2cJKIjtH0SaOiZrojrVnfAFkYDDs87OcVNOd +Cc0c5/qVtZIin+72TklGxRdSUKJ/KAMj4mFIw2CDxrTgKDpwMhAcZQnUFfgSRWUATUVhE4I0gUsB +WTLq50cD/VZHGO5petmya5qaj3k1vr/lo/+gDUUt8F+cUBSlkqyWDLupW1VRiElyDsFj4agehQ0o +YqC4h6JOKCSiiErTlqJkRDGhKMVYbMxx64aWp1FeoEUdLKyQGBkJhwIYAuuy3LISKyiVGvVTAwOR +EyfDABgonpG1Vv9A4ijp85EY5jCEi0doHMI1VsunAS/pMCJjuM0+qZUHI/2C5+C9wyBSEF2SCpn8 +CiuUQmErHJajsOa4XS8+4RumQgEwvY4o5RS9HkXcYEiNRAyBL/N8MeAXRoYZkszlihu61ZWUBoLH +h0cAcliZ8RQhBjwawxfs5Ey8sFjsd6SdfNJtXKJIu9Ha4vrVy3XT6sYS86nsqptaGgmoJwaJk4NY +OKyPjtBPfWp4aBCRlGa8sJEqrOlWD6D35HEICop+H//UU6HBQRQnk6ox7iVWdbMXgszRgDI41H8s +xVIOAPNA/y7ZyOBJKDhK4aihSQWZi/mGoKAPJqIigSg4WO6Q2D+yFJIjqBuO2k/90YgZnyW4NCfE +11ePWhPbKB2jxRxOJwUlL2tl02q1JvZCiBSOSjSXMmItjElFUC+KxUWtXWvuHV5/I1dbHhihghHA +E7NOalPQegSdjUS1QIjDcIsXiwBvMOogeFJUx3RnCjCirFQEIRsMq1DUjKImxeZVq+MmJyStihEx +2+nkisuCmFO1Cs3nBL2VqpyKFdad1JzudHgx25m6IMjVCKxKWo7ms6rdYeUKSmdxJms43WZ3f3nr +BkbFhnxkMCzTXL6/wY9Kklz/CI+ll9udbcVoyEaNkesoVSCYqiD3gmFAO2440t8T6A9S0agkSXlR +6ZJUIRTgw0FelkrckxMNolpPFpZTxXWKr1F8NYrFINhk+BxJp6JRjecy4YgeCCgYGaeFAkbnR4La +wCBFUl4Y4kZG+oVkYdTlhArN5lmugBFJislxQkkzO6N+MRJ1YCyFU3kYS1BsASOTg0P40CCuqnVO +yAVCbAiSSD5P8EWCLShmW5D72zIRzEbJtC+oBiImTGbs9IpsT1nJRTO2cHKAHBlhGTYnSHkoasAI +iP1YGPIAOWN4AoKM4WGKoNOW07Ps8Shs93uPhjRaqPJyW9cqcEQCsDx2LDQyhAdH6XBIRFAv1D// +a0AQQJQ1OoQBWiNxy7DHNGdCtsZFcxyncydPYIzUYMRyLNE7c+5hpb0CYTpKxxHSs2LjVnyqXzFM +b7D9zTYTTmIshMgjIS4AGTRfrbTPV3qXsvVdUshGEI2TKqo9pTozOFuGyTSYf8PuxlKzmjMG6CUE +aZLW9tLbZmyZk1s4lYJRD1yAoDRgzIQiCieVACpShdV8ZStTXPOSs4nk9MbuHV6rUFIp29ybWLk1 +v31veu1WrrFTHTurKLVUfGxp+1oYNVAqBqClurPJ4la1e1junE8WV1HSY8WcpNVZoUIwWYBP3mgL +am1y8szG3kNRrQyM4CHYdFOL+frZVOEMxTUjaBJCXJiIPdkLJ0Wi0nC/C7PSr/2LuQSViSCe6fSc +xDRG2zBhg0Vk5LZk9TssG7EpgLFwWB3r7hpWG4x3xM8CSiS5EsXXRb3HiEUY0SKQoGtl1WgCKo5E +AQE6sj7mJhfjmeVEenHUL4lyQ1K7vNQCnxVG3NGwMTDCQbDrxOdIJtuvb4+7jFgSjY6gdxmxEoRU +AGzVHkdA1uhXQqtiTM6IzXJKU3UmGaUVhl1JH/NSC74AgKUCoEWQBUFq6fY4GFEUdqOwo5pjIBED +BA6P0FBEldR6PLNE87V+zZYRClxVMGwCZjtxzHfsmP/4ABGC45La1u0eK5T9PjYYEAShwIIQRhzw +1S+eicUUrc1JrXxpK1de1Z02zsRYqWDGewjtcVJeUBsAhIJaj6WmKu0t1W4EIrKg1zAqjeAJksuG +sGSUrMBE/j/38IeiRhTzJHPMiM1Uu0eLpx63Z69FiQSC2Bmvu7h4GMYcf8QORTyMLCrmZKqyk6rv +Sma931gtM8XIJcmo80qFV6qi0YplF93UFCWkzVj71NGj5YM71d5usrSuujMAk2Agjfra8vYNMGOC +UsrXdoqtw/rUpUJ7T7LHYSrrJCZnV2/mKuvBkB5LzC5u3JxYuNieurC291DzpgCJAfzwcpkRMjBu +4nRqeunO5MLT1d6NWGEbw1Mo4UpaXjBqAyOsPyAB7lL1Gd2Zd1MrqcIKQmiSXvayK2Z8EfBDdfxw +fOFaqrimO5NAaMlGK4JaglIU9bbu9kBeEI3JQKR/2M2yO9NzRxSdCIbBKtu6NZaugBmY5I0Jgq0E +QnqhuOZ6vZGAFMVS4YiLEhnDW3Szm6IxFYbjydTk/tl74X5lP3rIJwDi4gCFljaXD17mhOrFS899 +6Ws/yJcWB0d4f9gQ9E5l5uLE5tP16Su6Nx2E9FR+AYSGb1QaGCQQMhnBAK/WsuXTdnzJP6pAYVUQ +CyCmRnwY4K6BEd4XUlkAodhStn7mqeORoSEERvRw1ApDNsAkjMaDYRtC4ro7E8+tggQ9GhDCfX0S +x8i0l1lD8SQOHBabA2Qim71K6/zE6m1GzjrxsXR5uVhfr7Q3E7lZ1aqDyRT1SqW7B1at3zZXqlix ++UL9bKF51vRmwDD9EQWhPEBTIMNSfJHXQGRNkVxdsydbE+fr46eQ/t7jnuZ0JaPDiDXZnjAS07JR +nVs4t7l/T3fbaL+qfBoo4dr4md76XSM5b3utmZmdN979Sq23HsZtWmrkanuNicvduav5+hpGOiN+ +hmTTBJOGSZsQMmHc5bVGd+7awubDUmuf15ogddbGzrJyFaXTkjlR6py1U4uS3gV85SQnB0fgYIR0 +U614rmt4nQiewuiyovcS2cX1U7c2T98ZHKH8QZHja+3uldmNZ630KUqoM2z2wfOfL5RXwhETsOLM +yvUHL3344NWPFvceKO4kUAua3nzzrY9Nd2zIx0fRlGrPpcoH7ZkbqzuPyq0zNJvqTu5mCzMjATqM +WLTU8nK7c+vPdaYvjM8cif1Ceblseb2/iBFT0tuKM8lrYxTfyFdOT8xdgNEYkMqAoiWjKxrN/qZW +Kg8029r2tav33+TkIkoknfi8kwAGuEeLNZIpADXCCtXq2Bk3uTAwxAWCuu6Ou5m5VGmt2NoBvOQf +AS59anzmEAjggSES5HrdWxGNrmz1CK6CUaXBYS4R61y//qJhVD71R8PDQxhGJqzYUmv62u7F1wq1 +rUBQuXLjdSc2HoroIaDupU4UCCckBsZiJ1ZqY1d3D99e3XtO0yunt680u+tAcWlm3YlPlpsb9e7p +xsRBorwkyPlCebHU3sXpNKeWeL2KsyWQWHmtbcSmc7Vtis8CtcYrjUx5vzJ+rTl3Ld89w6llz2mv +7zwdy00CGBjeZKq0Mbd64/zFF87feLM7e+TGxse62+3xHc1spgrLjcnzqdJWsb41v3p95+i5ZLHX +6mzMzF/V3QlaKBFCHqPjQIkxQt2MzXNyTdXL3dk90ahGMNdwJ0FSkKwJ3ug2py7Nbt4HmDS9KS+/ +Ord5ffng2VznHPBJQdiBYEuzG/nmehBmFbtMiRVO6aRLG4nCqmx1wCiGRkiCSsp6Q9SLnNHkjRkt +tuCklmLpOQTvd7PKFedVq8pJKSfVq02fTZaXUsWlbHkjU1hGcAfQo5Ocd5Jglbt2ehYIadVb1J3p +fO2UGesFIanS3GhNHWrupOlNClpNNpsUV4gnZwCqWSFHMem55QvXnnlv+8LjidXr5c5Z0+2ybOL0 +6Zt3H34QjJgIEXMTk62po+bUUX3ybG3yEIi0q9denJs7i6I2xSSqE2enVu/2Fm7Wxi915u6yUmvY +J9JsLgKbdmLaTs0biRlObwDxkyyuJ/PbA4NsFPbimUWaKw8OI0Mj+MAQBSNJMM/ACOhaOxgUj58I +AfnKiRWqj7o8yRQDYQNQ2ebus4nUNNCrCO4BJIDkSFBZkKaB4rITs9nKOohlnk8vTO9kihMobqpa +NQ8od/Pu6s79WnffSnRFJTfW225Nnw8AUUfait3Mlk81e1dzjb1MdTueX5TVaq60qFlNw+ulKtvx +yobsjtNiKVdYn1m7Z6UmUMqttE9niivj0/sHh/fnNq47yQlFKc1OH/Rm9nkpn8nPnb34eO/opaVT +92c375Y6pzUjfXT+zpnzz8A4IGFAX2XZbAMMJIvbmjdPceV0eurq0697mR5CeKn8ihGft9Kr5fHz +py+/Nrdxx4vN7Ow/mFy5zGolN7+keAuM2jXiS8nibmXsUNCakpy5eusVwAlhxEaIBMGVSaHKKjWa +y+WL69XG9vrm4eTCOZKvcUoLEHIY9WAyprudiaWrfdqk3WRuJltfTxQWS60dL7sE4xmUTGWqG/H8 +UgR1OKWUKK3lGge55rnm1M1840Cze7xYuHjt8d7hM4JaAeKKZPLAIJRbp+PZJcsbAwqW4VKzixfm +Vy7E0z3dawO0u/GJfHl+7+wzqxvXgV9Q9WZv9nBu646TW+LNMd4YA/L13OGDfH4iAg== + + + SZJSLLW28rU1LzEBwo1Vx/yQM+yTJLkMo1Zn5vzWxVemTj1INXYz9e1UZYtTesM+BejY8YkDji9E +o8C8m2HIIoDmUcdYvhqJOAMDGBTRBbEGSGlgiAmGLE5ocWLbdJec5BLwZaNBAQQUgsWBa6CZTL+A +fFgCM4AzGcXseKm5fnTIfeUpCGlRrrjJSRCMklYD8pgXS4nciux0B0DyxUwArWrnoNo5L9tjOJv2 +QwrHppvtXUUrs1wSEN3k6g0w/4tb9xe2nm3MXBTMOkI47ckzJAMkjdMPeaWq6I10djZTWOSVIkHa +jlOLJar58lQ8N23EeiyQYUo6nZ003SZIIixfeNK3woqSpuJ07OSC16eRWTc9BmO6qhWOrr66ef6x +nVn0Mgv9Q9NWXZYLCwvn5pYvAqYFOr/QPIoXtrOtI8AhJNCiISkZ6+yfu5evLpwYRDAqA+glXdtx +0gsgtOOJiUZt+d23Pnr00vvBqAOhMYqrmfGliZW725fe6Szd5aXq6dPXPvP5bxWry8CjMUqPloGE +nqj1Li0evARWLYqYNrBFsXGSBXhLYnQap9K8WE08YaeN3WuJzOT0zBnL6XJyBXiNCBrzQ1oI+E2p +WqrtqkZDNZua26XFQmf8YGrhciy9SND9xkm5wkIsMU6BVfPmkkC7Vre93KqotcASA5uQyM7jZOqJ +6RMBGUrWTLx4OpbfoLg8TsZqnbW5zYuCXh4ELwgrFF/KVHbAW2KJKU2r9euDEVoiNYViCZ9PHBhi +QU4c9WsolkxnN0vVc4JUyxXmM7llOGqFgjKQ+sOjEkCaqLTd5DKKpSSjKWgVEHcgBCguCyQ6K9VE +YwyhshDqYpQnKoVQROHlQrK45KXn7dhsuXm+NHZEq9UQrLqZaT3eC0Y1nM4Am8YCN1fe0Iwx8DJW +LCKoUW5sljun4vl51emyWgVh4hibiWcX0qU1QA7AoYtqVVJqyfRUtjhnJ8b9YYlhY068jdE6z3uK +XtXtbq4KrOU0cEYkl4OilqR1eLUejPCilonlZ6tju5NLNzqzlwOQCPW34ufbk6cJPgusU78wOF8p +t7Zq3c1qZ5vlsgyTlTXgv9whHwmiwEvNLG/eBhrD8ibgfnFCcniUBj6aZOI+Pwl4w3BbufxkrTa/ +fepKKjMOwY5mTRvOvGb1BK0BLAPgN8ud6E2fnV+5BONuBI3bqfVc+6KX39Kccd2bIrh+wf+l1avF +ygIwyxDiEUw+Xzm1sPH02NS5ch2kzplKdeGtt77Y7R1E8IybW03Xd1PVrXxrF0w4isemxre/9sc/ +ufXsu0CsAu8p6uNeei1f30sWVgxnTNNrW5vX9w8fU3weECnK5FiprtsTvNLG6RKCJWOxzvjMHsll +YCIbxTOBsOkPKJyQy1eWppaOUMJm2YwkV2xvojd7YXLmLMnkRgPy8AijKtWZ2Qs0kz15khge5jih +Vh87n85v8HILRjOO3XntjQ/2D26dOBEBviAYTeJUOZ5YTCYXdL3N0nEwfIrPwJgNI4Zq1ik2zyot +lCkCmZ3IbnjJFTc1B+YcKE8rPi70C/JXMDqDUhlarCSyS73Fa5o7NjxKgevh5Col5BOFBTAKkG1R +wuuXeiutcnIB0JTpTcQKK4XWQWfuxubZR9XxfYSMcVK2D6egGI1awFlQbBEls0B2AojChGk7FeCz +ApAKVCiYkGBEBx+hu9OiMU7yeYZPrW1dkbQSxaZAnAJTABDOsOlsfmlu81ak32IvISlVhs0B8RbP +TtnJXgQxnxR2LsOYFQjyrJhzvGajtWw6jaFhZmCY9Yc0lEobdhfHTZrSVaOULs1OzJ3tzh8mCrMQ +rAGVoujtJ9UhaBAXQCp3py/Obz6U7Nkg5A2PCK475iQmwogOIAq8fCBk4FRRc2aMxDyImiist8ZP +A4kI9+8Gx6KIAxg4m18p1/cyhVPhqBdB4m56CYiuJ3cV9AisQ+F+FbjtvXvN3g5BOarRzFU2amN7 +Tmo2iseBVgR6rNnazuXno4gh6VUjPgsicXz+aqKwEYy4o6OibTVb46dwKk5SOUFtKtYEzdfc+HSt +veclplDUmp896LRWaMqBIjJCuLrb7c5fmFy6hhFpKGIGQyqBJXA07vdLEKT7g+A1/Y5XmlFJxJsk +4fl8vKx3ErntMGT4fczIEB4JSSzp0HyZ4koomQEU7STGFb2VLm7x/UY2Y9WxQ2DHVHs8CCkQpDBs +CqyIZnc4pSEbvRLQDJMX6r2zvFYb9lEsn0fJOEzGOaOO0skwyLNsNp6eyVTWKS4lqcVya8dOzRjx +CTPZixWmQSID0OKVMnAxgZDCcGVgUaX+SY0qjCeB4AFoL1eXgTmN4B7BFSA4BgShpAKj2gJDI7k8 +uMLOzFEYNlkuXWufypY3gcxQjU4sOZsprwKHzos5SS4BYocRV1AbkgWYMB3FLIyyMdK2rIZp1/1B +cjRAjPjpwSEqgiSA5zITsxSdZAljsrMyOX06guog9CixiHN5TipLSoPli4GgIMnZWGpct+tOrC2b +rQiWGQ0AV+7ki2uGNzYaZGBERVEvENQougCmC+03XhQZJrlx6gaCOSdPwsGgHEVdRW92py53pq7K +5syJQcYXkMFy+PzckxI0EoLaLJNWlbqXmJX0piBm46kuxTgIroEwQcm0pDad2KRmdYGdjETVdHY6 +W14FqynobVpu+II6jMQFoQZeBsMWz2ZqY6fKY6dRIg20EEakgK0LB6XFuYN2c5FlHFFOe4lOrrLQ +nj4ACm00oAwMkr5RkSYyLJU5cRwbGeFpvgi4tNza1cw2BGnDwwyCerHUnGZ2jp+IDA70KwSCC1bV +mmZNZCsHZmLDiC/QfApGVYaP02wShCSrVEkOsEc2hCTAeMGUhsNCLDUdz6x4iWUgb0AGjOCxYNQG +jhUnnCiig+xWbO5Vxs5q9qQgNwx3nJUKnJguVZar7R2YsKO4FSVs4BbX9+4fXH55bOEKcOvhiApM +KOC0KB4bDUjhaAxwl+lMbJy63e5tm16nM3VA0NkgpAPAAB3CCBXNBpe9U5+6ipFplokVSzOW0yBo +IN4Aqk2aLylaVzM6JJ0cHCZIkKzFighcntECWX40LMGoncsvgVQyMBAeGAj6/DQw4BE0AVOZCB4H +y0pglme3ZKUw4md5pSmbE8As2Mn5KOaO+kUArUplPp7uQFEBJM0AZKBE1o4BUTcFlnXEzw/7aNNq +UHRqcIj2B1UYz7JiO5XdKFVPp3LLIH1gmFuurhh2o18JPCQFwxrO5EWtS3AlnMkGAkynvZUvzENR +HRiuCOwADIz4OJbL2U7H1y/ACKP9WkApHAyZjIdheyTQb/TjxSe8+OT/z957d7eRbXtiH8CPtyUm +ZKCQYxUqBwAECIKZYBApSlRqioJIiS0GNUWqu+/1u/fNC37vrQmeZXvWzHi8vPyPvfyXv4o/kr33 +PgUGFLoF6HaTALvQaok8qLT32eG3wzkV4fTHLz5/+Ol/qa+8A0Zl8wsgpR5PJpMyLKsJMh8Oq+ns +nCA9qkzvCuIirokLC4VC9fmr05mZzXzOFOS5SHwqX1ytTH8rFFfTqZlJ3D8kP9N4sbJ+ANY4EBA9 +nvzYWDoRr5WmXprl59GoGQzwoMv5wmwiVvL7BFBtSVvJIzIpg1vP5GYB+UdjpVisLIGmm9uyiYg0 +I2ykAH3FdDBBidQUwLZ0up7nV9QSBLDfKdbTSEL1h7KJNMQsS0VxFt8cJ69DhFia/haCwfWdH/PS +WiAs8cVZMGWLa+9fv/tz68Pf1RZ2s+LiytaH7b2fzJlXk4FCNjdfrR+IyoZmPRX1NUlbLlceb+6c +R+Mlf0AwKjszK98vrH+U9O1ccTWebkQTpSy+p6kRj8vJhCUqm5Xpve0Xf1zbOoPQAFTb4yvkCksQ +fOWEhebj0/Vn/z24J1nfAuMWS9QCQTkaNyMxLRSWramXK9sXy9vfrz79sbZ0HMvMQ2gDvnJj+8yc +egYmQtC28uKarD+hd5qA4lsz9ccXP/1b+NkTkFK5hSy/DHFQubY3NXMoqlsAVxLJaVXbLgirheKq +Zj2HAyZ9+dFRfGnXUvMgX5yNgrJErXi8UhSX07lGGIQkIEajyrOXJ42F5+GoohiPGsvflae/VbQn +2XzT4yuOjsYmJlNFYW58PJ7JVquNV+tPP//4z//3y/f/g1F5AnYjHhFW1w+sCoB58F+42QhQF+G0 +AiCZ5JTHm8UNeXC/cd3jLY6OJb1+Ab7NZKbEYi2blkRxShAb4PgCQdzT+8GD8DffBHzeQiaF78MK +hQv+QCaVmQoEtXCoBMGIKEPkODU5kc2mS9mM5fMmJscSnolcNg8+FNerJhIVUd4yy7t5cSMSr4Q5 +My8sp3INLlEBk1WUH1XrremFQ6W8HYioY+NpjjMTKYiX6+kC7uRTrr8sqqvpXCUcSkWCyWRSEeUF +iCuXsEbzD49e/jGaboDfTKUVTalrGlhywGaLEHSvb58f/fSfmi/Oc9o6gAdZbRal2VhcK4jNlUff +f/rpv3384X9b3/k3uFFYRDatR5K+mcrOgOwJ8mZBejy3fFqa2o0npyJhXlXBWG3w4jz8iSVrk95i +IKzy6sbSxvdW9WVBnF9aPyjXn3OJMli2eKquGE8byydTs/vAKEWZ3Xv/9xvPPyfyM1mpKZhPs9I6 +r6xtPvu0sLKfydVKpY2lRx+K6pZqvixqT3PFZVlbnV/c23pymsWVfTO1xl59vjU18xK4kcg0AAlP +enKZ9IwirQSDOYjXYmAVUzNm5UUuvywrm3yxGQjpleoLUWr6/cVorJzOL6rll9X5d7PLHzL5GbCl +8GDr26cCIE/c+XDRFzSBonBETSYr+Vx1ciIuFmenqpuqvlypPYfgF19I4cvIxYauNgFMRiI6mG5B +XM3l52NxCAEs8PuTk2lFXc0XliYnC6BcAD8yeXzvWDxZ9fuzXg9nmsvV6WeBkPo3uNdfNhgEi1eI +hI0QSJqPn5hMzM4/f/L8DNz9g4cJOACwVjrVSCWqoUARLv7wYTgYEMMhPZmpjY/HqGwqg/NN5ZYz +fBMgeppvivpTiPt8oWKhuFyqPFvbONvY+bM2/TIQNbxBNZWZD0Vwc9d0trK48n7/439c2/mzoK77 +/Ml0XMiktWwOZHJaNtaN2gupBJ5xMy8sZHNmJi2lkmI2XxHVFVFt1hrfQsCo1p4Xy08lc1s1N9JZ +sJkaBMvV2Rd7+395/e6f9ForHLEy6al8YSYa1wEDl6ZeqcaOrD+rNA6KynaYg/hXVGV8n5fXl+Ci +ckFYiURK6UzDqD43Krjnc4GfXljZzeSnIRYGrSnKG4vr3zdWP4rGE5h3SWrMLb+RjdUgp4jG9vqz +H169+ycwXytbZ7y4BDHO0gLEsLvBiFEoPppvftx79/ffff9vn7X+MjX7OsqpU+X1vbd/mlvYDXMy +vpYuKMWTNUXbKOTmMsmy35eyrLW1zZOCuJLOgbkAvhm5wkoyPQ9UwJwCaFlcPFhePw== + + + FrUtiO+SmYYP30DB5/Ozy6sHiTRwch7krag/SWTRUAPIx93yJ1P5bJnPl3O50szsK8XcSqRrYAPz +BfCAyth4MhTWuajpBeOZqBSLzUxuMUG7ESpKMxaven0gz3ApHaQoxFlw03SunivUKtWd8tQLYOnI +NyGfXwbOT0wWvD45FC2FYxA1zEOgZJib4FXDQTUer0bCJvztxdd5ZNELxEqK9ojjLG9Y+2Y06vGk +QUhyhQaY8frcwbuT//ju43958vpf9MpLf1DM5OsSQCZxkVc2C9oT0XheX/x+bfsv+L6hqKTqC4qx +Upp+mRYfTUYqE17ZVLeay4fV+otoXElnrUxhVtK2NsHLzL4ORgreQAL8pqQDIMdXFIFIF4uzi2sH +q88uBPNxIjcbiZWBTMBLsaRumitm5bE5/Rp4Dj4xEIRZ47M5NDjp3Hw4omRyjVKtVa6/56Un6ey0 +x5sYHQtyMZUvrvn8uNttNjcLU4zvKzHXdb2ZTE9xUR2EHGYnU5jn5UeVmf3Z5ZOi+gxNTYgHa7/X ++guIWV6cjWemQ7FqJF7N5OdqDYD3NYh8G7iD3/ermweLzbeCuhqKlwBLGMaj2cZLRV32eDMA1QC5 +xZONTGEBANLoWGpiMqNrzaWVNxFOxj0NIiovNrd2fth+/mcAPB4vn8nU3r7/CxhAMKep7Fw2v2yU +n5tTz2XMUJW83pxmblQbL6Kp0uhkJhA24uk5QIC8sJpKmLmUqUqzz16dqdZWIGKOTuQTmdlwrMol +6lZ1F0HRREJXludmW7Q9jvDwYWxsLMHFKqnMDBezJiYyoFlm5cnM4rvG0occv5BM1UHYwMWDmc3k +VvwBLZedUyuvphYPJGML+4jCqs/LgyAVMvPT1aceTwLL1g9iqcRMKlWLQNAXVQGJgeMIYnOLATY/ +z9frc7srG+9XNg9XHx+X6s/A+6fS9SJbic/PzC0fPt39x/Wnf5pb+x4QC+AE3NBDqMZSpqhuGlMA +7F+p1sHi8qfV9TOj9CQYEeAAQYbgsZLA0KwRS5Zlbe3Vm3989/E/gU/x4rsahYIwnYJYVVxRKi8S +uYWZxePlzc9ZfgVC9WZzt1LdCsfMIIS9YQNi82x2cWH5ZK55ls4tAhKIcFKBXwLDhTFaWI1ETQC9 +1ZndJ7t/4WLVRLxS4BcA6qdycxBDAX7I5OYKPG4A6PVnQLkg3FjdPN49/Kd0YWXck/f6C5nclGE+ +Ahmgfox1ENrd9//uResfc/hunQwgybnF3bnFbwH6lqZeKNbL0sx7QJup7AIo7PhEEt+fIjc9nuzE +RDoSLcVSDdl4UW0cs0YjrzcdiRQFoQ6IJRqTYwkLAHwhv1woNEEFsFMlahYgHI5ZsXgJ9AskxBfU +M5lKubrJi7MArvh8Y2rqxfTsW3Dx0ViFi8jJmCoW65JUi8dFvjANEl6rP5+efcNL6/H07OhYxudN +p+JqOmmBAYnGzGRqWlY2FP1xLF4B//jgAVfI1+cXXmUypfGJFPg4X9DISo/LC58WNr9X9bVQIFst +ra6sv4NoceQPkfHJvCegxjNLgvbSLO0G/YD9IpI4//TpxejD2B++CU5M5FPZRb3ynIsaoMXxpJXO +1iR1WdWWIAIVxGoCX40hxeOmaT6uznwraavp7JSkrljVrSxfB9qBk/EEqjMvryRzVUFqatZOUX1S +1J4B2gTkAPIAWiZqG+bUt2CCAC2bU095EV9WW6k/LyhrnpDi8QvJVNUsPy5Ky5Wpl/NrZ1kRfPES +l6r5QmCBzVRhLpGd8fjBKa8VlSeAChLJGWAOhF0ApUC2QWIBXfh82XBUDXOGrGzzxUeCtJ7IzPkD +SjpT5+IVT0BOZBfA0Uv6DkRwIGP4lhlPHEQol58Gw5vMVDPCWk5cL2rbVn3XGyyO4jsQBQhqogmI +9Gu8tAaizhcXF5vvqzOvi0ozmTAhHAMAD3GZP6RPePlQWAPzKCpPIN6fmEj6vBlfgA9FjGyhKevP +PT45GFajcSuJ+YRpvy8dDhUgLAKUWCiuQEAE4BZMSjQ+BREHhA+ASxPpWUndnl36CPwH7EGv8Srs +PD6emd6OReVgoAjmMR7TE/TH54ll4vxm88X/+l//T7E47fMLPr8YCJsFEUSoGuVwG4pAIK0Zazw/ +6/cL8LReLwCzIoCoTAZfiu33ZSDES6XncsJqrrgeS85PTmZw/zRfRihUc/n6Nw+jHq+gWc8ka6cy +sydqTyc80h++iQJmy+cwQ+L381ZpS9GfgtUNhjDsAm3KZCu8MGeVt7MQ0qbAdaps54RE3BClZc3Y +Kk09BWsjiPOCPBNNqD58fV4+k2ng62PExUx+ChBXAV/Ru1TUtmLxGu7DU2zq5WebL//05PU/mLVd +mPq80IBJ5EDk4mY4Wo4k6tnCim49LdV2JKVpmFuy/jgYNRLZWQ5MMd80qi3JegE+C5BJJjef47Gp +D3sgAwqENhFuSsLWr5mx0Yh3MlHgATlLmexSND7j8cETavHkNAhkOFaDUwrSZoZfy4uP/BH9wXjy +4UTCFyjkcjOxqJqMq6CbRe2xYu3k5UfRdN0bFIIRJQ5QuTAH/gsEWDWeVmYOytXdnZd/rtReAt4r +5mughmD68C2r4Fyyi1bl1aPtHwX5SShsTU5mQyEpEBQnqS05xzfT+SXF2FEM+FYeH08GAkIiVY6n +Kt5AMRIvQ6gLAaaoPDbLLyEUHZvEPeTjiVoqMy2pECzvePCVpsVCuj499SSbtmC6A7487t7sL3gm +M57JfDgoaOJMo7q1vPjM58WNsPD9GskqhMzArokJsE6BSEQqVV/CbE6MJ1PJKlgGCGBT6elw2Bgd +jT58EEgnzVx+MRjWfT4xAHAiIAUgeMR3uukgiuPj2Vy2sbj8FgxRIFiEX8fGC1x0Kp2Zh7kYH8/V +qpv//O//j0rl8YMHsYcPC4l0nYtqwVABd6FJ4GqIZKIEUu0PQMxoplLlZKqU56clZZEvzqczVQ1f +WPkcIBmmXHAHDyOWMMOcGAoX43E9mcZegjCnJ1NlWV2vzu41llrVuVe8vJTMAP+nAiHR5+chHE6n +ZxKpuUwB4PQ6iEciPYXvLAtjFrGxdGrW3htT7xRrL1OAE6vxuJXKVMGJww+lyhvV3BXETfgDsXwg +LI2PxbmQJAoAjyVR2lS1l5ncKtg31dxR9OchrlTI10CnuFiZi9fSBRC2RiKzoJvPdGMnBNKY0J8+ +/S7HNwB+ZPj1VAHfXK+a64XifCQKUV5aKC6apZ0ovv0chGHaH4Q4KAl+LZHU/YFcMmWCs0ukgJwZ +kOHxSd7jlRLJhqY/Bb0DlOX3i7H4FLAlkW7EEuDg+AkPn8zMVxv7peqLVLpyev6vr1p/m8wuxBL1 +ZG4+GC1N+jG2TaRqfrR7RdC4TL4JSCAaVj2T2QcPudHRVD43B7YIRAhb1FOzurKlKRvpdH0Sd+pL ++vCNe/z4eGRyPAFWJZqEx2uAbckVFgNBbXQ0sbLyFvQU3CWEeOMT+aBfTCcsVV6AK/zhm8g3D6KR +iAFWcXKiMDaamoQDgkY+tySJK+C1x8bjHk8G0BSgMsC60Wg5EFDDYaVa2Vhb249GSxMTxWzhEQZ6 +nBUI6+FY2c/po57MOHAjUMznFszyE0HC4Aggkx/fBZNNpQxwXtXGe7PyJpWdz2Rnk+lpr7/4cCw2 +NpEOhrRYYgrCZOBGNC7jzkKpSjo/n8xAeDubLcz6IwpcHAKfeKzEcaDUuXjCyOIbsReN0ja+niYz +DY9qVJ7LxmMASLj/ubikmpulqZfJXGMSX8IlQNCEuyTFLVClVBICn7ky1tE2QMi93jwQmIYoKQ6O +spLJzmSzs+ATdX0jk63j+8iCWnX2ULW+FaRNzdhOphvgnoRcbWpqyx8UoomyUX6pWi/gXkBFMKKO +eZIARJPp2USiCnYGwIM/YPqDFqiqxyuOT6QDQb5UeZTK1kbHE16fWBA3FRPAwzPNeg7h2CRtzxiJ +WnDrCV8OIHFBWNOmni+sYTIEcCyos6Et/ulv/+dnL08h7ouB7SosJ3ML0WS1CADD2AqF1HS6ZE1t +T3oKk54c6A4AoVhqXtRe6uW98fFUIV17tPpdlNNAkHxBABiKL2Ra02/Wty9EeXlsNJyM6jFOB3UG +tgP2BnD1cCwb5mqy8RzM4Ph4JhK2gDrgKrAilbSwp5Qz9dJObXbf4yn4fRL8iUaAzxsgzOGQBnDL +4+MhpgMc9c03YY+H56Ilnl8C75bNNkIot4AzhWxuMRyFCG41kVmEP/HMvC+s+QIipqOzs4CLoomp +bG5JViFAnoH4Ip6wID4timv12XdG+VUkNh0MV/zBcoSrTXpFX0ABOMEBnEhP5/kFbNhOT8H1AV1j +A2qyYlVf5YtNALdhuIsPBDgZj0vodhNGrjgrm49ml95V6m8SWFwzwULmslPT9aeLK/ul+utYug7j +RXEpnaoAOgJQyudq6ZSRy+r4ypi4BqAUi02pCscpXk8WPLumrvGF2VSqkivMxVL1SLwGXjiersFD +BsNSNjcNzynrjwAuZvMLIADZfENS1yJxCBl0wMDlekurPAdpSWWX6RWQYEamAGGCBoFJzAuP4Gqx +1JSgrHqD0h/+4AcDqBtPsvk5CAAnvWAN0mB2ltdPVjY+gtCGOaVUeQZPCJYwmZny+AoAKqzKk9Wt +k6dv/g6CZaBuZu49oMQQZ/hDCsgJGLfxiVw6XZW1ZR/FlaR982B+I1FAd4WJiRQHkp+cmhiPA7oL +RIxoEiDHsmI+SdI7tSGsyEHEHdbAwuQLgJbXEok5AAwg4dksJp0mJ9KhgPpwlAuAShYWStOvzdre +3od///nf/F/V+tsHDxJgzeDP+FgagBnYN68XwFij3mg1Fg9y2FBdWFs/FqW1UMiY9EmTQSOSmFLN +R8+//fFf/6f/B3c4jFbCHIDVed36NldoghCCsoAgxRIVoCKXA/i6CboQDAPz53L8XBpfpzIP4Z43 +oCXSi7z4VBCfeP0qNl0ElTCnAi4SxHWwOWArMoW5cNQMcZhAq9Rf5UW4PkwQOFM9mQR9gR+kWEzJ +CTOSsb62faGYYKDms/x8ImFlknohV8rmwJFh7aYy/cqwnkY4IxyWCvlGLlsNhnITEwFAp8FQESZl +dukQTEEgJIG6ZXAxTjUYyAMaSSTKgrRmVl8rpWdgHLx+HiYaRCvEyalcPZqsIc7RweBsSdoGHIDd +F+JSub6rl5+D5wKlAyiV59chdguFwNFkeWFlqn6Qzs8lMrWcuDLhl755GAkHxUKh4ffnvJ6kZzIB +980XFmqNlm49odcx69WZpwUBkKqWAbuUmAFfD4Bh+9ufXh78fakGUje/+fh70B0Q8qL6KJ1fBHVO +JOoQzgdDAsTC+cKsUFwGFAdyAiguwpmxxHQ8WQMU9OBBcHw8AY5jwlPw+IRwVEf1iegQCJiVl/F4 +BeC6JD1OpuajOLmKz5cffRgYHQ0H/VI8WgPzG09PVxpvn+3/y/L2D7PND4AtvV75mw== + + + b8At4tIACP1CQTmXn1X1xzOzBxBggveHiANQ2eOnF5q+5fVJQa5cMF42n/7w6S//+S///F+OTv/B +H1a4qAVwDuKaXGEJjAwIFb1dtJkTlhIZ8HfShFf04MvjKhAOg3LBM0P4Fk1WwHJylLcPoCusgEym +0nWARiFOjcZK4LM0fMXG21S24Q+pyXTNFxT8IXCU9WRqMZVZAt2PJWciHAhYJYMVbQMsWzw9V194 +X196B5pOdCmA4kIRCexMmNOCYTBQjYKwUeCbYD0gjpucjKeSpRi+8RY42chAXFB6VW0cJZM1Lzj3 +sVgc/abFxdREZiqZb2SElYK4kS0sBSOS15fG90Zpj+aaH6aXD1P5RS5RxURHRE6kS/EUdrVBOAlx +xMzSx8bSRy5eHhuPeTy5WLzMxTR/oADIIRKrZgUQyFoyBbOsPHwY9kwmg7hgIY0L2TJgRhpwYpZv +FOUFLq7l+Hplel81XynmNi/NQwQUTZXBVArFhdLUk0CoGI5osv6El5tg9MIhwzNZGJ9I+P35VLIM +UeHDbwLg9Av8Qja3EAiXxj2A3PKI6IIAS+IPR2MAdBPJSioNsGolnV2IJyr0VlYwO8WxsbjPWwgG +FZ8fNzmE4CiZaBSLWzA7+eKyIK+lsuCGlIfj6dFxgYs1coVZTQe/vDI5CWw08vlGNF4Clzo2WYin +q7niYl5oKtpjsD9gvgDLKfozRXuE+9InTJ83F+Qq8eRsMjXrQREqwB9/UOaFJYh3wDbyOuaLvH7A +SPnxSYBbajq3kpceZ4W1dH4ZJiIIYI+zQCBDEd3rF+EP+LtUBvf45aJqMMRHosUIKRGuF0tVQRQh +HodQDpDt7Px3Lw7+w8L2jwBfAQCD5MTicO5UIlPOFRdqix+06l5eXoulp8HM+gBm+ARgCDg+AMOx +2Eye3xakl4rxMppA4z82EU2la7X629LUXr64EYyUuMQ0RMGWsZnP1wHjQVg63Xg9NfuOS8z4Q3ok +VgaYXa6+kpQVAH7wLV9cfrR98WLv77LFxQCn+CNivghh6Qr4JqAukaprpV2zus9Lj0Fbx8ajXl8G +0BcYGdARuB1wMlNYi6fnAezx+RmwM/F4STPWm5vvq/OtZG41zFUnvTyEddlcnV6czYfCfFFszi4f +za+ezDePI/EpEAOfjwerC+IEhsgzyQcCeqG4wMV0Lzi4sThu+RgvRXGbvsj4eHrSU8wXlmvzLX9E +G5tITXjSYLTDEYiV8nA8pq0eJkKk+KDs4F6DmD+fyuRmKR7RPD4pELKiibpeeg6Ujo6lIGwsT+2W +qq0ivvZCBnw7Ppnw4Hs6KgFv4cGDiN8vl6vPn7d+qC28iKZnQ1w5GNZCYVNSHuFbfaNWXlyvzb1f +XvshHIXgpRFLzkcT0+jfvfkJD/CkXKvtNh9dbDz7u9rCiccvj03k8MFCegjMWrwcTc3ki49l45li +Ps0WFsE2IjCYzPsCEDNWheI2QDXaXR/R46Q3R6/UkcDiQWQdS83EkqDjU5LUNEv4sntwtaK8Xa6+ +LoqrEJCGuWI2P62WthKF+WRhQZt69ejlP5i1FlblJtP4cu2wyOcXVW0HQolccS1fXM8VloXiSpTD +Pca9voLHy4MFNso7grxKBfd6ND7NC00IEwIRMxSdyuZXGksn9YXvQAjB4OCGw2mAarO6uTo9/zov +r1bn95c2v1/avMjya6DUMDVW6Vlt9iCRWQ5H6+nsXDoLVJTDUXytT4SD2V9tLB/vtP5FMJ76gwgn +ojHAA3OZfC1TqGjljYL8OJ7ExAioFSjXxCTEcZgfwC3Q5YWisiZIjwACZbILmfScxyOMjSf9/mIk +bOLfnAaKCcY/LyynMwv+gALW6cE3/ly6lkCHqIOCA9Ko1L9tzO+DQfP5U6FwwTBXDfPxNw8iYPy5 +mOUNqZEYhKjTmNodpz0w07N88ZEob8F901nwAmWvVykU1iHK9kFoNhqFI4FXoWgN3J/Pr01M5EdH +Y9GQks1UsKiRmMoUN+bWL7Ze/LkMRgA8eLwE8H5x/YNqboHTnwRTEClnCxuC8hiMjzdQBEmIxUql +0lattlObeQ28nfDIXr8Gtgtsy9hkyhcSuWRN1J5Z069F83EyvxAHesMWwXiNQoxyIgUGuRlNzIUi +5XEPvucIjFI6N6OWniqlF1r5ZTY/H0+UASeEOZyFHA/AeBXMERjhXH4mlakEIiKYXNDHjWefX3z3 +73h1C6R3bDzlxQxeLZ2uBDGPUQBfI2lPwRQLxbWJCQi0kxCSB0NSPGlk8vUQp4FNK2IeFYLEhUBQ +AbOZyi2lc4tFeZ1L1CDaygmP8sIKRA3pLAD+mmpt1Rb2dl7/+cnrvzWnX4djdX/IAOwqCCuUiZrL +FzetyktR24ympyHmnUTbpUnyigZQTd+MZuYiielUdkFW4aarkThESdPzq60sv+wPqD6/6g2oycwi +BKdoqMPqxESMi8pm6ZFmPC4q4Fxq/gAEdGokYonSuiRt+DCgtiRlsyCuxzONUKg0Nl4YG8+GQ0o+ +PRMMiPi6H4jpyju1xmtFfwzg2RfkJbk503gtFpdGRrwAREV1TZ/6VlCep3PzgYD88GHM6xNUbTuX +XwiF5GBQAySZB5ML/lF4VOBXwdx5JnMcZwLqmACL4ZcjCVDPeiSsx8JaFGKHVK0grlnTe9OL71V9 +I51uJNCVGIa1sbz6NhQUwaJCMBKKlhO5BV/YmPAK/rAeCBvpVJ2LKtG4Ap46nWnGEyvhcM0XMLwB +edyTjianYtStF4zp8eysNf129dk/lRc+ANQBuQLXA1qpqE9m5k545RnVX0ywZqA4YNXpFfMLWWEd +phuwHFrmRMXnF7x+AcQyka6bFVx8HQipoN1zS/szSy8Lcj2eqYLRVoxX4IxicT2dLvsCBa8/VyjU +4Vxw9B5MLEuYzeZMy9qOZ0p5fmp1+1g0IOCyYslpXGnu4X0BiZdW0nlAKVowogGAz0vrsrGD0CsM +eiEB1QWhISr1glCLJsvg9Fce/aSVXsOk06uO+JywGE9PBTk1FNWV0tb2yx/Wn3xS9dVspgxohBeW +64vv4hlUKH/QhDAnJ6w2lt7rJbADvB8AdtgE4czwa4ncoi8EDAeklE6lpxS1CeFPOrcMVjEvbDYf +/SgpjwEAx2KVSQ+grOlsdiEag3C7FI6Uk6nlZLpZ4NcDAeXBw4jHm0tnGh5fEcIoLlGfmn9jNt5P +Nb5LZxcfjiYePowD5yH4SmZmAlwJrgBqJSpPeHAQyWkICkbHE1xsCrxqMjUTCGoF6XFOAiMzBW40 +HFTBZno9BULj9clJfmI85/MDnsG6PwCJeLIUDMmjY3GIHzOZhXxhEcsfUbC0Usl6wgHMC/A+TvOG +tCBXAi1OpJYUdScYUpKpagYkIV33+JTRcd7rBZdaFpVNpfQ0lq6G4wYuH8gv1eferz/7o17bBbyB +fSwRHWctakQBVnFTmcLjfPFZll9PZgBgqJSDran6s0c7YBN2AVQDDJsEgBcCHA4hOciYCEjeKL+d +nj0R9Y0wtoHlwxE5lqwmsjNBTpv0pgNhVZA3s/xSPFl+MBrFjiMvvkMNPD64hiCQxpmg4KK+Hc/N +jk5kI1wZ9M7rU6KxCgSA4ODi6Vm9vAuh+pgnB0ZYUjcV4wXgDVFp8sVGJCoLhbqur2Negl+c9Muj +E4VJnwimJpWd8YeFSX9eMdZXt77bef0j9W8XJjwARCWBXypVnkWiJkQ0srKlm88167kgb4D8fPON +1+/nUxkIYNUAZ+bEbWPqsL74KSc0sW4VlEbHYoFgEaYsgShIHAMsPZYAM1sQmnl+MRCSwcKXp55D +fPdwLDPhlf3h0sOJPEwNIFtR2ihid8oOBMhBTvdHpsZ92phHiSUWq413VuUJxBfhsAx+6tHTz7vv +/rVc+xZisdHxzOh4LhyxwLpisOYR0rmFd5/+29L2H5P5pbGJwvhYNpOdr0y9BpT7N//d5B++iURj +tfVv/2Xj+Z+K0io8J3gc4EM6Nw2C7fHJABViqbXS9NGHz/+7or/K8Mu+CDyMCbYlGIVQBXDXYiKz +AtohKavZQtUfzMKMe7xKJFQt5Dfmlj5kxCVPUND0te0XP4XjU7HUdDRT9QKG4WoA20BPk5lpfCs0 +pwOmrTW+n136QbVeANwFCMRFtALEsOqaIMNF9FEPIOSaIDwrlb8rFLfHJwB8FoHAcv1ALb3mUrXJ +oDhJPSHI7Yn42HgiEtEV/YVZbcGTewPC6HgSA+2QChAUcGmqsGzW3mw+/8eFRz8UlMdeuMVYNhGv +TU4Ko6NYPQGWhqMVUX26+/5/nGt+74coKTdjVV8a5deF4jqEhxO+woRPSGdmJXwRswLhA2bDknWj +9MIow4xMYx6GQzuQSFe5hBWKwq8lLj4djVcTySkMhTz5YBjiqXkA+YGQAr96vPlIRMtkGvnCHDYe +5xqCsl2qH+jll+AlxzAlDui9CMg/GMStkACuj48lI5wpCBCqr0H0N+EB+CSp2jqA87GxdCbbbD79 +k2Q+y+bWksk54IlcnK9Pb0YihQcPQ9HkfJZ/opUPZhcvcsLapC//8GFUU1ef7f6YykEokf/Dw+i4 +RygUHwFaBlsBQTrAKhnXVW3x4sqENwf6GIrWk+nF2YWTR0//HOZK3/wBs6MQyyRyswBLHjyIQwgA +YpPMAvd2IEDzAryvt4CrC2ufJOP5uEf9/+7J5/VdP8Cv9XEJGbSPS8igfVxCBu3jEjJoH5eQQfu4 +hAzaxyVk0D4uIYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1c +Qgbt4xIyaB+XkEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3jEjJoH5eQQfu4hAzaxyVk0D4u +IYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1cQgbt4xIyaB+X +kEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3z+v+9J5817p58/iaZnDt5O7t3vjeysziSrC9p +u/D75t6n8/2zkbWR5G6xfnY+e9g6Pzw92Tv7iSvBkCjIKlfc3N874jLsSA4O4tbPDt8dnsDgVmvv +aD/LFeDQMvw/InISJ9J/Oz+N8Kao6IIiq5JpyvCPzJmiIQuaJiqaImqirHDHeJBqCIop67KpqqKp +Ow86woNwTLUs0zRUXVe59lmWJRmWaBjsIMftejrIcbv3I09HTkYejVhcJsvtPB3ZvvYT8M1Evs2c +XXx6v7F3Diw5uWTm7trpycbZ4cn54ck7nmfDM/vAqutfjKx9xG8kkX219WRh/vAI56B4+SPwvriz +2lw7fbuPP96YlJ/9osxlfjw+OoGveHiss8M3F+f7n3BuYF7P9jqOaL0/PHp7tn+C38tccenk/Oo7 +/Ov8p480r5n60m796OP7vV0pyxW3Tw5b8OUWXP3k3c0TPu8dXbAzDt/Ckd0OOdk7pg== + + + I+Ax8JjCbZNy+ua7/db5zOnFyVt4tpnTH3ul6IAmBQ49//TLp1yj8MY5t06qmOyVti8w4RpFPw40 +HT/1TMdPd0CHJPZOyfv9w3fvz3smp334QNP0w+Hb8/c9k2QfXejhwQfFTJ5fnL25ONo/ae33yhJ2 +ao8cad/nlqmSeyXm5OJ4vXW+93m/dwN5/ZRbJwynq1fazvY/XRz1ro/tw2+dppPTrfPD89YX1OyK +rk909OPDoz4m7cY5t+8NBFHrlbo3e5/258/2v78AnezdN3Sc1YsF+hlCpF8gpDs8uoY39h/3aE6u +Hv0XJmOAdevw5Asm5jpmxGNvXeYOT3ql5fTj/tne+elZzwRdnXDrVG2dXpy19hfO9j6+P2z1Pll9 +zNUdKk/j9Pjj6afD8z5057d4DgoAen2E4uz+AVce8BBQdUNANwQcXDrcEHCQabr3IeDB2R7EM0dr +p4ef7lUQ2LPVd4NANwi8jSCw50y0GwO6MaAbA7oxoBsD/hox4Mz+5/2jrfd7b09/uAfFQF6+LwFS +P5QMeIik3sMQqQ+a7n2IxFwOJZN+M4czqNHRp/O3s/ufD/fwgfqA2tdPunXi3hxdfMF7/QoR0h0h +hIW9i0+fDvdOZr5I4yAC7H5mZtBV6PTg4NP++ZfnYfii8Z6Nw9veHfPbu/DMvRPSO1Z6++Mdav86 +ydzw6b0k9uxvPu63Lo72zuZ+/Hh6sn/Su7Y4T7x90NQvkY3Tk0/ne19B5NWJA+1cB92EIzvXL77A +/uGz30cYNGAvb+v06PSs9MP7LyYUruO9n456z+3bR986hT3303y6ODvYa+3bDd+9UnXjpGGKVCCo +hk+vzPljzxz5410kCLQ+SBnwXIfUz7T0me24IyiycXp4ct7sJ5vx2+Qq97dsn9i0rd7woaOvyi+4 +1Ye7qD70iRhcAHSnyZKvKKcMik3oW9AG3R7snR2evz/eP++9aDdMduF2qpK3Hkecb+wdfik8Hb74 +qGck9uELCaRrxOChA0zIF1IT1wmRBjlz8qF3M/fhLqxc74QovROi3BMXOjxxdP+5/WHpMFndP3u3 +j5wcPkjUrzu6x1Py2z2H23j0azUeNU5Pj2bO9vf/2HPudWC7jn5H6094LXlPco59dPC4/VW3TpPk +9lddMuPt4dFe7xWq4UsL3KvOsZ4JGZZsQO8z87b3mbkLLy0JPW98cbb39vCid5fcPvzuIPLp2cf3 +p0en73r2VIMTttxf63ZvbNq9W0/X+yom16a5Nu23lK9B1/yeE7ZDo/r9LXIaYN3nf7s+5DtS+WFt +3+1DpgZc3+/rbgc9N0QO224Hb3r3/8NioHumaNAN9O9h14aeJ8vdteHOai09p7kb7/dOTvaPtvaP +9lv9xNjOE29dEjd7rkp8LZHOEwfZNA58v9v9wUxvvtCqMoQuuGeKBt0F90zIp/5WwPS+9OU3cUez +h58+Hu219o/3T85X9z4On0/qQ8IGXPuP9+BSPRf8hyFWetNzXmFo7Fl/W5wOsD0TufZ/nONH6caP +vVJMP/Ueb7QPv8OGy6PTs9UelG4gzV7vgjjgZq/3tdzDuEFKz+miobGAPVPUtwUcnj4a7Qtm7lrC +vPfNY9ixd7D25GR/r+fua4CrrdXT3jtor51w65Sd7RO07ZW0vbdvD88PP/dO2tUJt98QcPTD3k89 +CyEYi/O9s76MCzv+9lFJzzS9wXej9Z79Y0ff/rLPnn3WNTls336Nnr9XYbx51uDWRc5Pew9bTgcZ +jxycnR733mtNB99BFa6ftviDw6OjfrrHj+6AopPTk94teqt1cXzx5aaw62p07ZQ7ikz2Tg6P+3jk +32iNypBvf3dfoqPWvWub6Z2iQU+h8KbbNjMY6t6HTA24vt/Xtpne9yUctr6Z1r3rm+mdokG30L+H +vhn3lZeD75/cxpn70jjTh20c+MaZ+4OaWveucaZ3igbdB/ccJLmNM4MqYQOu/fevcaZ17xpneqdo +0O3ZF7pl3MaZATd7buPMMDTOtO5d40zvFP0GjTPDUCIanvafPqayXxtyR1M5xJsV9tGQ5k7G8G5U +Mjxz8ds9x90+w33aMnKWtgra7S/Jcs+aWO/vdkn3co/43lOcv4PteVz71pN901375tq3IbFvPcuq +a99c+zZ3BgO/b/i2jyxwrduQWDcXvbnWrU/r9rsGb651Gybr5mI317r1bN2ul412+2sLuGdGrmfi +f5UK7lBVCV0l6kOJjN+zEvVMvKtErhLdVKKNwx/3jzaO9n7a7W9N4iC2pf2O3hymiZzWc3Mde9TN +Pvrrrp0xTHZQ6n3vjMHflObTR9yWpld63E1pBmJTGomTyrLISRr8LXLwfxl+hn/L8AX3mzfDujvw +uDvwdKGnR/s/7NvvnO0fn37JSrgbvfzsRi+3TNvhydv9g8OTL77s+7oB+bi/dz7bh+O+dsawbGQz +KFDqHr5M8naj5NtuAe7j9fHDslygH5p+pwsGhqNyM+irwL9kuYazzNaX+gy47W6dHn88/QRgYf3i +C4brVzBzd2QaGm0ah9Uu9IkWBt0q7J0dnr8/3j/v3dINk3X4Go0aJitx7zYN7Dnd++ELNdVrxOCh +A0zIF+bwOiHSHRDSs4h96N3UfbgLS9c7IV/o4btOiHJPXOnwlD++yvy5qxC/4jnc+vOvX3/ub8dF +t/7s1p8HzgDfq/qz+1KUIaw/k15iBVoWy33pqFtzdmvObs35K0yJW3N2a85uzdmtOXcnya05D1mW +1a05D5pVuE9lzLeHBwcXvb/VZFiUpk+yBn1725530/t0cXYAgeRWf7t23zhpcHP9TJr6o+3GObdO +2k/7R0enP/RK39Hhu/fn8D3fwr18eyax87TBnUBbKxunJxDUnvRuRhznDVUKzn0vsZuCu9MUHLNC +5Xdn+/snZQAv+2UIOw/fnZY/H54e7Z+Xz/bflk/P9k6+VEVyc3MO3+Lm5n4ls9K753MTdG6C7vZo +cxN0XZ54cEJxvedy0v4R/NJXLuvaGbcPqc2eCdv74+HxxfkX3qZ4XZ3ax99Z9mf2kGB8E43+HffO +zLLIomn7n+FTAKn31MDH/RZY0bO5Hz+Cve4j+nKeePvq0LM2tB+27xjTeeJgZ3oHPK/YZudtrI4Y +XJUbwmwcBIO3nq9ykzluMsdN5vQckGDqhiVz7MwO5XTcZE6nN3GTOW4yx03muMkcN5kzHLHs0ZcT +AsNTsnczU25m6q95lC07gB7e1NS9XIJ/Pzfm+IpsjZuAcrfnuL3+vIG3C/d7a457+X6Mo8Pzjb3D +L5UIhi8/fW+25eh9E4gB35aj9xkZ8G05eifkd7gtx+ADHNeN3q0b7dfjDIsHdXe2GlQX6u5sNWgu +1N3Z6q9i+aB4375Nn7ur1Vc8x90+w33a1Wrr/d7b0x/cVypt/zVbWg2PebqHGxf0vBubu3HBYKWp +3cX+g6JCpwcHn/bPcR7O9t/2ZRyGJXDr+eWtb3t+dzAdOsCEfMEBXifkxzu0Auske7+rGOHr1e0e +BwuDMjm3U9Iannlxg7ihCeLcfYmHaF9iXtKSvVLXuyv/ccAp6R1d3QW4khSxZ0re7/fTDHh5+O3T +pPZO0w+Hb/toy7SPdtMfdxq76W76w01/uOkPN/3xSxSa9yX90TshbvpjUJ2wm/4YYLvupj/c9MfQ +pT/O9/poDHSTH0NdwW79dp01t/3ikbO91vne0drpYe8LXtjJPVLVvtPAbsp0cnG8Diz43McuE9dP +uXXKWj1nWIclMOidokFfV31yunV+eN76QvrqejoEj358eNSH8N045/Z7doWeN5h6s/dpf/5s//uL +/ZNW7xFdx1nD5BXc7Zd6Jsrdfum3IO2+bkLUhyUZ9j17RKHndyCdn/YOwk4H21UcnJ0e9x410MF3 +YDfc3ZTc3ZSGfDel3yST9Pji7M3FEdjmoU01uvvADMEC1T7CxCFJBX/F6jQ3DfvLadgrW7T7hSWK +bjLWAULusBOt9/6gwe5D652OAe9CE+9hF1ofNN37LrTzHkHbcKX9e27NGLasP07Xfcv7/x6y5eLg +pcvdGNCNAYc1BuzHDLpRYF/PcU+jwJ7trxsFulGgGwW6UeDvKgq8r+1fPe9Q4MaBbhx4G3FgzwLp +hoFuGOiGgW4Y6IaBf30Y+PT09O27s73edcCNAe8+BuSl+xIF9kPJgMeB2j2MA/ug6d7HgffyHSo9 +Y253V4rBCAT72s+h36VAdwTr3B02BsUc3P8dNk572MdheBbTudul/hIh92K/kNvuIO7nnd/DovR9 +ETXoOn9wBCE7ezd76c3RXutDmWNDpx/3WofnP5X6yKR+Ov/pqPdChX30nenUPJI5fCr11+yj4+ZO +72QZRV/2wsV0d2zeP9G2uo3f1MgPT8Z7UMzefYqL+nzd8bAoTr9vcR5wZNRzH9uni7ODvdb+Vmuv +H/Rz46Tbz8X2J3z90XbjnFsn7Yf3faxBPsJcOHzP9+Ckr1HYedrgzp+tlI3Tk0/ne1961+j1cLfz +vGFKrtP03Js9jvSed9baP4Jf+sqpXzvj9mVY6dnE7v3x8Piij4LQ5fF3BrVmD0lvmv2U5n6j3QJm +mSo3bZs1fNiv963l2m/Bnvvx4+nJfh/mznni4Jr09rP2bdOdJw52wWnAYfxXvHJ9WKD8vca+dwMQ +hww9ueDJBU8ueDrY37KN/PCiJ7fLemgqBV+BKFyQdOev9BnirHq/KduBtwt7Z4fn74/3+3gxwDDZ +h3vZNHp0eL6xd/ilMHb4YqiegeeHLzRYXCMGDx3cxMSHLxx5nRBpoGekdzP34S6sXO+EfGFLvuuE +KK4LvTXM5rrRu3Sj/Xoc14O6HvSWCBlwD9o7FBhwD9o7Ib9DDzo8qWr3pZIDjIx+czc7PFPy2z3H +8InFPXwb+33d1On+vtOv121zhg803/+9ndwtfofAyvevYINu5I/34FI9bwMzDOZ9AU799OXOneGz +gRIn2v91++lypFey6aferWP78DuMBY9Oz1Z7ENdBNBz3EB7e621RbnUp4B0p1HBvKXIr6ZFbpmn9 +3i9D5XsGuYO+GwfvbscxIJbg67Vm8EuW97MjsG+IPuiGG+sUKICPb2Nb7XtQixmC6Rl0kZN6fy32 +MALw61PW85rXYVOp4Ubg99KK7xzsn80fnv32yaPhKUef773pfY6HIUMocz1XgIj2J/1lym6cc3cb +gV2ctDaHz6jcO2ETDE7kfh/ituCK292Lm/R7MW4zd9yoQvEQ7qrw+Gzv5NNB72+7GBzp/8qVN27S +5C6SJl+DTocBcTMhHBDM7WZObk4QdePVj44GYGoGhSVfJ7NuG+hXPMfdPsPXvMIqWV+SxN25k7eX +r7LCIQ1HdtdOTzbgErSBCs+GZ/bfHZ5c/2Jk7SNdQ2Vfbf10/Ob0aCSzsH/2BhxPdkTk6vD/zg/4 +w/7IxchVB8jOT/DLMvzwHQz9wKncKvfilci9xcM3R3hZFixTUjlZEURLMrnjEfzJ1A== + + + rcuR5uUIDz9IqqnC0OV53cauzjy5ep71EVEQJUuUZEOxTFMyDYUTBcMwRUM2DFWVRFk1YUSXFFPT +JFORZFVTZaRBsGRNhTMtXTRMVQHKBMW4MYQjmm7qsqFqomWKisXt7I3wkiYYEvzM6wIMGwZQx8ui +IGuGyfGGoMuaBT/IkiCrosyOkiyNe0ZH6YpucLwmqJYhwg+SJeiGCT+ogiGaogQjpqBpookjommY +FteAO+qCJGscrwiWrplwTUkRFFE1cERXDLyOJKiaJOOAYimaRmcB4yQdL6QoCj6SpAqqAk+Ct0dG +OSlpjBxczYskSIZu6Dh5ogCsVHFINxRT4SRDMDT81bA0i3syAg9oENXAVZNuJuFV2IgiSoYGI6Ig +6SqyWZJ1S1PgZvCEuj0EZIlwXQ0GZIlD3iF/4D70r4yTzE4BhqFgAL0iToisCrKs6ngfUddgzhyP +jzShkJi6pIuiBrKhSDi1miVZBsy4BNIlqhaOyIqha5Yswf+GZAuJKsFl4CE005QVjY6SrgkFh6yB +C15KjoQyYggiih4ejXMoAQ9hSFN1vI1uifCc8LtNu2EplqrhgKHIKgyYlqHCdRpwDvIFn0Kz8MpN +GFGJfDhLMgwDL2OKpsaeXlPgTqYgWZaMJylXlzGJq/CoiqnCNBuCpqsqEqMCwTpeRREVA4/QgFDN +opM6SGjafLxVZUNBw5vzIAEwJRYwEhTEAh7gEPAdfpBxplEJQN6BPpA0C74Rmb5YkowsAAGFyddJ +9FUTuAy6IMoi6YKsyZaCQiwzdtNpCmgOSKyqKXRzy5B1GmBaLgumpqrIJpBzFUSIHaMAK+FOlgHH +wgCorOP5URpNAR4FJhHUTgXWKSQdMkojPo4uSYoC3IabKTJIKpkU4Dkqh4iiywN5IvAMLy5ZpJY4 +LyqKOjAHpo1GgAYZWWGYGrMYsgYTC+fIqBwyKCw9DlxVRjXBISIOjjRVjdkUQwQBeoJEgsBoNKRI +wCy0PzqSBQMiGDwwbg6iLuXFBJMn491Aj1BeYGrB6Mig1zARBgkYCBXMuwxiY+IxJC83NI9k17rS +PBIg0sjL48g244zBrzJZVgnYBrwFhYJD0ewCraYqmnR5mbEF5lzVUBNAV0RLReaiCiAvrx0Fl0XR +hkkBjUGlQsItYBL9LSqMv7Kmg6VS2ISDgMkmCD9wGG4qofmFiaRHA65oQDxKBWirKJMlVW1RA7p0 +FS0dHGYaYBtoDHSc60Lcs7vQSdAPuJmqEo2SpaL84phGJAGPwc6SFsFlSNZ0UDXmviRbXsFdMNMM +Y6puki8B7ugauT0YMckRoqriiAXiobARXSGPiO6SdAFOM1EiYQT00GRsBlWjEfA3qPNwOwUMP7td +x6PfiZTCE1qkYfDwhors08nvSTSkaTJBBFFH64aSBWBBQvahxbfV3SIRBbMCaogKb4CvNywDARPi +JPQWIMom88o4OYqtroaCM4B8kOyrK7opM960pQtEV0GegiUAr8wmVTZxdh08bY105bxzdjrmEM4D +ZdTR1KF8q5KBlsMEBiuEnUhj0NvJpkXyjmatgazT2qwDdupIr2FrLPEO9ISGwKRb2rUH6GD53SgO +UMH0Hr2QoiC0gjFDJosCGE836ZkRMiE94EkkJhRgCkSRoUuwVsQINNOWrNOXcCeNIUcdXZqE3NaY +MIEfU8nMiaLaxpIWOSw4D8CPQVMpSTL5FQ3hHRh8EgG4gIlSLzLDb0qShk8giaADJFwIYJAWE2SJ +EKeDvjvRLqDHNIhtID7oVIHLKC74kDBmwnSrxC1FZaiBUfSMQg3gt0VGSCNJBC7rqFZwlGGaooUs +gYuLhC8tcq1Et45e+wqSIHMRjCJQAP5pPwPQHSjegfM7g4EWPSRdGv0LPZEM3FYMdhqTF0REzKsA +wiQ7AQpk6x8JC7u07dyA96bJ7n6Tb3eBnHnCWPStruuiZOsIw18wxuIE1BoRLo8jAIdBZmFEVUHE +aIRcKc0L6LVC58H0yGxeAPUR0EWcy4yphqEPPA1ySCVudT7DnWDfrqxwPG6TAj1TtvC6okWCAOZa +wQGEEIjT1K6T200EHGLSIUoof0rblAoaQVpeRixt0VkSyTGcpGg05SAQYMiZAEIYiFNhAAiSGCyA +GQMsKUgmxj/M6iiaQSGQZlMiX54mg3nknDxBISUYijqMcTUC/mN7CEQFhpgKEVSF+2joWyzt+oBi +wJTaITPBO4iLbTSjwn0sCwYsFjHrDPiSolp0joyxGERQBnpd0kZdBbsMsscws4wPAtdCrw1Rln2K +iXYZuG0inwj1IUJF9qsKsQL4ZeIRsoqhCJlyPMIUDBvA6OTUYUAj5jeIfbpiYnjHrC+Rg8+q6DSn +HUxq3JFxvvHYzDZ3kNZBewd3UAYlJigSRbnIQLTiYFUp7kEzi6YchJuTUJIV3eY6CTfKlEYRD9ht +xPyIijCWZmzXFTCqeB0I8chMSugTLYIbWje+34lpAJSNeSPSGJCyY9JmxQJohlKAyJYUDJE0ZllU +it4UMhrENU1uuyAQQDakoivCAYzecEAhe6GwqIXCUYXcHfCWzAvBC4vdyUJYgvkkU5aJkfijRBkd +2WKYUpNEemDwEW2MIaJmIhRXNPveqDJ4S1NkA6RUFLzqpi3jCmWKwNkpmPfp5MSzu5BqgO8ymhDT +VnqYDpNyB8RITTUsUj8ZgQPG2VJ32hz0OzjUwcUWKRRlbDDDoVnMsSN44eBfg8AMBfR4J0DFwCK6 +k0QGjvJtdCewVrIKMwfHGhqG/PD8IPYySY+o6BRhaKRJaIFxkpFoW28Z7GgQH5DryAcw6Qp3nTGG +nQ29yam7UR84U6EHRK8EVyX9AXODwNhsm3rQDPSY8LtsGuQ5GY/g0dGeUvSlUVoSswhoJBDIgQum +CQM2EJCkpCT5Op3O0Rg+wcyMaciE+0XCNJjnFhUG7Ay0MGjCdNWOki0Ns6lg9zRdIqjHYjUMnQyY +lCcUvjE/AxCdOVjQQCRAQkfN0AA51TbNjS58OMIEMBCuyGTgMG99PAIBnkmioLILQXgnkd1ksRR8 +TREF2k7iC+JRdG+IHUBJ4UqyhYYIXSOKMfwugk7h94pIaQCIXhUFhdhkwmbYYSZaD8yJPoFrSiKo +IRkztG6gNRKGhhCzgOBwsp02A60jpNhAKgjgwYgpgaDJDPHh7+T9Oqi8C2doIXtQo4APIFmY25RY +9C9hBI15cHDgBqgs8gWeCYwbJe5UxikyH/A7cgj9lISGHF2+TN/DY1NKUEV4ruL0gH2kDCCoDckS +QjHksSLiPcGxiQZLaeo68V4yVXo6zDlz7Qyi1ZYGeGqTsiqddNxVppiyHviYWJQ4xswmiRtaYFBl +SlqiRAABlLN8QrlPYpaE2XMVWUDgGq0gsd9AVaRksamRsUIniwaOsqYQo2N+VZaJiRjdcJ1PcRch +lKMCgOnljipBlzrCzVJDC4sPikSHYPmNChTwqPSsmF2QEGeKlJYAXCnpTI1ZKC3ZAPTqd5aIwpoH +orR2mIw3EcnIYkwL0TRgVQtmFI8AUybT7+RFwVlCAGyxTL4ky1dGqMmKT/A7S4AhKJEJ5UoMIhos +na0xFExTSKGNRhCSUuRkAjFmwqlEq4WmFWYYtBVvKcsMAqlkoOkMsvIyKRDCHcxqaSqSobIKREfd +6vOIo7LlKH05y2OWnRQWyQiS5zHIM4j0qMDyLsWegxFHleKYhlSVyhCmatiVDDQbOED5kGcj4KIk +ltoDD2VQak1v56ZEOyEB06FQWIin20IhKpirA8lC9KkwKaA0Lw5RPg+0iGqBMAByAijAUW5CQXCU +pDqKVg5aWyMOfjg45uBqa6RLZdJZvbxR32yNtIUIMQDhGDKiMssCXSq+XZVCD0aCBkOiSDwGFTed +taDPIx3FIkctyVlvYuYEfpEleHpwaTpjo2SIIO9wG5EVGeEAsAoyGBBTJdNB5uSaXVWYL7thPuwJ +ueao0J4AZCMHgKUy4vIxemNyt5ghNkE0QFYwX43OHocorocB2bAHqFwF6sMylgrVnhhS0ChKwNIA +JTYBDJFA8KhJItzLIZWNEYfsNrvL9w3OfR5xVvMc9b7OmiBNPAvrQWQVtHUy2W6WiGDYvJ1HxADJ +pGQHTjyWTlmyQrachTqyBx3FvM5yn6MkSNZSpggZC/iY9dKBA5QYRmOGZDrm6i4cEEy0QckarFhg +tq2rwDgetdmthuioNDa7ViNvViw/I+ixp0ChtDq5cpbrgvtKOnnwy8wYWTISLNNEGC9pLJakpHE7 +nQssBEsPkRilbrDqQSaxifCYlQ5VW2zANbF7oTxhc4KDIXeBNmXM+5uM3wrq4fEI4y3Jk0hJDXg+ +ZrJUO93hIBfNewdTmghbKTODmQERgZTZLmdiAhvx+ROcbg2hGk8VaA1TaoAKRZatJJXCYxgaoMAX +4wBMhCPfsEzKPG4HDXch3s5aMdaYdcRGMtWsCCSIFPQYZE2YvXmGTwqehymwJYsWsA4OYyEzDhGA +wdkEH6uwEbR9iJMJwmOthbAKGCawFmQ5sfxCsAV0h6pgGismyAR+6RyFChYYEhnMv2i2AQbjCEie +YlAZUTnCLAD3FLe3b4TGmmqHFntklRKvsp2tkTF92i7Yaqz8RwGg3XWAsFJFX6CT70Z5oBvBQ7E7 +IxpT2DmSXY+R2DmOSjpodWe1vbMc7yzZN7pMV/MuvKiz5GpXzTsLs53FW0eJt0WJB6YoRrtoCNxi +RSB0mCJlTW2doYyDXQUC2TRJ1ACkAr7gRcpuy0z6bOTUIaLIwE5JbnaV9042fx7p1mfR2YvRpauh +W++Do0Hi8wglZDCCxTFWNMeMCSI6KikrJvFFp+oCXpwsEaVtrEvrpOrMLnd0Jnwe6dq/4Oxx6Ggn +aLF5ZmV6sF6yYVw/SkEQo3Upv7fuotSGSSS7HZFcKwkkBmwkDwoVXpCBbTFSLWoClFlFyLYzxE+F +QBeaESIOO/OoemxXUR2dC1T97+xvcPZAdBTtG90L+zer/58xdSlSTocaElRWxrarvximy6Ql1mVV +CKGGnby0WNkE2zQR4+l2Jg4LvBIGI0/wuWWqPMKNTWaBVRvB4eHsK4XKOxLjoqbbKTyDOlrxAhS4 +YrJQsu08i7QdE0K1LfhWxcCKp4y3Ru2mMCYrdoebzDCUJGqslGxJWLDCS1DFGEdIQalrxvbBqsDC +I+rnoPq2arcl4lNRfvKyZYOe3eYMXtTurDM0ibWSSqxQ6KCZOkM6OePknoPHLZxAW+ZINjTbPtpV +a8oDEK6jlCvG+0wMUQdZnQM7S6h8LrHQnnyVSjUHSbDnWGHghUYk+1YmKwJZl+0rEgqXxXozSOG1 +tvdzzMqdhGYo2ZrdhXGZyAbZZuZasTPZwA4q8vDkNYGeZ9R8o2E+Fc2cZvsEXVRYlxZhuOsjooqo +kGWvWW8K2K22L8Goh4kza3jW7HYShPoqmxqUV2qaaAsjybx9IebVnBxtjXThu3NuOg== + + + J7BFZVwEzMwEqwprgMFmI9tQ2y3U1BtAIxrruMPUAHETgw0mHZ2dN59HuvTnOHt4HJ0wJNVmG9fZ +ttVsF43Rn9CVHPN5Jz0Yjh6XY7S8LDNHHTSKSNiDNQYYZGMxV0Q1K9BdVthBKMJ6M2Ty61T9sX0q +ABgGc7oLWRdRdEjrTZFudJF7BzPJN1jU/4uWiJAoBuC6wVCxxiCNo7WpNdKlAcrRItXZRtWimqzN +FZGhqctaNgWvmsbathjQw6o3dmE0qCROyQ7kOtl3R6f+55Eu7fyOhv/OpqPWiLMzydm81KXF6WDE +McEkE9clwCkhjgu1Rrp0VHXpuurszWp07eDqbGn5PNK188XRHdPZQsO40tEX5Owd6tZhZNrIBsZk +E6vvMCIjDqYRgwEUCxOXlwOEYmAyTbqSHbQZqJhUEtE0qspQwsmi9Ptlf4dBSVdqBMZsF+M5SzBj +6pJdoYsi3kmHq2JZlBCXKaFAwqLSOgeYP8IH1wYUJomsDwTvQdUKmhgcU2myDFYCpREMHWHE7h81 +bBckssmwgSK7ODYOUT4ZR6huhe2STL0NuyR4OXl0HosXfnb6yIZ0TLFTChyy0hrp2rPW2dfmaG9i +3qyjB8rZJtXRS8VMD5arOawYM4XHmArDanYI9dAgZ69ZUBlbeeEO6MGxh4kCK8xuq3be5QnpIbBT +o9SMYjLThhl7KtFQ8s6wgaN8GXdiNt2inARVBFgvASsEqZLEkp435eWuWg8pKsOWFctkTRwWBdPA +cBYwo8ggolWoCo1lE5QrFX9U2tNj2IUlxMgik1jK8eAAFbWYKlPOE4ZUargDt2KiO8ALk38yaAEc +XlanYIidRHKnsOfDG5GJwnUvsk6xuEK9Z+1aN+uXpq4gLIfbXpvidKqYk5PtmC5mDG/OqGPOO+WC +taWKYKCxu4w8Frapst/t9gmUP5RaXaCCEes/BEdPIywW6OyuY07uZgOeo0Ovo4uPPX+7oqcxV43e +QKSsk32jmzNt+zdWcWhfiJC0QT2EKrZaa2RbLXLaIA/MZxt2WwJgXVpyRByXNITwGBCRO8XyF6I8 +hVWTHOLArFynyDiE6qbgNboIZwdVDKqacLDW7gBELyFRByCrjnS2BDJrc71n0NFS2NH+xixNR4uc +o4muo9GuRY12mt2/YLc2WQKVWxG7i4bd+2ywdj1qoGqQd6enwVYqk9J+MrYTYU8CQZAnDN6I1ObB +WlFNu7sGcBMtv0MARcizXVUh4Mh0RGMtISgJBj7KZetop2jcTazXrefP0Q3X0VX2eaSz78zRl9bZ +kUVhF+Jv6nRiC+l0O4ECAywjo9viaDInzLgoUhoP7YmdZdYow2MwhUfETSVYvZ1YxKjOQi+p2wBW +t9dEgrKjTcIBhdKAGiuns5iCHCtcXCK3rlN3C8o4dkbJzgmmyKtDCDqlpEOOmBoQFXbWmzLOEpNp ++5SOZkrWitfRcOloyeyYwjtxcwCzKctk2MbsmJbwUOhkXCV/TKrmY6WeONZt8m5Or2P+O2WEBEuj +cNq0AyuSNMz0XEYKnU2FZBw7Gg8drYkd3Yts+pjxMNmicdQU8hvYKMzmRmQTTAUIyQbzTMrRDVE7 +PJYKMTTEmAWNFKX/AJgi0pJINJFT1FKD3coEo6johwJpXvaPEMcxLQ3ixgAjDoDh5bDdjQBR55yQ +R1JsA4/5TJEBEsxnqNRSx1Y7U6xLvwNg00zn3SkL1/GEDho66WQpOMqI04JSlakMFRhkWWBQFVwC +AXLsn7HsAJxVHHCFrqQ5mh8pp97RH+nooOzaZGnbnnZ0zxKGqFtEcieb7iLgwSY1AvcA/MmvYUkQ +wYaM/ZYsrkbxZb9LtIge2xhIuSy7h4bqHuBU4IFxjDVCoJmWLXYUYeYubZyOTk9HL2hnv2jrKvuP +GmGxNghW/JPt3jW8LIOK8A0rnYjkXUSmNQZ15+jMLmCXoYk9dSJLPqjMb1N01R4QKSLlHLy6Cyvo +aHIFwdMwg962VriWhbUyM8yL024Aqch3wG+MGwpLYlssg4iEETMsBsAchLZGujGjk103OYqlXpYk +oP5t3HzBLpxjaUxTGI7EJ8ZVkxatklQF1niFpVTU544O3c8jzg7eGw2+P9Mbe6twx9kca9mmDUGr +SRaCYC9iXNQek9UyGWcpmNdRNlTq4KZ+ZM3GrAhmsdah2nVA/bK7SrVrd+ByKBmp2BlM9CKy0a3N +uKMPubNNubORuQVUyG3WG7QgH2YNO8kINEumo4G3NdKtxbezBfh6k3DD0UbcycvPd6Bw2NJDPGcp +7+PLZg+tzTmWfdVp25Ruk9M5fZ3T2ykA2B/I2hUlypTQiiJq/ZNwUZskOVqZWyOdzc6dvdA3e6Vb +2MBnkvYa1NPO2gBFajdSFLb9A6IOWmdBmkRVSuo+AsY6GoypI/BmC3Jni3JHEzOJBwXNpu0XEe/j +vyh6dhRGxkBH6yGjlzGZemtoDEQEfayLg9Actg8gE1W766DROXF3saS3swsYhcfE7hAMh0UE8thd +hKlcrGciFmi3Dap2Oq8xcm3EYtKjUt2pTWgn4dhtd40vHTzrZGqLGvpQtsx2G7Fst92LBI9o1S5O +kqEzp43WGvM7up0f6ehT/jziaGS+2ebc0QbdcDDpTrrw0exRa4VmJyWOseuI9TrAkN3Yw7r1sAKD +jrRLU1dn35ejMczRPNYC82D3QkoUPnJauwGKCjOSQg3drBkF16ZRVUGzxYUuw6xQRzMT+sqOhqfO +jqguTVMya3yhAJasF9BMHc9YUqLajINR5GRxW6vcxYjEzWKHDaAyEYwAGHVLI7yoGwikMRGmwWNS +vhmCJRGUBUs4gAJwehXwO7olQ5BjUMONdHPicKTTXEsdk/2zOxgpJqW9cd2vaXHt5n2RwmrTdDaD +t0acHeNdmso7WnzxrI42YEejsKOZuIVtpyytrtjpZtWuOuGA3c3Y0YeJJzl6NR3dnB0tkNQTd7NN +0tFI6ZBplIlOsXfoRYdI4Dk6JcyovxfRKQyQDPK2mXB0+eE5NxsBHZ2C3doJuzUdOhsTO1rDWiNd +GsicTWadjWjUv2bX1OwhGrAZyLZCuNlkRKd09iE5e5U6+2dYlMMkSbPryxSDUi1Zo15srUvLCwXN +nY0xzuYZR4sNa2uiBBnuzmGxdhhJtCvVLKXi6I+gs5xNFM5Gi45KOeuP6Kind6u536wHUkbFUTXs +Wlu8WYG089TIO4SKVHgybLHDohrhEmcxzi7iOUt2zrKes/jnqBA6aog360bsZsRn2U7W0jNSqYmK +xI4iCTuls5DSWWm5WYyhc4AQg1qmUXTpGIq1lfYy9s7aAM1XR/2gS4XhZqqZTmL2UbMVC3wKLTXR +bBzcmSWlUzoSqZ2Z1o50Hgl8R8avS07wZo6KtMuiTLlhr0+l/BRaAYMWjWnO5IzdIHkjgdOZ4enI +AWE6z7kW9+ZiXcdC1tZIZ57kaKRrLqUj3+JIyqBtlJnhxCG0Spcx+7WBm7kBDNpvpg860wsdITaa +bcf61I71qzdDT/RCN4PTzuC1M4JCiHQzxuoIwTqQfougP4o7CyM1rt1brNpFyk6U3Rpx4vBOnH4T +pBJAuLHir3NFYLc1g52rCjtXHd5YlkjLZgg8gECw9WLXBhSjy86LdIpjd8bO7Rtv4iPs4M1tt3cm +lbj6R/gZYRwEM3BxHaI44IBOIY8EIE0DQcElKhatsLSA4wA3NRxjvSoKeBQVG+HAu1I4dS3kxuCI +YFgnIpcQh1+hOxY7sRyVZPsRXItjUfcyiqBMi2ww302dABbVfXExF2mixhIKuMSFpWk1XO1KDeCK +3XarUwEKd4dsL6sy7Lonbpanm2hOzfbGrZe9NHAMRbNNynhi+Qk5qpEyNalPXabKgiUB0KVNYEEr +0CAbdiajSUl16oRqOxwaMlTUHZ0t/8MhEG0To2Ms/WJfTXPkshlVtZdiNq/ssmLHzDRk2j4BO5YV +NqRTFN9mJTuKrKZI8mzaZ9pwBBcyoPrQY+isP1cW2HpbGmM/4h54bDEI0sSKWO1d8Ih0hhupq0uU +GH/Yijoy2jrxGhueWJqfwI9E03bFXDxSRSOBsyJRny2iHdp9BqcOfLfCrsem4LIvQbXnEGXAxrj4 +uGiEUUxYRpvAmUEM1+2lnZg8JuBLC71YN5dILpgYgjOkKxTTyPYy3k5BxfgV9Unkdt6O6Fwmy+08 +tXf8Be5iwAFYHs5G/QHnD8JjoHVTDFJsCIjAfgIS0ABBmzQ/EogXeB7ThiLm9RQVbQqp30hUKpSc +uHkMLW5jxWKJlb2OLwfQ06F0gKiqiIh1Wz6vJqE9QmjWoGzB5UEgunRM+yqXA/Z9yEOzEXR+Cm2T +Z18EMSKD+Ffz3R5Cx8Ke53Ko/cDt63RQxJYiQMQMVhd4COzQaamug+ngG8ClyWCWTIVcJzL1ekKA +FusaVxxFRtKMX0vviLq9No0tyWwztT2g2GYXd6jCsFlt9yFcUqpeNdjiRpsK5UjsgxTbDrSvcjlw +xdT2CE8JDoaT2VV4yV7efY2r7SH07+yBLofaT3x5oQ6aWiy+/3jn4sva2XATUoaFaH8PsvtoQyh6 +aV4dhhUlZjch/mDA8GpIt2HytRMvj7q8frPLPVG3FcpqY8KtvYgO0Tb61LbxaV4eg7xUaQNk1S5V +Xo1oNkC4Oqt9jHq53qvzXiw3BgeZJC4SdUIdo72UWQyu0HZICvks+zCZ1UbQgIrUVnxtQLt2Qvvr +9mWbzjvh7TF0ltjCLmrSsXS2bVnbA2C4duki20diqteUdHvdIMsEXB+jYEK6fvLVcZd3aXa9Nz2T +3DYN1BxPu2jgailqJCRsj6ivee04TD+yVbB4T3tfwmtDrDhy/dT2Ye07NLvctcnWvWh29xn4a1Vi +y14sZsokO5HTvHaYbHcFkBvVZdLlG2OSYenWjXMvj7Nv0XTe1X4UhbbPkG0y6FHYAhhspxQJEV0e +hZuX2rBFpXUIyvUhxWbntRPbR8lXXOq8o/0YbH/rdraJOtQUE9ME8pW0tI+S2MyyISwUSteHVDuc +uHEiO6p9+abzjvQYWC1kiWm2VJH6RyyioN153rw6SrG74Yl0jXY7uDFEqa9r57UPal+96bwhPYVE +W5vSEmGq5ZDusLxfO0fYvDqqnQwg2Vc7x0TywvRkl2deHta+QdN5T2ZGaI9aiQpjtFstlv5FWWLb +q0is17h5dRxPBVBGh9ReOXdjzLBYZHF5bvuwy1s0u9y2SVs3sdyNYusglrXb4RVTneblMSiADNkp +Nja+PsLKFFdntY9RLrW7817s/jJ7UQBmpikipsI6A6uSvVK0eXWYbK+XwetLsr05xtWQ1rZm7RMv +j7q8frPLPRlytGzIuD2S3C3Wz85vvKwluVuG/y+PuXqRBnsFRpeXYiwdHV0cH57sne+/5dbP9k7e +7Xd7P8b14G/959+XIYk3X5iB7S/YDYAeUrTfKdEeA/hMC2XxX4xR2Dhcyv6B9evRIg== + + + PHuE7zyVd16f9UixwfbpVz+0vxKvfqTY3mQrVuwhxwW63WbmDfAjs32CLy95y70723t7uH9yzqly +lhhjIY8Yl9p/z7wjhbz+keg9DxIYQtkkn2Lf4toH+8IAdrIHANQqYW6b2zl2XAtMr9HftVQMgsDD +zrS6PBjuNAGYF4JAzKP2+XgzxxjgCDIARgAmmBGwMN/Y61VMTO3o7XvPOGnFjJkGKgHmVgcA1vN1 +DdQzQwPpkeRu1+2fhxZmIE0EYRL4wRmGhmdmfoeSL4mu5NuSj/klLNFR9u3rhR5dkA7IUZZ0pXch +t3ApsA7uTVSN31jIKQ6+8gS/P5k3mcjzvco83xZ6/pdZr1sgTBDpA+t19jBdxZ5vT2Svl5NkBUtC +Jgk+ZcpkGQC5jLFE349EIopZMw2gC1xE7+cauKJLhX8MyRZS+6024C8srQ/+gEk3ZA0QpWmJandX +QWtcVVGSLdSLPi6N0bXaPq2rIvU9AZdm4lKHrkOs3IWdSrF1SqL/sA33JuBiS7V1XbW3t8C0Npbi +2q8cuf7tjV94jdUzMQ908wtb1llMTVtGXX2JJ1HAe/nb1c3YgVR3x4uKnQNsNcTPn8D/wp34X3xE +/mcp43+JH53ca4zMs76US4ugsnz98aVFaj/pja87f/3FYx2PfuNr28DJYpcr0ZEabQ9EFbnOgYZt +0Gzm3vzyl27zy0/4S8Rdv2EHJQ4mNpx8bbKCEqXABf26WN/IiF9VmrhN6veSNAUXk0IYK9NiU1Uz +VBEXDehgTmizRFOWRck0VFnTJcXuy3Mkaa//TtGofL36JJncTv2muskY13Cr99m7fYLZaIdvnfOQ +3O1G+NXol0lP7n4d8XBev+Qnd7+OAcndE/Tv9ZPTk1+KrdtvNIUoWtnYOz/fPzuZ+/Hj6dn5Y/tt +mMldkSvOnJ4e3TzmBF/3vXBx+Ja9e7T/IH3j7LS1/+kTt7nfOocQ/ejnY3Sx7xidXvQAGmFZGm7w +KdOWjaqkYsgG6FNT7PdAmqKoKrgoBxfZOI5hy2D1m1cBeyyqoqyDxVGt7oeArb+6SGPEeQzfeVDz +Zw7qcrMbT8x3e+SbhDsOaYzQMSIM4QZcbGFuxzFNOgYvAvEoLvt1HEGPq3Vc4+bjdj2kgzeOY5yc +6XaI40bXn7XLo94k18mRL8tL82dDxD4jRDTpRJ+s0P6XKu4WIpmWSU2nrEBz8yTctAC0+7p4IOhS +sOmEvjclrRuWlnAxkAmUa7hugJaefe3NVAuXMeAkmOLPhpgyLjNSdQj6sEvzV6OsnXdRwDNqpmFJ +qmxo1ldfHUJS9LK6aMEz07Wx5wzCQFXBZaVY5PwrLq1jF4RuAJd+Brj/alNiYf+BYimSpOJmhFfg +27V9ru27Jdsnu8avbfw6WPYr2r7f7F7mLZioaw/akWPTrkE512S5Jus3MFntlNPM++7Izcpey0ld +GS+QTTRfuBTexNcXGCa23rGonvaTkrCP2VLh+XDZE+gRagPoCwTo8ChtxeqeT3ZF3RX124pM9L4z ++Z3+me/N9MOhtFOHKLLWLYfp7+qgeYej+drbSfh2TPDQGu4lbKrdXTRuHmko+Ew6zAY18/5K1P1s +hl7VdDxKg8ubf8XtTFwP1b6f9TO3+9WY6cAgP5vWFwwwkKpJvaEWbamn4SoGQ9ZMSaUdn5k5VaQb +/fCY5+xoK8VuuGv9kLLuKBDYqnKZ/MYlRIpl1wquf3nzu2Zbgf5/9t6EQY7iSBv+/oD+Q3vX2NKC +RpVXZRX4QAfCgGS0CDBe7OVtzbSkNjPT4+4ZsPzrv3ieyMzKqu45hAHBWj5gJiYrz8i4MyJbai/5 +883p3y8Y90Gysk+b4EVHmdqO/qu/J+ra9m3tH6gasBBmN/rc84VLDijc+nM1QaUe1d93LX7852nn +9dS2Zzbe1+qPd6dHMloz+63cAaM/c0rDh/WEJn8arbT+265DHP1x0mk38nJMZ3Pe2d696OArh0Am +vdvugM+mBs2pkRp2T5hf78FOy8HSwmmtzieQQA9q0M0Blj/cARogxVQ8MzH8JM3FnyyfPFkdX2Yj +hlvlFb7Fvr3bRI1EobNvZ35ipCYdZNUlOFCjlm/slPEKCC+u8SowHWjHiD88StOsucgx4Jn8AL7g +2OoDe7oBLOJ6GbOHqo4ieFg84kGmebydD8ye4ZDaNBWsV9kDT/hcKrCAcFMAPB9BNZqiZp/12GyH +2EuFOLwsaJnkj89zLVNvIxEGUl/hQYNHIu3IexQbelIsguSRVAqBiMh2goICSOMlkhK9PZYPnFhe +UlMqNAEZGQ3jG/noVZOZcdc6r29y9dkrQAiaxbshlCRjjg/fWU3yjTQpkOrTw0vmag2MjWHSYQQy +xK5htUWNgsS22VYrBqY0+W64cyljAeqnOoRoamglAcwT1jBxqo85ubTRtx7pRbPDy8ROc6Inghrx +UCDlSWj1EaoF60+1NZC7hz4gZ23KkoZH8LI0fQjFnHbw/9Ez55zNSfijvhUPyBuhyOa4jxPsg89s +552//tGN2a3Hp+vl8bPZ9cfP5yeLO4eL4wO52s+HW3/99oMHO5s9nJ/uP/90dWfxdLXObe+c2+EH +91ITvGTGgVct79y5vb9/dvTJ6nSO6VV0xOyJiM0iH+k52hFfMrFmq4BEzOhYD68xWoWAST97ZHdJ +OSZSBgQkdgpWE4brTUIRCuaYQBKXPiK8SPZaawKnR79AiS6liEctOFbzbdGLIBiDp5EeswOTxJNT +ltRAtsGOwdRaXMQis7lmFAJJmlk+THNMOtMyzYJl/RkWakW5FaaOMYFFmxm3j4RDqFeCmlmeT7KR +pB+bwlxETJDkGhGVcUmiZuTc65FvGAAmfdOX0jL1CJAWvkAsiHfMfsP6r8jfx6dtSJODGsZ6kUQV +Zko/reWAXSMdQHIto4EkMRX/iiFdI2kamQcoNOkasVshanwFzZSiTAiLt822TbfIOc1WF1BwTXru +WWSE10LuDMZCYkeGMOO9NN//QDb29NFavGgwWjRAOLeWtjF90PQl3qZbFEPKDyCXn6AOtQ00+wDJ +FZBKTpYvvsaIh0uEPFOOlFTf7As2dgiLhqLpNGkOXlVqSWFkJfJJ9XNWC9YI1uAAWTlJKyMwKQqQ +wuNFvkHdOZBbpKNPmXZFQwiKjEKNrGYbxwtwgy3WJ1IN9wybaCKeK2iKLhbOEyKJhCr61Jg4DuKJ +l8EduEmP7GbEYj5/Nkh44FkFOQYmezTBskI1U6fhWTBwBScg+gczdzSs5UIm1uIiBFQLAJqhgB43 +lhmInRYs1ayGooQQoqkt8gEBwfVU8PTKM2On8Ckls8zAwBSFvTGKDQ5MjamcjKKi0G86zHtNJ++4 +MSAPnWIEbq+h2aZLeQ6R4j7wPmvQ+j5Ta2tmCxaNYPWiDiWHNA+vcCzDa6Bpm6Ge9k4JumG3zLms +tVRoV0ioyHfMuISaDsLwEGPKcaGYh75Cp9kXVWJ1hvlVZ1toB1xE6UIbFfFESwtaYNRE1rpkXl/D +7GytUdQ3OWWv0RLm1nK9SFrb+BTUgOcUltXCNPkOwx1wE5vQDusRXETG4pRN1qasZwEvZRuinhLG +JuijP6s5XnBQoMVtSsSMYLTQk8y1yMZqUYkHFrF+Dw/xgI2NsnFB0wZvvFiawbFSaINE2Ex2Qgww +SnxsInvcyZbhbaotKCHsNUsJ34s5LcCQSjFYPPLp+RyLAkU0UYdRguL7qHUpXaqeALtgy9Sd1Ntv +cs8c7wmFExyA6TzvPh/1KzaaNjAtdJPoolYpabR4j1ZcMKbVWlVdehqJbUspk12Lv2HfbF8JEyCC +IuNq9mYmSdqn/qeFgGA9wKtDWZZtbaJLxmnRHzmIhI08Rb7ENIns4mowLWCTEqWgVAbz903wDsgI +B4HBGy4HS0R0WkW7d5G3h6U5WM+jlH/qNduoFpFBYQxmmdVsi7rpfL5uWdDVp6uHuOIeL9dI1QML +mxIZrUlPopk6gQXF+N6r0ZS1EZmC8PBPE8BqQdEWORqQB5g8WXihLxVCUQsDj0mN1rcjUxf6ydrp +zEDXIcFQRxTB630kDhEeT6HUB6YuMMiaEZkekNmsrabtASJqPVakMujlXLBh+LdyW8uAZ8jrUTOm +C/Z6oJU3ziQRMSWWtum5LZK4OmbPS6XCkBlEBG4WYuqUGLSuHfJIKy6Kloh3RPrMi8jIgNBU9o+V +vTp9Em3wqiyhovSoudNT0RBe5lTjqw1aRsRBywI5FJHIJ+aOJ8oUwylGwdbOF4E3mWjPaxafGNuU +5R7v3/g8W7eIFeJoT8Dtiir49cxZNcE6oCITELLUghBB5xn4hjR+GNfi4AzV48hXiH4vBSL2nW5v +SiyjlcVVhxIS1JMha4pqi/B2GRCCFzLHpBRWjs/D9Mkoa1qxSHngey617kalMznhEdMWtoaikmHG +LWAXyDf4FFRFGDesLNOmpKT8IiKpL/adaTxaS6wVrNGUN61mKI2KtqqaaXlcTeeObEdI7AwCzlwD +LHtjSeRbTXR5M8lytksZkpA7T7MF55JfrWG+S1SN4AeBz26Zji+S+qHgjicv9i6fT9fxwjE5qqIg +cyjnoqUm5fZjyiQTVJoXlNKaVExbosm9o1eJXLkIWXEfuyRWkjnjJlBItyi4Y9J3InxEYqws3Kn4 +y1exhklFNPtzUAIVswJwE+Ylvr1g91bzzllrFAmblO6yxjagICS+jmpmn2v6GaYFSjHYzCOK1Ay+ +T6zY8U6LnKy10KJR8S0gUYsqgiw8hEFikxwskHZck9SakIRCIiIyytPMAZEGzBA6SyraRL1DEyMw ++TWRykDi7VNKCrmlBglRBP24UhQJAFEmJ2mtzst0hi8zmIEHWpZRzFNERrSMlvvNMh+LgydJwaf0 +ZRr7CJmm6VOx0IDHvH3m52QVWIxlyivdG9WRIMD2io5MPYXMnH3C33YvpVvVHGa9ZpnHnWeBI7J+ +lshAWreEi0FtRTYlScMsITgjzVfXJoIouMyYzqbpXBpIk673mpqABM70qcAUeKuyZCb4t04LTKX7 +EkIKx++YbkoW3KSai6l2odD9VmXWRi0GLMGpScBRmc9rNr5WGXHXaTGBMdoRFy3UO5WPA4L5j64x +hTHfPyAnuGVRgqgSHl57OquZwdOZQAFWWuW1coFB9ieV3lvWdtDcJLgPTZMLdDIPm2O2M1xxi3Ke +EG9Cx5QvTP1imHWIWX2YJ5uIFW1LsQm+VqS8RmZkyzQmZOxCVqKy4TZJrzIWlfeg1c071yvLp6CM +CYAo8BL4lJ9CX4FTZNUCRJ76gWNpHyXympoHGoWKRdgyyIQWufOjaqUd0vZgAqySSVtTyyy3sesy +0YmyMuSEJdfBQbGGbpdKnVOe750tyaMVF3O1Lt+pGQmMxGnqr6BveFOeW9a+a/NNKWUzZTGeCCfI +pZy4tZ1KnByeNNOm75zqREAPVlBgFTxWA2IWXfp3QVtMUpes1cLHJvQJP/EIAumAHQ== + + + Y6O5i6qHjfGOyAjSElSlYiZ0QcZeZRxMShPVu4x7SN+odpBkqYG9UrERWfHaZMQQtkGrBnkFUgHh +cqnAz6QCQTERRs1kyWM6faZq0/xlOCjHXGhaM1X5f9SEv0grChYsbF6zsjMVMTMO98QHETLVVNvz +dSeye8eBGXeaWBpKhlZWSXyO8k0AJcEWss5TnyrUgkA5q7lOKbvbdHAqSyG7C65AZ5PwnO2vqQpV +yAbYnqmtFXsdFKeYC/PirkKRjbn8ntPKvjObKpgqImpuFdT4jDYpuzHlNjLE+ZY2bK0j6mMWBliU +iGJDy4NlsSvVU0wbkv2GairMmrY8HSBBl/0jDIJnscPKjdWU+6msKg0WnhqfdU2v7BkvZZFcWsbS +uwYf7WwL5YCHyTKaHJaQRI+uqWG+1SxNUbV0GDU0F2hKK6OmebUI0qmqKzZN22fmlG3zvZqd9S7T +zKzcP6dVVOu8EgFmJ1fzfDY0a14mketip1vfaTVOGujTaTAJDS30umBW7qSJ3qmNmwVQqEhzXjTZ +K3UPWZqFu5w2+o7l9gzziFLjgZpHezs3iFb6Lg5FbocttFoZhLes80zzFXiPaEqJMNBarYzQqhDU +lzSEpJodpUmmiVMDvaOfgyyNxm1KGqhVgi+Y8bgntYaRG9Z5r6ZZPlqjcZ4VfbO5fl8rXtiGslAk +x6Vp3lH4SEUatXINB3JZgw6yjJka6rNZPihls5BU1SoPc7Oml9frKXI2VqxpwpJNHmp/qoK5hXnn +G+cvsbvffnq6WCeb+tXs+Jfb5qGmiqLbXck2n72cJj2onX277Qf9XrI+fLpeHs0eztdfb2Z/uf7t +8vT5rL/5+HC5v/jLjW23YXqKddWcD00z61k7RUs5Vb8+0F/5jwfXJj8OjY5TOrQo7MaKZif/9sI3 +6ZzsjSi3wnPkHtLP2Ip6JzQGRWL6wDyGIjjLvRZygZy5Jk/6+pefyPo3p2tu+V9vcJO/+Oe1mxQ9 +mJvrphas75BRU70WDX5UFW34kRn/kB9F6BcmCA+j65lKTKQ3YdQQJGxIz81EkmllXqIYibrMso1I +Sd7DPYmXePHc6e2ZNEEtqsoJ5vHHs2KD6scyQahRSK7VybXWZH6iaDtcMNSq73TKIp/LVEQqE8mm +1byPDvWNgqyjt5r+bPcEbZogX1vpBPP441mxQfXjMEGm1xZBPyJHtabWd6LzybCxb5lCDHuHJJPC +W8GMtPSIsHtRRAwl7HOn59L0qGro9PLo4zmxQfVjmR6S7gj/wEsKpIJjIK7BZQY7dpq/LKA4IGbj +4V0g7cZLY5kkCnwzXue8Cfo0QWfKBPP441k5M/5xmKDMJgi+C5L5hinv5cC9l8mIbGORY3YXRGZs +kSkqNI23+k5y9wRDmqAZrogbrkg1K9OPfywTFCHMIKIPLv/I9G6i0CNNKBK8toqTcuCmQ3gBMpgx +mgCcDPpOROTZ+Rd4r81XuEzPDBekmlMc/VQm50QTsghsEH3Gs4CL9b5hsEsT21YhAWq4yFZGy5Y2 +588m6myGyzDchTKBUP9QJiIkTWhcgOG7gcgIA1ljRGJHpk5RTxg+EWRCInuICK5Vf8+fSKcTMWVb +CtaX4U0c/VRmIjsiew+DkuyMmqpF9BYxUJqwsgIhEfaBXmRz1ui7YCa9zsQW/DFlT4YZ2H70U56L +phSUre87kdPklEIguhiPlDJMjedCCYxHnu46Ts5oDtxRUAprDTrEeGpWLdoZDHEFPwpFPUwNqh/7 +lA2L0TI/PEP6H9xq4frfcaKbKo/Aj8VBDacLYwyrZXeBOVM5cetSfUAAVd8FiNY/gLy+IEctGpc+ +1UIECqStHcA2f2kTgLW/AKGltYDSh4FlAsbtEB6jfbUJQpUqzyJ/SWMAZ2vTmNoo9F07+t2nkqwF +4kP6wEOd6sKey4ujqNvBS9WWKXr6JwFM9hGAWgWZbvgyg/phWwaguhU4ba9jqg4JiElbwMiEPFGq +wIiQ1ahzblXUdppwVbeU9UUTKJ9FiHbSjnnWOYQG1AADmHIfqzK+fBoZfACgp4gPEDU/gNomZlCn ++2hzIVUAUTmHe+nzcdASRFDfewV1IeETrd/pUxZHBIyWUULyltO8ICC/B1tBgfBD5E4O02Y8SfZP +VRLVpKPRNVElSV8GpDjV1Sva+eT+xLYF1oIdQJ5VSfOnBdiGPARyOBCUIpk8kwwTkqK/0tysfmlb +m0bQIg4AaZa57OwtoPQp8yPW7ZAn2+oQeQnYyATR5Oy6463RuWlNB4JoM+A8XD7SQKz0e7lgI4EM +0MMimnwTtXwBQBqrR3RrE0iNEgqk7wTArs+XsWt0XVowgCAooQVUMN/baTvWI0ZvrBquNyttnMvJ +F1w+aZ8j2ACigxogtwVpYtmkAkylmdlZ3t5g+zymTydju4EMmTZtJkmqXlSvn5pC07TiRKdWnbJJ +fdpfptnULW9Tb0npxmkx8zZA2aGIk2ZID1/o2IS/+lPHzDwJL+laLaCMhYaoVLcL6WRYbUiRnEVJ +RkuFAywhiVYmNbSoRD2G5KqsQbTfpk8TMNCwnTpzSgc1maIO6vPl7ct0IZormVd3nE0nR1Dv/Jg6 +tL3zw51xftQMFZ2sDtoWuk2/tDKgpmB+59rUjrSUJxNzb85n+jZiojn5PkrftFEwW5Qib6lZ9sih +LLJRj+eWKpg1PrYNnhPgbpnZznJXM8ZGjgoXFrmIFchGMgbr38YiY1Q/5kJcr0QueumJvkK5yCf+ +GK2e7VGNDXg+goDdwwRkiCXflJSbymI5Md92ZYEQAACy/UBXSXajyxWaSWrhOwJIQ2EoesUKVAiV +6wdgmoqnP230sQZMcAiX6K8yYU6lK1NB2YI05Uz46DbkumI/gYS+UMwCs5lns2QyQU2ig8iYSghL +k+UVwB9AYMwCEMUxQDS+kQS/rUCZ0iJspgDz2skH5MDoRc7AdhvEqKMM1AlrrSCUJM/yoDpxACq8 +12l1cwAZcq4gclCAMmMcINVBF2Cj3iLN6KaDavQyQS5BgiusQZ1RALrO5FNIfXEbdE3BDaCMXP0A +yqhKg/jo0w5iybh/xkrrPEw3iGZRYW3IJNTGBFJXcQ2q1z4A25Clk7RDdIfokDadVGPLdqsveHQs +6a7Vh8do3gLKaydBnpy8SjHRqbP+MPGGNAaZSoaZhDchhsxAGZMBkGadt3RC6mZSQs+shocJoFHd +w6cISYKaxCyNT8slKH3KsmbjdtZM+rK6BFt8Zyo69pOp0c2sC2jTAmDKHBaahd+Q6E+9I/pedLR3 +Xi/uFpCe1uo0IJe1IZ2ZL4J4ulxNJXqEggLKfv1w44zWNxyBbCU7Z2BGO/TWtCPkxKDGTHA4SysV +rnsNaa5vhNdgvvFl8uqHGl8nP2Dt8HG5JmUEETnaya326aEHL38WtBijzWVlpSND6tUXWJs2XB9/ +VDQJ6SHbKe3yGv9fX6Ysio2OLzGu+jL5Pa0LMzl7Fg0f02DUH2ziFpBRjzVVRzSzjyPSnzxyYxYh +QAbHDZykbPnAbmpQ4Uo1MDEvdJbYUuZwGLTPTLmSUFH7tuaYXp+TVGwVG5VWMPDkcnNqnuw1im/8 +sWr+FdvXnPIT8cAjDGgkRXhVlmtZwzMx/Nbyx9LLgyKQCmtuW9c28G7l2qrOdfAB9hHSlFc/1nad +7EHgbGOR45LExgjoUIS36sc2vkKB86Un+koNcXzR3CLWzMYsb6p8mIEK0kipphBYx+eACqqYZ9s1 ++unAZFvGDADUbkEqSbAAm67LSmvujM7i8aDUT4vVKE2OZXEVxAB0gGyXRQ4WMM2gjOtt3S7fHVu3 +VBCe3dRDaGH68Uz8nhbSrWbsk9pYrasCmer+D8A2f5k7y3vpWTZ7vOU+RaFXR+P12UJ9gLjC0Q2g +moVn2OEYJug3EFjKNS0e3ntTgBY8dAokzcpApVkUXwHKZI2sFIDYDpSTwjCAfebDSibb9ApjAqr4 +6wBMZozMNwXUmsyelPgDZItBQZ8nAkbJSClsmpxalJW9YOYZtD/ZEgLT6rWCyxSICpnjHlk/XUGZ +1uPldJregBOWFYm4jEzEWZFdF5s5zACqNmUAls1j6NR4i9X2MTmKlMZ1ODAVm0aHyrp/BVQYR7uN +JsYqKvKAs0jcZZQoDbOWOwWiJH09dDY9lemhrE7jJ4twWoG+XixAsRttSQ2qdY4CLJRI35nwILI9 +pidPbPlkq1I6uvHBVivIx+9S6NgIobKmPsIdGCg7vwWkZW7UoRYdHg2rOjnxadCJ8JRNV+FGKlyF +TjWo2pMBWPYudzZscBmzPogyt3xcvp+QCKfx9WNsqtZeYxOfLpM8wTA2BQ50bMLYiijSCyNFHYjO +5CKTfYvUGj0ej1nX6KtsD899g4QzrbdqLeuNgzPR93ibuV1kEo7Z6Sv2aWnKIsqEUCSEJAvgR++K +WFD9GMIrFGVeeqKv1HbW4jXyTd9XPkXUrY8KSy5Fnyt09cWl6Fk/XEHFpYiyWNDlAMy+HY25BSRm +pw0fvBVQ5sh8VzVu1+S5ZQ1Kjfl5GpmCokyRTtdmQZu6iu+LW7EGFc9iBfShfGkU4vI6+UIfkMG9 +mF1FACb3Iose62wHPXkA9cMWDcDkXsQQUVdgiuRBMz8gxb2YdREBZvcidq3RXWuKkqF+rQwq59L3 +k3Zt2tzsXfTJeIlFFe8iCvZaPazsXQSo18ll7yI4e5rv4F1EIGnUIbJ3MWudACXvot/TGnE4Az+4 +ATotEtcX9yJKhqQtz37D7PTLIH4aNOh93E6riHII9f7BW5EQenAwwuns+rQBioPwSxvtLTsYC6ir +HIwVMDsY2RshySmEMbmVXeVfTM+QAMz+xeTcJSj5DYOaRgoo2wn6cTOt26yg4iHt6MsDyFaCo9OJ +ZPciZFCIUpyGy2dKWRWg4l7MIpzvinvRJyUEIFucQnymBFAYpD/K/oAl76JPzxCwRU2+CoGqQgYV +xG+7STtVwtFbX/TyNm1b8S76fMxd8S5CCfe6Ic5tQYp3sQJm76Lf82V3Q/bfqSrE3e0qgtSndk0W +/fDwkyAzUDcK3gAV76JPb64F2BSxnM9ICCqOapYtJsi21ZVxOuHBu8gH8Td9LF7DkHSsDMpXhj7/ +UTsfc2/J6hWSD3201iAXOqa9S+7FkELwBZTdixVocC8WYJ/diyE5Un1f3IshyY68un2Zr1qnQPGT +iB+SzRSg5DesqEPtX2QdwLqdZwVnBRXCzdBvZUbNYGyiY4AML+Zb43NvLquRY4ZaF/cWBq+ynE14 +WrurlAqDalXuKqM73lfuKn1ByKVncRQBkgqqpNb0PrCv3FUNzXCcv+4an5BWIH6KTAB5d4tpzKaI +ktHHmS9m+dmywnmaST5mZOMI+bBM+jKzniw/V5BiGKtgyXyIrmKm9yaPGF3iE92wAJPIeDZZWshU +Ckl2TZt01gxKX6ranYF56VTPiffZpprTJUyAGhuQgQoKLlPkkEZWqWpEy2HqT4Qq2w== + + + hlFf0ynBTAbkGlJOugJmfxVAfaIPMR8WX3YTVEzbNp0cgMkEbpPo1xUzuc3cvhs5rJpCgAaPFV+/ +19/iFU7TjwZw+lpdJzJoStbkdsVlpc8Muazssiqg2mU1ALOljIVZASjWNNZj1x0frG4mk9rBZWUG +CpdVQm5XAaV94wvR8eG7FO1D0WZQO8k6KRaYwfXraLkHgUw+K7grvW5ydgy5QTAYfFaoptqmdibH +yykDJCjHenlEwhdQ1ikzRR/a4cnLpDc+GNZRXRk1SzLD5DQCkEto0xI0QU5eavqyy5JXvSmaa2ay +fTFmplkDiwhSDiQJqV1tVM08uHitYK4P6aqUoJE242f2WtWgCqMKcMA8JaIj/EQJ7i08Zm6gMb7H +gsflVmhUyuhG+aQNjK6U1yej9ce+uirFbcWMD+O77ZO4XjHwZKXkurLbKkNqt1WBZflOw90q0oQR +0x2rxVEmgqgvlOezzNH5wcVqqyNNn+ocR4cPC4W1E2LsB75WA03jw4i8w6vSxREP8IzwnvAKr9m4 +KpZS9ryv3FYDqPbbFGAxKprMnwa3lWHg7Ygl5iQXFetMFr+Kvfp0SiPeXK5OPwol4Zu6+uOUDWzM +/jVXxURMiJRkR+IE33OOhY5os+5cBZOMxZjBb9XgpYENIm1g52E9wjsDua2i5DZ8sd5HpkN0vWhq +eDHOTLBdJ5842/Yd7Un9kJEVqVphK2r62n7ESHVTJ3MdbEXeFRNMMrZorrlid6l+9O4V2opeeqKv +0FaU80e5thJcs1TsYiW4Ik4QVwLAYm7g20iABg9pZOoogCryI1wqtSsOVy3mDFC5HMwZVEBFZWNa +tDjy6aIg2+RjR+syhyixEJqdL46uqaN3mVPO15n5hXRh+dIPoIo4DMBCRDRyCaBMaRgc5OKIHjl9 +CRwrupXykcSKumncQwYVLdkOsLx66sRyZONYEBCbCdBBkM4whYCBAFLIuTMJAUZkv9cPK+5AWwJA +hYUUSM1oMjALrl4T9AESh7DRVuda8zbNJglg4YHCs1O7wildJBK2IzarIUgZWMIe+My1/rhjLNdo +CI1x4lQqPxqNGQCWeBbNlcV15aiXAhrFhxRgdl521KEBKc5LjbXglg/ey472tNHRpBtXnx8TQRRQ +NjCQ303OXo06Lo5iizTtkWtH4VZIW0tgFl3DHvPcEJSkw5CCeF1bia54kexTuyRshpR6h6AmGQ+M +CRUofcq30ZN2XcLhoTe1tnBUN5g2NPFNPTs1enENbVqDGnTyWrNJjx7t0a7gSXQz3T/YI5p+G8go +nupEgkjvCb+z7ArzXxvT+Q72GNUGiAcqvIbh6mXhtQbZypyYgRn5Qnr5XaEoRnXdBJUxO+NGKI83 +IDGMLgae4VgzuVUw5YTqqqUNKKg7fDzcljJEr0me6gsuQGtSf8X61CsVbIv0WoHqDRiAbdp19X1W +FErmQevziJAJMHb96FZlE9XoDBMfq2+VAMPW8WsWhRE5Dvr8fwtI+0JF32VcE/2IC2AqiaUO3CLs +aSXGgaeUTR8YTw0qDKoGJkYWUjRBxe6QTNFkDl3Z7TSV3sA+QwqxqphsSJFoIw5dbk/NoUN6KDL6 +WB0ilRAAvAuZQw+HrQFVlVCBrHOZQRezO43Gk/WPZZkHO8x0xlaHelRb1Sp8cCmtSIU1MA9YO8Eu +JCdNhGgw8PSZbBQDzwCpDDwFmH03VWdNq/tTDcpY12ymyZNrGNmmS0gErLLSmKZif0UziFW7omk0 +bvJxBwv/eIhykeqppBQnw5RdinOsFlaBRlHJBZgDt0tnQ3R3Zkx1ELg+XKvOJj+jGp1g9MZObnQy +eYyu9ACjRTPB+oS7RM+so2rmpAmQ5pEMJMiYhJjKP1RtTReON6CYBlxqVx7/qFoJnC4y1gAKQ7DS +AOxywLEaGkZSrSrLE+nXaC7cWkpWv+NIlm5oCBpd82FTaiW1RRLKLSD9RFWHeB3putHVd4lPj66+ +0xzo9dV3icVzsTkGZQCVTamBBaH0mWa1xfnp2+goXDK2VkeWLU3VwbpBniKoXKgJTiAaRG9nh9xo +2Yw4wpNiWs3MpAYyCH00sMoVo+kxrfJ0GTYR/2G1tjVxsicDqNq7AVjubBKecBJd7s1l4u8qIy+t +CKOTLUsYzj9lbh0jlLo4Rshjka3UbQGZhqvqEKb/wq4yrVRnBqfXFDIbm7wK9e5ky3eFTzWo7EkN +LIQ8d5Y3uBpzOIdqbvm84G2Y0AmbpZAanarV1yjhaAkCiYIXegqsadmIuxXjTWc7ES9kuc4hHAMh +md7KWnrUaXBNpwW/HfKy2Ni1npCmQQ0ExDjFjkkymJaltta4HXV3irHGDW/w3fAG3wwP76sf3atM +FvDSE/0JBPbYsB3YY8NWYI8NW4E9ts4VkAN7bJgG9tiwFdhjw47AnnG7Js9tHNhjw47AHhu2Ants +2ArssWFHYI8N08AeG6aBPdD++iFQRgN77JA3IAfs2LAV2GPDjsAeG7YCe2yYBvZQ0a0eIzCwx4at +wB4btgJ7bNgR2DNq16bNnQb2MLIkTAJ7bNgK7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK +7LFhR2DPqJ0G9tiwFdhjw47AHhu2Ants2ArssX5HYI8dMgekwB7rp4E91u8I7LF+K7DH+q3AngzK +lqF+3CwH9li/Fdhj68QBKbDH+q3AHuu3Anus3xHYUyxuikjELb8V2GP9dmCP9VuBPdZvBfZkUEH8 +tpu008CeYgkdjJjWbwf2WL8V2GP9NLDH+h2BPdZvBfZYvxXYY8dv6TWwx/qtwB6Iy7E8JGDojvU7 +Anus3wrssX4rsMf6HYE91m8F9li3Fdhj3Y7AnlE7dQNbvxXYM1prDuyxfiuwx/qtwB7rdwT22DAN +7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK7LFhR2CPHRIH5MAeG7YCe2w4P7CHMpX1OywG +GXhzUMp5l8cWgxEVyEq+9VsWA+p17RSyZTGwOZfEqLOpxcD6HRYDACcWAyLl2GKQQSOLQQaOLAaj +j9ViMBpCLQaTqaiSX005WwKqhVWgbYvBsE9VZxOLwWjPs8WgOptsMRidoFoMMqi2GGTY4RhG3Kkt +BtmgNbIYTIEx88+JxcCGLYtBtpmNLAYATiwG4F4TiwHNclOLAYATiwFv5dhiANCWxYBC3NhiwKs1 +thhk0P54U7YtBlOgMqCwZTHgsGOLAac3tRhwGWOLARc7thiMNqUGTiwG1RZni8HoKLLFoDqybDGo +DjZbDDKoshiMcCJZDECytiwGk4Yq/E2BsY+TgZNIErYsBpNl0GIwWq1aAkZ7MoC2LAbc47HFgCcx +thhk1WRkMRidbFnC1GIwQSi1GIyQJ+vME2BMMu/UYlANm7V3Tm9iMSisbLAEVPhUg7YsBtXeDZ1N +LQajc6jmNrUYVKdqBw68bTGYoIQaB7J4OwVuWQwyrFgMInLidN70VpinR1RG65ldUuQi0ximpAzC +aJAYvkF9ociko4j9iCISolKOYR7IUSiH2w2ZFOotJgQzpKsxQ7qaKkVNraK/OgPCS07zlcZ6sGwf +MrUP5oOg5VYITPaDsKe6jSvmA4hHXfqymA9CotHGZfMBUldTHnD6ZlZB6hRMoPwlYxRH7TT6gZ0l +/5NK63kaWZgMLnWXzAchCfoogNBnr/EAKuaDCuhD+VLzxWbzQdJqARnMB1kTZK0jE3M7o6DBmTuA ++mGLBmAyH2AF1OJcNh+ElErIuMp8kL1lxhXzgVYgVVBxg4W0gMF6gLOyYdJM87obV8wHIQXbYFHF +fACgfpmtB8W+44r1IGiZJ4KK9SCkKHFWx8vnon5R44r1QEB9q70N1oOQnigD2MXsF847nq0CbX6B +7irrQfEU1e00RxCHUDbUKn/FPIrxoM002hXdu00v27FvyXhQQLYyHlTAbDxoy1vQbD1o9U0oMrQX +40ELayn3oRgPhliAYhVoU0S/sSM3dh919ysjQ6+3tbJ+KC8AqBgP4MXV+1SsByGlGNQSUulMY6N/ +rKwHISlHLKCR72R+Hl6sByE9zgeoWA9CEqQATOYDRF5ooEIxCwChu24AFcTXMJmqXeaBxXwQ9lIp +bTuYD0I6Z1usByEVmwLIbUGK9aACZusB+kq7m4wHGDHNq1aoU1VDW4wHYU8bmYEABqVKleUARFej +o4rlIKSiQKyzma9t1D2uDAe5rh+ATZ6ZpqBB4Y8kZrQ5OYOpDAdtvsJ1O1ZlZW/JcNAm29honSg2 +kfAjGw7avY6yA0qVJbWtAg2GgwJ02XDQJhsJ7l4yHLRZjHRKHdOX3qfbnQ0HbT4OVwwCFWEYDAey +JTTbVu0Qk9IpwWsLydZ0XGRDTcF6ta0ZVwwHIddqcMVwMGWl24YDn8JsjB0FVqZqnW4UWNnojrsq +dWOKlXPpCYkZDErjDDWska08sqjTWsSzzkHX6/vycQK7VLJ9nMBOZdjRxy2Fc1MnsNPEw2acwC49 +wq8T2BW2M7ypH0BV1PEALDnsUs3eKoddm+ts1Tns2i5xLLWAcV02kfshiZ3G5mdQXn9CwjqHHQvV +KO7X7xUyBa2AavozdSK0NpHGwcrQNr6i7lntTCp4ZbTIMWuDZWOA1LpuBg5J7BIHqnLYtU2j06iT +2LUmf1meMCSxr05Fl305o9jKJrRVuxKbnzjZEFtpEnZUsZUm71EdW6nPdkydK0xfD5k6o1gB1bGV +AzDHVqriaGwVW6kPAowdxVaaTG6H2MpmIHPFrsHYQGNHFqA+YdHo9Pt0FevQSs35ZsaZ7DJDqTLZ +2T6dfygW4iIY1JnsUu32Ovuclik2dYY63/QVqNjR0x5U7WI6xqE3zedqxrnsiiQzzE59faZOZpfj +LkfJ7LosedW7oslmzCR3WbDbsCKBlPNIImqdyy5RinEyu2xwqHx5bUZQfawyBlUoVYAD6mXFv0LQ +TPZHiNyG4CYI3xZELtdCbc6jO1Uch6PAShPSQQ6BlcNVKYGV1C3GtzsUpK6s/1lTqQIrC6gOrByA +WcLLe10FVprEQ0cSqYm2H10p+Cbd+EohGLg+6vRp492UygZmFpnQ4zCwtxEwJgY3hFYak0qQZTaQ +StaP2UVg1c+aq5Rtd1Vo5QCqQwsLsIRWmtCMGV5QEW/MGINWs64ZKFzCXdK5S3Rk0xYNu7pSenvG +Ce30kWv1MTIEmsTLh/cVaTtHzzBsKq44SBWqV9Sih2aoHy1/KsxsR1baQWAufhKbPLkVQtiU8KlC +GwjdGUcqPwmrJNZoCFE8oU0xrw2Qyk9SgIOfpHQ2+EnKoINzoppcdmLYFFRdXUubkumOrnT2p4zu +dPaojHisSamKKj+JaROhr/0kWjKxmrJjSbTRwipQLSYMwCxNlM4GkcNkmaaSTIzP4kqRYPRl+kjM +aTI7qB/Paqz46EpXwNpTot5LSvqVwdIk/B0Bldu5yrCdVMKcfZkgvljj1R8M24kBug== + + + yrJdDEeDZXsAVZbtAdjld7GaMW4k2Xqmt5pIwKk29ijVMwvxjeTpVEB2LIyXXamN2H02AY2ANhlk +BtO2Jtasbr/NWmJ9/S1q4o2vf7Ypc7XZtj2AKtv2ACyXrwtJaB+M212m1pVtu+uzhJ6OzCYXbnWw +VmvnFlC+U36CE8gCQIQaPCV2giYJ6Pk8YAqMya45jJvqmNazS4xgvIpU8LZerNYWGG3JAKq2bgAW +eqRZvngQXe6tKHLFVQJZzU4PtqxhOH7NSDZCKMuCX1u4o09uJsCiFpcOM1srgzYm22aLowRGhLwG +lZdM8j1XyFSDyo7UwLRzQ2fD9pYx62PIGFEOa5AFypEaNQy7kZukrLzGhyI3Dm6SClhTshFzK24S +pOBsYsN3r6FjpTgU5XR4TyWyQUvbPSp2oU6X0A4t7RxdL+ShFywLkYW7zKTiUsPC46MEamZSkGAo +PjCk9M++B0RNIBFdcjtMfr35KhPCfrfZvtKIS6XpdFPBTJ3MOGpkLtCiAUKqK1CFMWG4piTNsXGk +TY0Wny5KjL48byodxjDHSqNlkN0EhgJf1Xt3hTZ9iYM0nVaqbdoSt6im4wZKTBwiBpWxMzVxU7Kc +o0D4TVZ9tX1SIB2LuxZYlihpLCvQ8vTShOn3nQvTYfQ5ZkNdxgzvIEnPUXDP2hzUgNrfXF8JVE2Q +8T5kYLVhubdhWzV7xXT7O2fM9Jxir9tQn6c+by6wvA1Umqb40OrydgCRyhHC3mH9+RRID3AG6iTV +6A76V8q+sCYNE02GIWBQuT8TUrpqvzRp5QRCzlNvIFJg+hz0p/uH8uVFQdZjM8w+M3zpFKaZLwck +MOQreUPVtJpAWbUgYmVgvkrEwNHHSQIlWxphNDN7dpWBKWh/pqSy1fvBNKZ53wqoXn4BDtE0ijbk +Szkxh9rpyZfKIiwfuI9OxvIF4Oj8kuiXQPs1hZkcfiY7XU8DQo67UnWwburSC78pkBG5E2AqzD7M +CNatthvN26XXwFgfVKRsBVQ5CSlLTbaWqaVoL6Rdq0H1phagxoNpb+l0TbFQ9wkzhpN0Wf4dThyW +7HTiGS9SzbIRThXBosYpl4OT629TvMWAti57iWvshriv29QO2WNUJBiuygAZFj/ABp1DFQdUS8kV +qXwwdoJQJTF/fTAh7Vp1fBqbP0Iol5M/jxFKn2Ajr7x1Q37vxiWoTSZybjHJY6e5e4hMKOMqoNij +LH0eRssKIFgkCdF0HwTyRaw3p+Oh72FMMPMBjWmj03z7Nb3FfhmFmZCjinyTWGpTF8zT+jlMEV6w +RYtQMJF4k/XFAqs4xwAtHAYdKpse+FCybE44liuXdeBtOVtTzQJdekswZqFQC/p2ykKdhmCMP1cH +S8rKm0DMVwQQgyNTjxpUgXzsQ3Et/QnygAav0rHR6NE0HdeVvo7TjYhpLvXO6hvlRpQvCzdSvrCN +Mluv9ySTnVanE1qtWaGmduWNrc8GUgRRN0YRirJ/Md0ru0ZutiZTZVpBG2aKLoIWI9IaVjPzYUxc +8XSJLoAJdU2IVsxZP55M7Gbfzvzs4bVU2Tv4XPQ7lXJ9fI1Agkp4EYt+p7/UtcLlj0MZ8Mfajwkg +qliCaZDYOfcvMo/CRT+kRxRfVJMYzaGawmgG4wlMxz9n+HNHz6Vwz9kzo3tmRCZIddOpReLUU52G +7NHqQhj/lBrxp31qFFna4J8yjUnN9Ve9lxqRUppXP7ncp6uckNX3ZrY1jjS/K1qMwNth1nqFYzox +7TEZTmONBQyEySstmR5yjE15q1NWmu5xN8S9z1SVqprrr2ml/HloXn7KjfhTMmWPvvezrXHSSn+s +W2RVtfx3QYYfX/39uaHefSXiVyIoBX3yaEfVkuuDaIaDkD+Twumn5fyPro3RJ525HEFsNIcPzr7C +vtRSGghb9uolR4MaeQu6oHmNSDs+ltErPNwxPBqM0LjMHchY8A8LaYcdqDBxhIjVlo3PNx2K6YGd +XaqaMavQI7WMMnfnQlLJZ2PsKoeA5vVJ7/hYRq8QZcfwaDDCszL3H51Q/duiy49Lt/6PIOd3IGUV +wS4dVefSlHMZk7GETG0S2ORQEEyUmGnCgBG22tSyFU0s6DBTYM1gtz8geuV+iYyTwRPXTWM2irrB +jrC6SZ/03tk+YeEWtGbKuz4xu8bYtR2FZ+/cKNNtwwsL2RJ6EzsxLqQvAhyGfhD4dh+GzxjcKgrl +5EgJL/v8iQm9K/sxgdYMescnxNitMQjddUJNwnrsJrC+taMLkVWAro1Bw87jNrRm77s+8TvH2LFH +r0bwfH1vfhr35hXIxq9v6Xe6pd9VRj9/u89FoOlEMwJNt3Qi0+8Yqb56W/LS9KLuvthbctj2ZwPZ +2HmXVLLbunjbHU8v7DlXfHshWx/uIiY7tyjLhTv3bsftz3LJjkt+7h0/Bwt23octaWvr0M+5eVty +3I4Pd9zxnZioMuLWzdgxxARRz7mDOxY1/XDXbd+5b69E/Xl9s36aN+vH19Be3+Pv7R5/R03x3BM4 +D5+2uem5zPSza298dev2+vTech/jz9cvZm8LKMxufXB8Ort++wPjHs1PTxfr43qan744WdyYvSUN +TR/hYvJ9aBojG2udzN80CMPrWGhArvUsRi711ieL+eHD+el6+Q/5ctR5//hwub94vD8/XB4/e3+9 +PPho8UIHkM/urFaHbB0eLf+xOHy0WD9d7J8+fnH0ZHX43vH8yeHi69zabM/7vX+crNan1YyrDksb +9vL+2fJgsdFW78j/r/Wz6zdmX/zp2hvStPnqveMDHZO/+6/uyIYcJ8j1z2VGq/VMpn60uIEwKPn/ +F99qPNTZOCxq9uwaK4fzv1+8kF8+lB/+JiB6mmZf/rWZHcj1++ITyN3pjWTXwoemluZGX0R1pbpG +SFmVOhQsTMH0dA7nr+5CnEoPSgTW+/R8SP2TAnEaNTod7e61pzKRe/xaTbhtpzV5qRPs2Qg3YRsR +TypqT88y9EYhGqHdaNx6C1JmYC25iVp+dEO3LfL+y4wiH18btrId63jvqRO55UsafoZnYEhVBFjv +mPJqz6XRcqY3BPHp85k2VX65i5IY9JlzPB+EWNoULiSTpFsaubzguWxRMs3iG+awgvoUG0wkzphz +DW2i0VeveA/cwVkqANaGvnutRcwlNjgGTeOD2BgGAsQWaZS6GZ7Y0zMae1Xx7l6zrJeMw6QTWMiJ +7KnlWbq9ptW4HKtpcTqvYaY4TKZUC2yVXmrLpjCndJfeicv29PpyihDb501k2vuOtXCRgxL7hL3r +mOFOmrOuNcIIqvGQpI8u8Q5FyxB/EGWNfJEjkMDcVx0zEJnReH2BIXMlHfsmvfyQPdDKCjlY9Wbs +FA3vErV6rk+2ThMAGbwNhJMz4jkUv8ObIDwDi/DXB/0OeI8YDTkWZ116ZMx4g9gkV/gWKgPJPd5M +IWQrRmH0HbygPqRCXjIHltNmdUYecKex0qiIaIEVnUwXHP4uPuqYAl62hS/nvU2xYB1ChOTMfX73 +MCwXg/NVfOz0bZrPVcoiSh5F9jKeHuYM1NOqzEC4iJerAPUsXo1MzK1QXpvmDAAKAw8fCfbLdbp7 +TTZGI3gJkZm1uUwpfsCTXfwhsr52L2fNB85tSKWq8LXMp3X6LZoIyrQ2pcXBriPETa6HSfnb2l4z +nqFIPB8a45M+9LPQ7ekYXS/Cyd1roUtZ1WR83OWQq5PI70hXI7/3Fpje4skt+GsAuWBhba/7Bt+2 +UXIgwpXF7wyRUPLATxA+AmxvrYICsD7qN03vCLCs3YNFiYilHzH2FZWeOTObXpm2QDvhxAAwjhmL +9F6nhsDjmwFEW84qpESRodVC3QFVEKQHLApPIuSLqOGnAVEUQfqMIvZhkGA184B0pYQsGI2K4Tf6 +piQ0eAiEXjWoC2Uem3rPPA9Qz0VTFnirJZ9aPN7HpgUEp3mgg5Y94rgYBZeLoWzSvbdCp6NPef/l +yLxzRLvYsz42UuY4opnTd57Y14BHNjHnAmzTyy8ADKLLW6+PwfmRxra3TF3JjvWZTYuwvRE+p0uA +m8GySJq8qNesB8KuAqpbM9V/k4rFhfw+VyBaninkUu3OaGoG0D6X8vBbFOFFp6Eh8VNIz7JO0/F4 +P9sUZSU0k7mp5H6WxM26P0IU9Kk/0jlgDwhgcRnEAPJMhVBqNlJke0HhL/TLB214YNZJm62BuAcO +IbCCaEZD8WQHkLAdkZYCirk2BB6KBuSdY2b5qIGPAY9XoiXH6BhfBpBjsuhe3/8FxA4xLzwqWgmF +SrRCPvGIXRMkxKZ0rI3ZKOZi3zgwaCCYHCt8kgjd9HgNpf1oLirv9LhY0Iw11xD1KTfVR31chI+i +Phdg6VQgtYgd4KteiJ3Ws+tJKXzQguz4pNeUJR6ZBzAOJoVoNt/qxQOAD/OlswY0FyiQ0gH4XC0i +pHSz0ptG8MrF46NaLX9L3hc6pcWBqSNIG2JoScZMBx4FmQgsAkjXUD8AlWZ+tpDLQYBQiZghv7uO +ApHTd25CNlgHAt/IFYMYFlKh7lYTdQrlEY3H6W3CHcK9Do1+gnjERkA+PWlDH8BDGV+kGUcAq6VA +AII6iY8aZT2REpXSNhIKyES8tyBIQN6IVz3Wp03gk1jwIRKIVulPtOmJlgACsu9FljkjKgStNBCR +pJbXNGqZuIgCJhiYAEGJGJVx4Bsk6pB9kasQQqd01CMej73wnK02jkxbqwM1mohFPvIMvwZyIOBM +OlZcEKRguGU1km819TKFOlbIo5aOflvWvAu6Y9U4wFyIsxGZOFkW0Ct+slvH+9DF8SiJQAx33WlF +G1BELS9KM2h0vJa4qL2+LgOEFUmFkni5/6DNWpui066i17KtermZRYa0uZ8Nv+fTKd8In1MMZckf +ubrgCk0qk4PgxMiEabLxieyAUPcdsY0QEfhjk8iUa/XRU2yGIkwoxiV9epX/nFdhqUUKd/baat7K +NmUAycOAJ4OW4xunmWLAgxum1uySoOGUM9wUfZl1WNEihvQN0z216ZmlS1W0A6oO2WE1mYiCsJIC +QlzBOA7GGtlqSBUQLmBWISlrKQQwuYtvVRmCUKAMFFIiiqCBJYkY4VPYMfCxEfo4HYHkvEweeQl6 +2tSZekBB0TDjplHVCLxQc/j0msUbilWkHHLTNgzebZkw1DGlHB81tEi1yVThk4E4OrAbT+YTvsng +gpkcC4eo4jzFiGhToS5wMqdsvu01D1TXaGICfIo7CukWChK5oqNwywhUcLxInQqyPZNYdSxbGCn+ +NxDPcJfQhd0zyJgRUzYRfJKeDAOpmWcoIvFN5NSEznYEML0u6ZThfYtIUuzYhkoybg1IApbDcnWT +DSAitJqZBVI7pW8gKfIvyWQN3qZ5yAn6O/PngDGCDeF30ZCACI2m6YmQH/qZoB/q58hvLd6OTQbA +mMhng1wDXYdk8lBT+PZeZJAusYwcstthotB2rYpZHZCsp86ZNMsupZG2ibFC6ccz6A== + + + 6Rh3+QqNdozQpXRJQHlQuaMKZJTtP7gmBFzDwqG2IG49FCpmFaMHMdRkJAuIcu5UNoDIHPCUFZqt +3g7ewVTc22ZkDiYlD/CNyqihyWXIhDz5jkyczBEtWNZL9rwdaobILB3ua+ATb5dSEAPAusOuZK8A +iO+BYC6G9ZEiBZMUd0zt4nNWahs139PdaxCdtNIHtAG5n0iBBAMDrxiQyfTpqQBIFTVt2+TiYEaz +FliTnjc7JHaTAXmeLA0XVCPmgWq2DZbnkgUAJ7pcAhLx9LZUiulVd7h7zfSZGksbTkXzj8nAVDUN +bDEkvQ01E/nCpbev2BaR5WfGaOYBADiVnsH0lmSzaxoca5/q0rpeE+iD/2dsMUIskcZCj9DzUbJs +tUxZyxun1XjyYJ/EOyDsXp+qLkcU3uMWULbSNqTglsWpFMC3EIa0xbPbzpKqGmAc5UavkhieK2t9 +bFiUupnNT5OAyImbNbipNERBrKVJotWshN4py4PRq2FWtbSmu7TZaeU2sHrsugimNJLwSlBn7VOt +zHy11GanKSQElWTbHI0e+nJQ9o8y1k2DGsuNSuaQQ/BZn5L6SyPjmIo49Yk5uo7Jo0uNemh5Ohyz +jDQqw6Ts6NASO5WMiJaCqJrYK2AfSMMAc6nYMZN1yA3INYZp6EA+PRoD887vp6Gg/EFc6lPKeX0P +xg3BRgxTBPHX5Ae4DlqMps+JGgWPO6O8G3lNCUkF0dq99CC5T9zDpaT7N/lQPqocYVKeV6IJcLlL +YjKuMosg8xmFXhWrqZJbKj3EEybp79TupNqP5g2yNBvly5Ay6XZcGS63pjN3UCySJEIeaPEntilJ +z2DUVXKlRknTalZ2FfpSqrhWNXFA1EpgupR3LitbN03Um41J2vxGKeTK300q0WFwWo0qdr0mwBRJ +FmKJSrIpI52nXYO3S3MwdunlPaQcTaMyDBdyyl1MCocWIHdFBRgIG4BYTY0iHQUdLbikAZherQjo +KCUu7ZO0UoazjRZiVnVNc2FBHuJDlxBy5mKnCe/RhhKmliRRI2dUuQ0n5x2NMX16ji6YoCkyYL7h +0xqn7jQqRiYl8cOxEpehGVl+12Ncq7YjLYLRZyEQsJ56kwNX9Gra1usmvev7elHIeq14g9dq3BWa +6TqFaeIj2MM4HEg1lCja32nDgcvH0pxE0zXfY8HaQVG9KG4WWhrNi04L+Fn0qOolBB8uRU4qGDWH +psoUPfJDGMp+mrelugaxT2IBqAGLmEBhUg6ZhOwiU1U8kwZfzUbvkoIuUqGWUrWNEuFhPPhNkVIB +38X0vBAIiS0QQEqhCoWsMYN4CSsxU6Po6hKS80o6bkHPTF3CKQ03I7qUxwU6SPQ2bWbP5DIQJmj6 +oiMAVEfQvmU2Gdg+mS4MTDg6Pbw+lYptkTKSxq4u0Xio/swKBT8EsAEWQ6v3vA2pnG6bnQGCdB3r +I7fM+27V9qa+lmGagtL6Kg04YxptpYVGOyZF8IPpQhZsnDJGqOA69Z6PaA1vkBr+e74ZU+Ofcoue +r4Vdunnp7VejRku0UkMxfEvUw/PFgyegUdSEMUnT70IDIi9xOYunSXJWIUcda5Rk45S+lEVlXEqc +Akk5sPa0UGr6CtIGxCkl0NRgLZK5dWr4pCvDwH6CI/Epx1T9USpHbfiQz5Dy05bVkCOAPmfFv+FW +mzZbGIDqMAszczhs2MK3Z55kr7J/9LB19222f6C8Lnxn9IaFpC6anI8EAChZxqtwmHYedlADzxsu +AoYW4XtG9oEjyTZKIYoiTqmVARZ2ORzohERG+DyQcQbyAisbJQZnQSmaNm0f8RyyayqzZ/HSXgZu +c3VKvGY1KVUOjsmkBblUrdqoEEoWFZVGwEeHPmMX2iRUMB1pySQH2gayhz/QQGqoOzun9bTxSa8O +BfxFzbOdOvik++CwkTZqPQDmRvIk+sxUCgkZMrrRHPAkfTbfZ5uKZ1R7YNVeYnO+O7SFsRayudb+ +MHwFOcsvqFVyYXpKSj4qgfRIao3fGxMHcQczwrGrIEfXJQWHlJ6IRnTIZcZVzjMH74pSULkx1G6d +VY8ipEheNAeHS1QfHOUaADrdOxi8ICE5m4q6RniiREPz0LowXziFaOGENJOmZ9Tm69UTq95eDt1p +Ou/io8NFxS2GLAYdV/ZKbqZw1F7lG+AaOtbnsrDhCboDO0PydzpNz+HBkFv1K9NTFuAvhdjREQ2s +WocdbQcsStOoqVpJNKprACAcpWt0vpw4DJch7x2k8rZJ9bLBKoxRa2pMyeFEGIqwIQmtyJPjPGHg +TQkJe7wdp2clJe0jqYVR1esdl4E6vM2Ebcr6XskqPMwt3PTwDiKrhOxGa/WRMJiA5higYSbS74MU +FfJDy1TGTNIMu03MSgdzWwv9aqE96BkaesVhvHNu2DQIAr5Vg8teYIllMioQ1sbDRCe/qnMb3ksa +UxoNPsBtYBEUGgk1AxqSCne0peiVyq/xByMNcuvQ+Rm9+twt/SJeXRky1ewqB3+GARDudRdhRIHx +qIcvvWfWA8gCMtosn22E+7Cl4tmQg9CxLlex29M31ipOdKCuHqFktPXSe0wRQOYbO5XLDN9bw3AS +YUfKmeBgSLGqDjNrnvzOJIFIuUczZwe1EIFB+ui7GqBVLg47L8JkolYKiklSBxVG4oPhA8i00Kdj +p7cSvyNUAYsG1oMktZW5zCJlghwsVoBoC0hMcCzDgISNT+2H/q06zwBhe6uyD+MT7IxJB/k1nWLS +HqV0cLIgqPIXmhVgSGvJC3L7VFb97jUIyT75BzvSZdh3gY4IAYBtlaiWygnSYsIthLdPjsqT4lpg +tJHThl2GsiG8FKrq+lSmA95t2tfy362RZcPmA0UQESOedxWaJNxs8A93dKtTd2xT6mAYJXhzy0WF +HQlWNYGIhAN1Cx23yWLkIDc3Tk2ljDZxrTqP2pTe18HQ5fhF70GnhZ+GWN1qpzNpYa2Xs3FB9wjO +HFEFYAIk7YZwJ0KkjkCdBCJaKz27VJALUoORuTsU1xY9OrCeGD4IyaZtVVhiDXMRWAJMWjJp6JVI +oEAbt0VAHtVc9fEpc4FvWvYfxBasPi0Cfw42L4I+NBgqA1eJFMue29OVg4ZZIeo2Wc19AZlJ9Hlw +Ipa9hBWtJ6fqELQB6yCt7jQxNHrCQijUkiYo5pExosOvSBvvoEaQjCETOLRgxzgdWjihf8LPYMFi +kVNbbhq2BuMQs1V2gKG8JeNm8hyXkiJkA5pz6sSj0Y1jBkUdiEO9rtUijKdTy+cgnpjIUB9AmKcb +v0PhdYn/G4hejdfzpOcZYV0Q6LHdMGB5tZg5lheM/B3kYzwEijQ6RIFEkgfEGGCzcUvLGoxuOldN +zRVyEdDRprz9TJNjuQsMjrCNugf5BWQj/A564dXhB8olSAsbCixB+JXRMDmnPkNqHUUbB5eoTIye +dIyLHHDyO7Prk2J4FNfT1LtEPSbuZ7pboF6viACJUbgdvog0T1qVqCEeuk4PzHkM3dOuApuJoanf +RlYVgeEDnJ4dqSmWSoFiEswSLWU9qKbgaiaoDAmlF6dggjJuBAo0ZA59q1bfXmmiobt0Rt8fXm9E +TWeVrdgwrzoiEuIL4GptUygYqyeLYChToDnCJROLSSxyHyRA365bZKQxvAaUWW9yMg0lsp6GFlgW +OoYRQMthZhmGu1kSrxx70NFYkAeqFE+QM6wWIXoOWSTh7Weu40gXHn1XqsgMahnsopr836jZ30Pu +568dyYDXABBIh41qgN6pWkR7FK+5WnxNSmmcKTnUe4rrXA+VapqCKPn5lC2TErzX+IOQRO3k/gfJ +YiYjmwLFgsmGkpSdEfFA1J9giAs5qihJ9XDgwWZdzKPQEeDfEH7IjOSW4YH4pk8J75leSpqAB5lO +zYIegVeQ/Hwy41irIk62iuHGwn8HVz4fEsGDAJ9tm7CaZstA81ORMhktDtZjsmG/17qlW04bdejc +E5Gqg0xViNrRNZi5YGx0rPvSzXryYZAsuRu95pcZiKbQOJ4aqCw8z3BEOTagPDPtnv6rTrNt5Qt2 +dM2mKCaBRNBB/N4pEYmgxEIRWDkOKSQDeTKtTBRmWqEuMxbCkLkaunza2XQIDPtZCeXVaNaslnAp ++j4paoZKYLxt1NrEDJTg+TFZZhlRQKbUhKSfUU0AVSIWgcyAHLg42ElHI6krV4VXKgxwjhwRlJ3X +qcigYe58BmP11XRaGO+CmqfhvpQNAIgRMiwcAmmoSQ6t6UB3NX3OzojvZoicbmb7q6OT1dnxwWzz +fH6ymB2tDhZVWPS/GjMOro087Xhq4RsPc7nQaMdXFYI6TaevQYQ5wuwCmeWnEz3efC/R4wG/fvXH +1fGj9fL4VCZ986aCGVNe/+HaH0/wl07/8ujwTP758ZO/yQquXb99sHqymN1Zn22ezx7Oj+fPFuvZ +x+uDxfrGxX+b6R/vzg8Pl8/W85Pny/3U8lNZ2q1ZmJ2c7s0+AQLc2m57Y3bz2vXxB+biL8aN3eyE +XcgHH38zP7y0vfY9bcouLmh//3B+eknX7OKW/Hi2/3xHm/y1IPrHx3LSz0ej3H0+X++v2MX8cHZz +dn8hLRbriz+6t/xGcKQ0OsDf2MW42cPVSW6SMGxXX4vj5dHs8WJ+dOvGbE9xRJBqhCHfM6Yd6PjV +Dl67LnOVfzYzlhVEzlz8wzn9SUSWWTu7/cFXd9ZCBg4X/PLB8olQjK/uPpaW4SvgDLfg4Kv78+Mf +ayW7jkeWoYdan6cA7ezW7LPj4/nR4mDW3prl/wpJusWnUrdmfLJjZsOjDlN+ari2mbloYS8/z4RH +k8lpE2k9M5Np4ky6lKDYMTXxjIoTJweezjU0O9YAUyP+d+ECvs+TOQ/hseqC8ecu3FqzGxzG4HTp +9G/pUEXSrg5012akn3+srTiPbF27XtNb/AoCjP8hb1uTZ8z/f0e8O39oV6gxB5ZNEwFsBu8Jp5C2 +7HsfdiDqHDYApeW/Pf9XrtoPMmhZKwY1HPBmC70948UPNO5wujrwcLY/1HrP44ScRDPDS8RqFvby +Wbz0bej1L0L2Hp++OFxsrt366Hj17TF/ERnz+u3jlfCIW3+Uiyxy1q3bIn9+s8h/vXU3Sa33l4dC +Q9BeCPryeKYNFHpDZcnU5C3RB259vtwsRX5Dh9s9PD6d73/9Ej3cmW+W+9UEVscHZ8vTq3z6zrXZ +rUfz9emOXh6frldfL64+C8s/HH68Th9Kj7WsLhu4Ov1ksb8SefAAf9RmaR9nml0T8reDHUC0Dssa +wV60vQaPmtquwVsf+Dat6MqiA4ZWBHrMaC8nvtdM+XiGXP/e0GGaiwqzmHA3++L27veQFkkky3vI +Bu8h0eqLA1nN4unsndm12fVq5pC835lxobN6L/91rJichl6jtLUfP326WZze4PzP+T5NUlvuzZci +/t7SmyLtFwmXr4/6mz0QvJ699xSairT+dHn6Xc61vHStJ/DB8Wap2tz1/CPOX+7gTA== + + + 5IrNyeH8hf564xzMqFiiOffszF73/ZzeZO/vHC5EK7360V2I9uxsWJvg6u5HuchkWq9jWMDQwznz +/0EREbjwfe0F+hq24uPzXyhPN4PZAg6u3Xki2Hk9y1jCPg6WC1GlO53SzX6QofI/7+AZ9J071W6W +OWAzi6L92Wbx3jeL448PDl45joB6xR8UR35+J2yaG1kU+9FO+GewLd7+8NvyiujkFffnpW7AtVvv +/WOxf4Y58A/8dpf0NzMx/DtIgP++UktzidTy8dnpdxFb8I7S+c7E1ke4lBBM6gPE0s4IuHeK1QgK +lBZFQoXcm0VV/oGFoYYCT8xgsUsKMnItNIeLaG8/JzEok6vXQtD3xiLb11LQaySpkCTrUHee78aX +/kalZA3YAgv7zxRfwg8hNPyc5UNrXovNu1D/tdT8g0jNITaV1Px4eXRyWKRmPb6RVWf+0ucpk1oe +n54/izuLbxaCfKunpz8r6f3HtrxeedP/ZRHyJfSSC5fwo5hcfwaUK4B04ek9jIiGMVCN7dvQ9QhC +QpQcYvh+HEKvut79s3/+88Xs4Xzz9cWKHtup1naunpfd4YNWd7HlOYXrzK5/IttztnkVMp9uQtJM +4U2+eBe0Idqduwmjvq62ETHvw+rp5vSGEgiGGP3t+PQEv/vc4OhwefR/h48Hn1QerxfhR2Hn/26c +/d56dTJ7/Hx+sPr2NVP9uTHVV3K/v+tOfP+itlLnEQZfRJ3RUNudS53Ht+FqbKrNAZ+cjfLA2Xv/ +OJkLsbizeLpaL2afL9abJaIOiIdKq5+v1v8EwGXAk8OzNbcGUW+Z4p/M92/oQjjG/mbN37dJ7qst +T//Skn7Bis3+4TqtUBHibLN49PjBnbQZBXwyXxIQilRwMF9/Xe/Nk8Pjg9EOf7NYn75yw8WrJO1n +kNpe0/SfL03/v64DXWLD9NSG8CwB7/Y1WA5PHPsfVwf6dD0/3ggdP7qYvZRm53KXqqOr8ZYy89P8 +ZQpt3YzWtdmfHy4eLI8XY/B68fRQeNGfE5FUosi2n391f45U8/xL00z+9mix3pftT30lzWL1zeIP +Xz063Wx39oeqs+nYXyT1hAT6ZHn8aLUsHaeGwiZXR8t/LkbDrVen89PFV/cWz9aLsip2cnx2dHd1 +sizAUXsoivPjzdbMPy8znyz2D/ViXyPEa4T4bgjxCq0k9mpWkh83Bi76H0Dmec0WM1s0N1CmgoxR +/u1QXAK7jlfUrxnjazr4mjG+RoifCEK8Ssb4E+OL7gcxBPx7MUWDqjmdiX3wnUGmYXMejwzKIpGo +7SYyZ0erymPf/cgOtNck8TVJ/MFpi+HLqtfk5QcMp+uSzI0MipC5WfoSuXo795qgvCYo/xcJyuv4 +3B+SoPiRhOJQexUExSFf1M8+vJtxxvYHxZ8f9fT/1cDG1/GmL+e6vL86XM6fLb56//FrB+bP2YH5 +I17SjDM3ylVtyn+/pFEadBY87aYNyPnasTp6h2KQof3r7OTHv9U/Kg1DGam+R3n73jL9JUvw2dA2 +rneiTVukZ+j7GDrUdhd25DvFMFQnrP6DHXxNAn94Esh3kJ+o4Dr74jUZfE0Gf4axea+V1Ssrq2aX +suq+D2XV/B9XVl8hkX4kpHN+sDpbv5ZUf+Yk+mdljhjwbqe0W5kPvke51vwE7QzmB7n6r0hAb1GY +qY38B/J+N0jPbWPsbR+8R9gjl8r8zCN5HAU1xunRuhKvLdK9td+jwH51LPh34wXMtTi7u1ofL9ab +mZ2d/KCvVHeKW6MpXCxysem54tako5f0uK8v9Lj/7HnZJ6/2tcV52fJ2IPn3kCXmp67xvLbO/viU +7kuBzs8OT//6sukAfk43Z3dGAuaXfe/4YMgue2mK2keiLInmyf149IRJpPpojZdl974nn29Rx9Oj +lE/rtfxjGxuPCgY2dH1o8QACFWZCNDDOudbkZVz/si6P8Ncb3O8v/nltCr/2aH/7QK7/6fnydKF/ +e7XvxwQ1hQWkmfDNe2NDY1kdDlZJG1tsWYyh4bCygZin62UaniIQSj508omzshDKQP2QbwuJuDBw +kofSfACpW7jAqdx9+OePZp8sDvJsHOyfrpX+G1SEgQTWO9c1rQt9xMl5vYuoD1bn9Jo1Q3d/Xhwe +rr5NPXa28zLXrnMOFWQbFAeysel7VCxErStmwJWFeFl313pCZFOCjIjKhV1D0ywExnpBbkfisTKB +99eLxXE5aRQa80EahMDPjG+C/FfONrhQ0uyg+FCdtoxrnBxvGeDui3nuvxdkjoIUnZHz6flViyxp +fexgV+bhNM4b2c+mbzxWzwX63jhMxPeh53HVh+WJXP0Ul8JoOm6Yz53Ds0XBJ9k02bvWeG+ZT7iX +WyTzk6vlA0p8cfTYNsji5hrBbj3lCZ7SqTk54zLew/mzxfHpPA2Jgs2t7LL02KFsDjfByDa3cswR +VZ6wHOmllVtjAirLWV4nPzpSLHkrldwYkI7gtybMHv4WNpo//7ZvZh/Jj/nOozS7IK9QliDz4Wrl +zqA+tnNNY2LTJ5yeXtzx8gkZzSbt9m+FdGLMP/+2CzLwMG7se4/cFb6V/e55kZ3gtJAwEDbeG1zb +pjcheCPbGXg2W1tQZ85D6TiUHRgliB6m0XH91TQwgFw223VR0KBjXINQrB7Vd1ohRCRrvVxGlDQI +ch+9TYffjlQoHP02Oo6JXTWPgHngNOr9cILY1olG18S+0WOQX51FqfTYdukYKk1OumVYf41xjgcz +vvfDuELCxsewx2XaFvjocGQcQ2hJwBn2rkGhNMImWLWTfva79h2IV9AuD4u4KCHZnexUh2riPAik +PDQB/+4Cl4qSn8EAGbgh3JJ69dyk0Z3od7AYnYZt0jxG2y6nHeS+ydWzQrATygmNFT4hxNx6E5S/ +NG2wKH3qUCaKF30L6eLWDtn6d2PzfuyeSPTCRXpQsMbnPOey6cJHGjDPjtxz+zrYHYkjay7W8W3k +GEN0HjHsnEfXGpRwbqKcjCf7MW1wprUO9TDl0EishP14oVYxolR4r9PdvgBTS4QO3CkpKiNnUsRq +51EuWwy+MSCoqJNnjAkoMdvrWvooZKP1bSeEueF6bYvVIe9mY9kGd3g7IfwIORMnB07KpShEwZXD +CIIEkKMaufidLm+a25M7MyUCcYR8zOy58zKWzY/1ZYxd7JxsqJxBHxwFkAZl3WXz5bRRLg9FzEUQ +wFK9YAK51ZZoQ9Y/pc1tzRmbfCu6Jp+FH02ksR0qgHpIctw/E+AEFsHGgiCl0C9UCZ3cgnbL+NRN +hIS0ARwY5GiEfLLv8EKLUGl6bl8AykdhiA6ZVHOOQlNn948tt7kGsErQTjJA5CP5rccVTmQbwbMG +zKhVQaYRCUQEMZFWHG9zgwpwnRFqCanOKaVArT5hVbJSpYBbCLF9P8OITOT9wFV4CCz882+Hg6D5 +ErUCHSS70It8TanGyphWuJRphF2oJXAqWwoVHP0H/UxYRz2wSgYWQ9tQKJIQGpG25HLJaShFFhCE +EsFKE1UuErWgFcwQucV0SqKscNMuOCtXB2H1e36HUIJtGG9VdS90MvX5CHbLZQ8oX8fyyaz16UTc +F5rpYqAYIPqP86ACQtBDopZCO2T2aNUpNk3EwV0YHHYysWbnvOT8QZlELBWJDtXmVRyJsn6R3Lzj +jZXb6UDXhQR1NtAeOyFGO5QgN742aRpu2B4XatIptEAwQXhh0wlmEIHlsDyiBXujPQr5EllLiJII +N62irwgzQBz5d6AS0W1RjW2VyO3aHjNsTxgLNXJrrZydXF2R2gOlE+FosiOivNikBlFhmiCrmdwS +zH8XHSm3xtbnYoMVsU5GFsLZc7FWNlaIiKhpco8srwOUHPB60/W8qzOtQDuqLLLNTKe1RpJ0gYOx +mIcf4QcuhVAHBzGXFbFEnRB2LPghfL7hRfWoBWllDOyIUppWVi/yuAjHoSV6bBc4CVOE8RM5SOfl +sT8+5HPJVxs2AmG2HaQ+w1ORb0UHEHYu6NwQGXDTgjBA6Q0TJC2LQPVOlGvfO2VGYwlHL7ubiOjV +FSLlbZuazAShsQY9C36oBB5E8BFWKScNiYBzEUYk6pagtwWh5unJPkgT1yK3tlXxeUICp3JPw9LS +NZdIM8PhtZwZLpUvWCSLjTIBUF6rReeEGQhhE/xrDaXlvdZFwTS5Q7IEb4zSITliIYCdfEwc2mIK +7UhQInJP2ESFVb5MrGBVA74srEcU5o6Clkd5S9kIYZrR4bkvjEhWhIQWxglqayinI22iKCUyBJGq +npUhE524hWAw2KXCuHKUcUSF5Ai9IIeQF5keUVlwSYTXaEWjAdaDxsixtcFAug4ta/7I70I9jSgD +HWgCEGBbx9tmrCO1r68JJI+yGyEZNTqY0Gw5OA+JNsiUEeBGTaKTQVDu2oFEkNYFuVUQhwWjUWl7 +l5hhRwSStHwXheRFbEPWg1yemAgZcstFpLTQ8jGNFjQD4kePW6YyL9QA2R/U3nVKC0U2FxFdqL1T +1dltax9bkkdzPomIgzgeCtMVAiCYHBvpx/D6iIImCmF0VFEj0Qzz7p0QBCOyj905/elJbZvVwCN3 +EfdQpsbTjDozTQdI2+RbMzUMVpbL4tquIuPHjYc+Pl7Pj58JPJnfLutl0nzo5/78AEUCHn/94tI+ +qqbp+2x21YcAj89OFmvmsNXZzj5fPjuGffjSns//EgNdGP46CQgobfnhS8USVK2H7fnj4tvZ+/lh +w+Nv56f7z2f7q5MXM3vpoi74VAXk6/LXF/RlPnr2yq3UKo5kIVGuU7aoygX2HhZNGHZZsUwINwih +qHp9Z5L5KIrAKLPFtfOkNcLbGoHZNsl0OyxuWybe3SyunldfpuVQWTyCocvtJecNIrcbVNwWtdsS +Ijyk8Q1sy51TrhqDiGiiksmF77pd/H4XL3ZjeX/HtLpCd9QALpqYERLNnRDe1UJ+iwZGb0BaOSpR +aT0YDoUGmGYNNDOZmX5UczeK3SP1p1FpbGxO2p5VLLMStUa0UwfBzBl+bGGnFMlNOEZU06GIUK2c +nuAaOqUoBy4nkmYHgyLVv0ldD4peExl7Itxtz6ot5iuR5ERcE2QWIYTallMTsug1LVUSHAYKXws+ +4GyV2spHojlC7ISFg4rRln62ZWgMO8179bTCoBdB/QR+YWZk1yKlwXZpYc22RF0RLzsY+0SuMzlF +ybbZYktIaXdysXoagwAnWNJC8GjghqFW3MOn5kVL9DClESK/Ap2ClRsZVA3Yuv7bhvc4URy3p1Gs +SZCF4JESLh6Tcm4b0Qs8XHhCBxQi9z7CXyVyY6+70W2pid0WTncTnN6ehi06YifSjJA+kWpxG2c0 +/vZy8YPIjUGlGUA8REbIkcnivIWw/cj6QsP9RE3aRQzzLGSXRZGIIvS3asKU32H0l6vciWDIeYlQ +IT0KVojMmDZj2+6/5U/bguzA0Mw27qyXz56fDozjVTsVfzto0GN7LFwwUaToNtAFQQ== + + + XBS1C5RRiDeH6CHHYhNls9ShJhNzDi4s34Fi7twst1VGc2oyGiYWw/a8DJBJsBWWYVK/BtbLRgRt +D78n9xAYL/+TZkKKYvKDdpPanNBNdhmoi2ly5LCREWW5ogRKp41XzUaGlIPphV/2pGa9HF4bBZek +nUumIDk80TjgU6VTh3LAlB2MD29kMjTbJ9MLT5JLHGAHp9rSodBTlGvtYDsngrhGblcHtUMuvLo5 +jFy/Dp41b9RdsYUy20x9qjCObIZbxjJhR5gCogNFZcDE4G+NgsheLp9RB8a2K8FvaTJTB8Z5PKDd +MY9Hd0roQ45weJmyvA+Wm9M6kmSce3dnNN3Wm5hRRYiU73T0dnASoL0VvcFJfJcaw6bRPz1+cfRk +dYhu/j8Za73aX2w2MsH9U1EkDkW+vv75AvH9IuIuj/DrB4eHZ0fL4/np4mCm2gZKJssfZw/n6683 +s79c/3Z5+nzW33x8uNxf/OUGNmL55MnqWH54f7F+sljPb6TxZcb16OevIm38vdX+2ZFI2ffmp/Nr +b3x1K/8+e5u/VXFH8nsJ9b9zuFgcPFg8Pf18Dof67C00/uLhgz+uDhY7v3xndv0fR4fH8ueb89PT +9fLJ2ak+OJCmt9ciy+tXP3AX30P/Vav958vDg/XiWNvk7Pv5r/jH6YuTtDnXf3W8+eqb+XrzTlVc +rm76zbCRhG/OaYf34toszWQz+u1nujvHq+PFFTbmcLX/9eLgKjuTW35PiPld1/VkeQy931xhbYIc +jxenf+QiLl9f3fp7Ov5/cSfMhTtxpfUv508OF1dB/EtP9ed00d/+5spXHU1fMUZjeftnm9PV0aul +ZD8cHr69mSNmFQxRrthV0fEHvxePUVT1JzOV/wu3dPP0258wN37F12ADSfNnfsrlUdJ5i3yyOhVC +Bjn24/VShOGrnPL2N6+WIneiv2Wx/FwUvhL6vuqVWN/H5rKlvLjKUl686qXcdDa27WVreb6AMeoq +C8otfw6r+nZ5wCJmly4qNfwJ8HwSu8ers/X+4g4MDK+c6QtretVTOFqczg9EBvpX59H/i/P4z4Nk +kbgKSlWNAcn5+G5/YMysWDZEfDk7mT2YHz87mz9bzB6tTs5OtH2Lhw7lm342X58+Wc3XB7P91eFq +PTOzJ2VelzZdZ/UzWG+781vaoeWlfT7jc40xb+PaHq0Xm8X6m8Xs08U/TmfvHSxP50+Wh8vTRAhN +6zpXOs4bcXd+/M188zhlihh26+56dXJ7vZjr49RtqWVCcspMPtjcThNO5rtBPe0aZ/bCLP2LBISJ +K4AB1z85O1ysa2aaJ3JvuTk5nL94mCo6CTLkAVDM99Znx8t9QYCMFMNoJZvGo9ufJLrWRhn3pv5r +GP6TxeGnq090aE7l0WqzxNr4V5uoXrDyEf9x1S/N5GbkaXMTt88vzh6fnZysYSRkxMLs428W65P1 +MqNx6PouX+dHi/XmZMGTeX+9PPgKgsidgpUg0PGclvcPV6v1JxnX7FAxa9rwD6v18p+r4z9UPMeE +8xrfXRwe3hWamad6bq8c/uOT+X7BSl+h+v1DpGE5xkH+99kcmDt7ACPu9mY1s6fadrGerc5OD5fH +i9mG71czw5jKnyMG8nhx+If5qVwBGXqx/uDepjqTc1o+WO3PD4Fdddu6wadQijBqwlLj95q9pqJX +X9/+4P7Z4WG+eKnum/y14HtZXlstb358upzJZszTyty5m4tTGF3kC7frVIjEmElIQ/vV45PV6V1Q +modyqy47TgrAo9M8F0U+AR7dn+8vbtP6fSmisv37A6k7fxJsOZrFpRdguCuhu3Bx7/3jdIuP7Bz/ +zk6esLPpcPvOafVppbuYKZ2cNn6MfDtlgpVh/g5VlMo0f8FSOa96rf78tp8vF98KPgtZPp0f72fS +Dtdjh+dyl033dF4I5MXbKoT9dNjRCwjfsJ+tNf6ChhU2nY+naDhBUx+6eF6/RKeq40soHwv8JgLx +5cPFwfLsaPbJYrM6PEtPdKf8bJfQcr/cZXL801nF9IZrAoL6cLF5PvtkvhEit/wnN74aLZOT0Rcf +n52enJ1e8k0zEjuytDVbSqu5MK4neEous99NicvHR6z8UObA7T04We6N+YJIPYlAuqJ0nMwPDiY8 +YSNkazI5oZmDIeb2B7PbZ6ersrDFlPRNBa0LV/r18Wr/ayGkIoutsthYNe1nJ3PE422WR2eH82Hf +LhUCK9Hu0raDFGqrZsxodjIXwXv/hXS3PJBJ/HMnffh0dVIRh/HfSA9q0pH/+v7h6sn88JPFydnh +pixrh/pZHIryl1vv/eNktT4Fe7y9EXTdfLR4cfHVxx18dDg/XjD5AUVY0I3FxV/xhp3/WddGIVGg +U5eQqLT44+XmuSDxFShVJbp+cHyw+Mf95Xpz+pJ0kYNy8kq3q2FjH6QPZ9rL+ijbBkGgpuZXnkXp +YWsSV13748X+6vigGjb2L7N4Qcp65dFc7cjUCb19YleeQVn4eALniZwnWdNaZRl9k+1w7mpnNSx5 +elhxUP5GY65JuW5+o0EDcgsH7nveNPcPlydCL+DI+IcomM/kjm7ycd4MmfBfMMkFqNc3C96sl7oR +ZXU7r+I7GLikLpkQkGlmk5dX4C/pLtP8W4OR6dbfVk/2eI7zw8NMaTfjNU6bb75enjyRJX49tWFs +9SvT03COC/tbi6az3iwwz/WNK0304v6ETxyWHb++LVlM2+dlV1N9pxgWkOjkw9WTD46frmaDjnPF +c5uO9GR5ejTHFZoKFcpj6uYnz46+3nsClrR6+nRPre5JKDy3+RGiZabNd+3luPOzzUJwi+xvc/43 ++0d7R0Ux2rXAk83eocGdm6dNcuc0GhTbXd08PT7d25w92ZxeeXPWlaK+o8PN6eHegVpkiD8ZyUYJ +ey5AEaDTgqc9SJuXYBWGPDk5wH4dHtd2mQsnd3Jw9c51IccvMyF1W5dRdh7hyTo1S6hm7M7tl2aV +9XonhkmTtK7My8/tqrbuh96f12x5JOSkPuwYzu1S29bX4Loctij/B7MnL2b31kKu1xfvGHoZtncn +Fu5P9uH8RvUKTXfxpA+FIV/a36pSpy6Y26TZ9p1GKwrOY3l6J919klwDFxG4g8Vm+ey4EvyvQH6r +C3LJ1pyuTi5Yy+F6rwglT/R91EVtRVqT1qdQny5ZFHtcPV1mrTjanX2uD/ZWa7zYmY9I+87BL6ak +6OqpSDDPV+t/XmFq843ylaKx7OzwJFloL0IaLuHZXr7XzbmtmOt470K8T319c8W+vrl4Ozb7J4f7 +Ly6gXOAIi2OoWgeXzUqO/XB+ctGI7G2TU8Jdoa/nV8J2divHdoq8kVf/QinygH8IlT6XKwrRhZFz +TJZ2bumpCKfZVHHuJlDnfjJfX3BFtN36orvJJusq9dolTcnaL2kD4XIpUtmVhaJLCOtYpiik5god +X0iWIM4cHJ6sn66KqnSFLi8RabTTERG5bEGj1e8Sy44Xz+aDw2snT9+IAAuR98J+hK6eMpz1wjZH +9PcUTNgpcPLa7x9vpuph3egfJ3sjhfCcAYULQjk8ljErc+Gu3p5NpXOzc283e5P+dveWmQwdNOfP +cGi57ZuYtjtcnkxth5Mm6x0Kxq528K/QvXIhGZCGq5P91SUNDs4uabBZVLPeuaGb53NRALMba7dW +KUraZiSh7hqPjUa8YOcZslk2GeRzvJpterK6K4vhHHJ+fLy64CrqtM6O91OPn+093pv9afFkdnfF +BxJ/uf74Tx8/+suN2Tf2Er3lSMSDSmzZJdzJ5DfJ9/otXK+Zkp2jAGbrz/7Ri4ukq6HhSmsTnze8 +tIQeU6wqY7X7dm5YKd55Yg/mm9PsVv7g3ne2fsDx9+jefThnjg+kqwvIKSaGpuXtx/k7JU09mmat ++vytyuN/up6fnFzSkKPTQXmn8ONzRmfTiRf9oqa6puXxBYeam96XjRdshC8sIeinz+WsZ/P1YiaH +PUtK30woLh7bbGbfPl8czzbzb4Cf8+MZ3vpQClitZ8DN2XwDsGbqlgGKq2Fv9tmGXco/x529WJ3N +ToTmz1bHM7ms+AuH1u6eIWP4cjTQWzMZrHx6LGudna7Qxf5itjxF4/nscP4Cbg05hsPlvjp/Nmf7 +zzG9D47vUa0ZutHRjgVFzmR2q6fD8MvN7Oz4a+QF3rv4duaTl67318uTSyTz0UF9crFwMKCKMlm5 +Jpcf6yeLZ3xrddU53KlU68tbf3qRhJRbPhKB7oMi0F3U8tP18qia7fUva6T67kadXfaqejMFK0ZR +RRc0R3qGe4IEGkv/0TI7BsxOnp2/enz2RDD9vghQnwADE90M7SUDfSqItx3GtAvZ5EaRtH56iehf +Lrtyx08r19oV1g4LvLCqT5+fHT05ni8PB7H3wmXcHYTCYcPOmd1FYSIX4pjazYA8dazB+TtGenuX +stmG3nuhDi8uEOML8aXl5f56dSTX79vV+uuBY1wiI+SRU6bqF1c2OlYU5XSpNpg/Xmh73PFBvb4r +Dqd+cyTEr80L56io0xv8p8ow5neK5PmLh6vj1XCjPoA96PaT1UXqyohl7ryM4RzKdaXwgZeXFCe3 +Cg4lRjEMp3TRFUmYuOOO7NZldpOi6SrO2bir+dK+G4Z8cCDcffl0mQXDl7tHV2Z+491KUXWJpNpd +quTuDZtimr8ER/efy1wXu8/pQsKkAvPt/fXqyfz0wfzFYn2RueDc/Sms9uJFTi7FdJUvdbIyiJzo +I9U1rkZyUuMPjveFcU/ozhVQcmfg4zmX4OIIwIu5K3dpzF5f7jTuXOKIO4f/jbD1HI35yjFLF407 +YOy5BPKqKPQyw2Zsr+S291SQvzs/0dDt5WJTLf+lFjCdyU7D0UvFGJyLx+dcgBqdRaeVlkrp7xap +c4yy0ygCDT1nGEFSbe8ss1p7+/HdDz7owr0FLif+6H//8a++fPM3f/rtr9+Zf/HWh+5XH9+88+76 +/aPnbz87/sWH93/x1vVf313O9za/bD/7w3vtf7797mfv/+6h//3bD/7y64fvrs/24/337MPuDeP9 +fzbN5t7f7j17q/nlu+/8795/vfubt042724+sreuvfHuOw9+sS6Nzt79zeHqq3t78deLN++s+v99 +8zefHzwY+vnd8Rtv/b83f9f+59n9e/6Xf7rzt8NfPxQp4/e+e/z3o49uf/rh2Zuj/j48vfPsD//9 +QEb5jf/7/7z7m6/v//Xdtzd7R2/ee+uNs/vX3z94yvXd++ijx3+++/zL3/6iP7y/enpOZ//vV/fm +x+//6f7dpx9+uWvQa2/saPnVe/N5eHJvb+/Xz6Y79svYP317effe8/v3wv/Y2P336tGdwzfefePN +9z7/4g+3P3h8+lxW+stf37/39a/+fv/unf5X3Pdrb9z/xX+99cbd55uPOfnrdw7jH/5+78Pr1+/3 +j9549oXOwTS35u3nn/3187eX//vhgXT7+1/fXD8/PLv17M3w1rt//MsvP3/3N7//9Q== + + + 12/e/eWnXzR/tG989Paz3/3FNQfX/3SyZ/7wuZy+jH3jb3cXv3r4+P2zWx//x+3j/V8fvfnbj+b/ ++e5vlqf7777z6d+Wb/7u0X/fYHNt/NQ9WQ7j7f3iV/3nbfvh8ln76c0//4997xc379x6fnww19V/ +Mf/64bU37j1dvPfk3c9/ff139542f4Y+/Nbp+yf/8eT2u7+5Gf/j3oe/vruPRd648/Hpl8/b/2mf +/UWO6Td/f/fvv99fcKX4q5dv3/w7ut3k1f95de/p45v2nSdvP4/X3rjjv/jw/rvr9fPP/NsP//R7 +INWXXViu2/fe6v/rrQHRpLP3PkI/LX79axpA/tA8+Y8PvDb53cd3An9SXERX77z527Prci73Ds2d +ZvEo/v/svdd28kq3IPoEvMOHyVkBRM45GAMGG7AxJjlhG0zo3X3Tz35mlbKQhAhr9M3Z/9jfAktU +mDVzqBklamXikx0nxUxXAKzdDeDJbi+OSDqTnRA3YikR5KfP1YTpX7iX+xsz+ls3+Of/zOJzcVvy +n8nUCHb9ShRng02oUN71d+hAfxHs0iVnddIs25blXaRrd9wWPc3VLnu/7z5irJWBqDhH9BAvvY7v +lnBqP/bia9hpQfTCDRaMzX+Wr+yRDZn5sDgmPQ8InrmizzuNBm47z1l8QhKKuGswuVKi+OwXTsgf +n381X/If4SGZCudXLLTRXnhgyrc+OoTTIigMFg73Rot64a297QY+vWSEqBX/8uwx0dTNUyEwSdhL +Zs9wg8eDWSTAVJylBPL8wee9RTjVxy9aBU6pwrvPlWaPs02nXrPd2ztH/sMzyJtsgc9UMsYtRQmO +ynOhnmMcgG2uacXSScYJKl128CTOHucM84jwQ/vpOdvN/lbCD9+NbvauV68UFu7COz4Bk012Bou7 +QilbWAhjd7JdauLidiVfQ6vy/RCvbldv+c/tJ1N48z21VNeK3jPZpG+ChACSy8OwzO2rCkwaAIS5 +BxAoFS3kGoMlUXrO0MKufrLdR6u/UPNYnlgm9OvtsotDtO+oANGEqH3+49kci7bsuUH+dVmeUrbo +TwQPAWfZ9JZcO+88T/Z+tojzRWDSxy8eId+fi1MiEeIlUqdUGrvMH+yuEHmYbMUZqDyY6Se8g3Q5 +G34xb7NEah8W3yxOA0/WbMubfkLgv5ULB/6p7/s24bV89rPdrt0rkQskMd3DLI7f1pMAkx/lELPQ +70JbEAw77om24CEjrx44kLcZ2svMEsqR+++n7P1rLc89j2ZfM4lK3g8vvT5ku4WGPUcO92NE8UHx +qfDyT2Yzi9mxzPGkHyZ/PJ8KDBLpu/yvyRbuvL07yelLL0vbzdYi5bK+5MlyvpFBn1LA28gksZjG +0qTXmU8Lf0vJf8G+h/+GvuaoQvo9j3+GvwIm3zeoNnqeZH/NT5BHf8uxg2UTvlI45Ct0qPFwXUSv +JPDL6GtBmCqHXmmKo7CzoPlMNvkQGWHxKeE3cfwKWk0LL0nYbpZdCNoku120pHCrcttFf4vjoaSz +4CGUIOKXrJwUfxVGvJeDEv8ijp7ibaTxACab5HW0PLx15vc93haAcI/hKcySUDm6lO7BpmCWqxwE ++wsELHFsvA0MJZNNDo4k3pX4FQ8mzFxWWUNGE+XwkeCXWRxTHAm7ZPxJGJGdVP7VMFpIzoVFDPR6 +Q9iViCwnASvJ7hRTDksvElLh57tTgJVFKjmlCgBMqmwSQySmPJe0fD158df4qWJS/LJId5Kzkp1p +SsRZDscQJLIqpBIX1tgS2AeLpvgBhiIeVh/QQJVqDEIXYzDQMRSFsVNq7A9vDZMmQOz4sAo0ZI9E +pCF+hR0mQrru8CcW+MJOgSfDf4aYhYfMucIYSRV3tvtQ/y1lHItuoTp/oyTWFnD53yxw8Ubp9XYQ +A6np/0C7ivCy2WdNeNaFZebR0nvPf76MM8XZ8s9usrHiaN+JLkpO+9qV/wjtWqJuohRbkvcYz6OW +ceWW6EytqusZ5P40uLjPBYc+b/Zn1djyahBhQXZANP+x7wzBIPvLSTeUGy+ynd/CXeb+ZTPNfWd+ +SJmVxP62jDTdOVawTDbF2Lnv70mWeXwaxQq1pNmq2Es4Put1suFnb0W2XYk64SlUn7p/2bv3WaO8 +K3yN8PpB55eucfoOqlqxA4pHbao+xKzTygUfqTirg6YYBkzhpd+DzRRNIwXk/vXMFE0jBVniVzNT ++K2xGCExL2AvyMBQMy/Cm0/rK68xu+ulgmtel8GJHSyVW7oYH+ebQHsmR5bbq+j86D1qQFUzm32f +8KTKdReiz7BgdyQURgw7S+N0I0YgYZ+oE8qoqTNEWq27sNhsvIgnt5Jx4bTkcNK3LCRgy7DW3XBu +ceXfP4pbDuOH1CNeCJyLsJToclEPSaiWP40Wh+c9ZFliEkAWSHlpW4AB0U4AVX7TxFvscaVcpmB8 +mGw6RoVk2F2r5Gp9x1kdNVV+9XGvvN98oEnrhUC/koYHbS9tbz62uacrOxFe7qdIijXq07XoAFCj +rDiRjr/mvn8fQCmd2Arc6e8HtuzdOlfJBfc5gvT2tmaeQEZ+OJenl2w0XvfhByy3FNA99RoOd90L +OKZlUOQhzG7tb8u07G44E68PbgD33/8EzIoh2+gue1+ef4HdnNxQmZ45ipdpsiW81sBT0rmnFrlK +1/7GPkp/bPcYypFv/6aCJF8Uwzu0/e3kTp8ZuKXK3CfNrGX5h0svI7elVPzdv8K5YPkjjB0Jzxq1 +XLuVAeE4+GlKzqDdvH/AKMc9EMxxyhdb5auF7z7gRtuX7eZ7veLk9d0jyhxElY9JOpOYvvxmHtse +e+zDc/8J4i/KGo0SQ+uAzVR8hdrG/arKZihzMcW+h0DAyUrZYFJazLUzT+5c2zbaIUbiERkJQTFZ +OycB+7VGOTuukZh7JXyvpRWsoe4vVL/CE7wJZCPzskTfMyBZyKGp3xFMfVocD1F5HtvuIMWw9V4e +hN9g10WKoMrBW+WwbbPrWaRzUF/q3/iVGBkxN0uuQWuXrQ/IOYttyXpzXpj/RL08HjhvsL2fJgr5 +ioXlm76VOeVnvYeczyUZzHY/+u5wfNgogYnunLGDiYKefy8UW7zaFxw8K61A7tvfIWH6+1/EYXih +Hmv2IqPi+MX2BNt8N2f+ci9Owfv0IbCCBvKyIpdHtAr49PIO9v7wU64fYH7+hO10DAygl27j/SP8 +eLu+R+Z6FOtP4pvhBF1cFF/upmPQD+JRmODNVZx5iOds0BltA+o+RtgNcdPTSCD27IXqz+dTLvTQ +92fb7tY7zNLpekplW3kUzi3J+UaqWLHiJhkAtaThBs0l0sGvAC0m7tUWH+narfelscU+QNz3O/cd +sXoLNafLKfXAcwL13bYE3InexN+s9x8qkwZBLnS2RY+beZMqJehM1+PcS+bButsJMzcAGd6BWzK7 +RqmTC3X9Ptkjh5moPpUT3BCcEsEuOXb79fYW+3S0b0H182ZLhUHFrbY18T0Esd+QJz5aPT1rvgSv +PLjDzVn8TvFKfPHiWmLhGGu+xz+L3tWQBGYWIrP3odKo/LNzO9B7XyYby/QPsMiyzNI7dwEmuC0U +p2/jpEQHFV8BFLgD2US0i7PHTEQJfGLrHWJEM9miXxtHXxURb0q3dsSk8oWa+Y1QnSU03N9pD5Dq +BYvZUPqtAbTvrJejolMW/fMsrgeOO12VHFgqydDicQv8vCGqUKLvrTibDBcgC9MR7LWu+5kh8zXL +dgtfHuBK5qXwOlgyt1tfoVrtWzFyFhaJFzAW2sNmtv6Yu5WiZjT7g8jHilUDIdYwzN5P12+8B55K +LnKSvUrNmeSQScXuQgfKObcQL5x+yZe93ztvYGzve7bbtT1KjpiVyNyj3hfSBd175IjuRJeZr0Zp +vLO8iZqLuG5O4eNnKbx1n1/ht5U1tnMOzy+0AW4JzGBbyi9yP8Bcvhmw5GzRwzcTzszGF91n72KJ +Tv523rDkm/kHUpOiI9FVYFacrio+/J4O7QO/eByBaK3e5H48dlJ75la62Ycz/ZRE+xRDYYjhg5LF +trhxyjtEKt8g19x/QG3Vpnh0LP7a9+sF1seIGujQEqsFv/LjjKyA/Re/Tbbc11crA6Zwe4ejYYlK +YVzNPHSrk1L2e4LRxl3c2atmfubavuDvzH2ZWPNrKSeALlDYbz7buLf/SXnbxjLHkZGgF/jzeFbK +z35IKTOr7XfazGw+n3VjzZfpvvT6Qv2U8m9pWoG/Ivay2gX3Q+TaZiFhI5ZPQBF9Z+HNvrYwu/ou +WRp/+wOSl1nULGzd4diL5z73HW57lOdCu35pYB5B4DDZoMOxipKP9UA2Ut7ucr7Ilw8Fj/qZrat/ +U6jXRn8sLUoP7DVYymff1sDlngNMbHpn1/8tuhNf+uso0pQqQCojH/ZdZDvfa7dEfvIKJiNRXjEd +4wBzctZ/AsWpAFy8m/kTsUmwxRjLFljO7TYTK9kmTJrplxGmpw8E9OfsSTDHdwdU8GIxYxZdctbS +jWjlubTDjIKfBUW0gMXVmXjdmn0rvFtGwXBs7c+DjfHpPhjsbbECii88JVxW2xix7QRSMdaaUhr4 +GMjpeyT8n4svX7sZiiNHDikQUU7O7YzdeugnFJUwn8S2hb3I+L3gLUATVCxw0qP3Uj5TBX3b2w0B +ig9rEuJbZovdbDjaeY8GX3M/sMkcoXgFpJjwUvxt35ogt5SLiwJxoKSz3Yf0MpNIrR/BICPsKrMs +ckvHrpYLDm56leRz0KHYqYReZHuVUSA3jtP/nPteVptAG8WV5JgoJrNCtFjjw1K0BWhtGJXuRVXX +5RQZucLLrswJmv7d8l3JSFavHyFW8T0UnSGwxD3N1VfhLVr7Lkzdn7Zo43WTABb2e4M1XKVeg9hD +rJkPgPFRTwRYI5xq3/tKRfLNWYplOzf8cT46wW7uBphkKZsCbsnY1qFCdfJ9IAOo75YLoDNCjqyh +v1Cv3uQV5JPw7luDUobYjeHMf6coLAcyh+ihX0QpoBz6lZP7Ur7jdrpY1T7cDb9IRMKhghkHRvKT +jX48Ny2lQuv2vmRbB98yscfFe4bODYOi0MaCFWEyd9JFzGaJpbk0BkSr72VOwNYw3B1XGJxKIPdR +MswfGS2BRCbemdSfu1aY5SfLgvszMBOJS9iLQFkCoglq0LMsSQXN92rZIOsOmMIL8cr8EdvP/FfG +L9H6CKoFCJ8tzpnitJt9BLn/Hhwti7PQLiPxLbIv3TlGRR8T/gQou29Y5whPKkWpfBntP0AMVh0I +GZ6z4dHAklsWHF/F4WzK+pDBEpeNuALcqfhK2Y55w+V5yIYF26jeLbld5RomAOXTRcwel8Bu2l90 +QBSnKiZbuTsGC5v3f2Io90GnWHuA6a9i4R6IKOnhvD6SuW8f2S0PI91etrNqvKIRi5xqUJpt1eDO +8rFn+eFweSBU27lDMinB9FrzAEj7nlfukmUyCV/JwmzalTSyTu1IH/sA/GUmmd98+w== + + + tjD6HFgwwXH2PlBbbpZtWZgHEX8jXesvUwgUv2ylYqRTEUgFvVycJzzr+FdpnMqCBvDzXVZzpItC +G8f312x+lcy/3QYeeVtylG0lRwin9SQmb28LuekpGQflEt0rbQNhFDgXW8k3BEUmty+5NtWoFBvb +zxawCHKR7N2aKWdXf9tAtmWd3YmQUEwVq00ebgXYSXRZrPOL6678wOsTON8IGCd8TkBIiuLfO2tx +NvXOkUROc3/7ubEj+2SMOFFCBpFRGEjKt0eWeD48Bit4bgfbwTfJrrKLEmN5mQ9Zgy3FjF/i1btK +h4n1e1P8FNB59Fq2AX1zvKZGvKMUCBegxbNPAgwmZhkx8YdRBmZhyeI2Hgj/PCc/w+HA9o3ObmZV +0rOMkTYyFB17ireeaDbi83gBLbrb4ixVgcF69rU12iv2sc6QtDd7TdGJkoovArCX3cqX+hk/bxFV +tp2foFvGP4DVUxFisctEiFrpwU9nm3SGqFVmqZA57yZBYP7cgDTsTXGWj5X+vymhyI1Ct8r8u8OF +P9t/BXzTMJdtyN5odHB/4C9f4R+OMpKbkuQDiYmqTrGkik0+RJXnK/Y1yd2cByMcJvCiTFPF5UPr +yS9/h8sZV+F8/i6/tzv/TLw3lS/8q/4u/6HOTZKKP0ITIB+r/6l8zhcKuAHmTf7X4nb/vftcfy+y +B1caCfdFhcRNtT7/9+Ibxn9bHMyarVKE3ouyewcBlNmq2Ll18jvnKgn0rh5kf9RAecmwWvwjfI3x +QUKtbCbyX7F1f/JU7K+OzyWFE17eHZc53ZXWJ6u/cq9Iypbc7YruIkTVOllZ1XFYhs3wDpvPHOC6 +hOW0LvzC7+ZRdUKeq07oyKoT1As0ZIgPA+jdKSm7AxFB7uge5a+J0JLDAb1zBBDsQDqQOL49dghj ++4v++12Jd7qhkkhU8YGuDDlgBvweFRfAHQJL+2hIxYGrjIWf3z+UUTUcuoH4MLEcHhZ/pos5CyPF +IuAhuvWyvtgoMRqe9Cfrw9db72/ypGz4W6FbUF3QYe0YGmCzmH1uD0kIHnUXAAThSjJa/A3utyeO +Rkm29jtbiVeJkrLB/vfu7rc1kVy/pMv5st/f9wuUdi6pLxaBhIQEvtx5PVEmvHObZasSdyprAYn0 ++IGqI1Dunvbj2xUq/h1vF++IhyrRRfnaGjYm3F56IE7iQrdCeec+hHRsRz8EHv6ZCdcJSP+imkHv +SYVew570wzRABDy3Pk/6Y0ejT1Qw0Y7RwoO28Ak/iNPp7i4HBmB5iUK6E5QZnRKegs7fYT7Mrte3 +iNlT/gMt2+zL0kOzbUHWzZ6ZP2/21aJ9sye1rPnpRhQ+lM324Ja2tvH0wfTda4qovNbSaHFcluVi +k9sXPbeNRzD2zPf808LSH9iGKtHXbjkJVuljbtHJBLbvidiodRstDAvpj3iajPhzrh/7fX5U/S4U +n149E9KdDf+CluJqc5OesDWAGLs5upI0+wKODtpGwuxqDqNm78cn3rXf7NnH7s3e237B7CNuKSKQ +HDjx1rhJqe0tXjzeKZ1DLVWHzM8Qx9fCjzQxx+fCPScq40V+s0klp1nvulnL1KPbVKSSePSXVsPg +Q3HzPCQKw9KgW0pmkzPl1vI+d56YO57yPFCdP+jpGq8GtDlYWZA9stxq22Q/ceBobDebYOGTCPSX +YeUrCASb58lTEM4vsufOj98VHEmkTO0Hr1P4Wv6GWeb2QUE6bHzb34xchVsiELx3Ss8cdgq/9QyD +N1TMDT8j8V7uJJOOekxBbVKTDU8batPLDZ5WZdLXzehv19OYND9lOhMfpTrpNvJI4knRuRzstRKM +2rJL9UkTN/atw7paq0262b/6rc6ptfOsmJTDMU+CaqjuFSZlLJaHYTOkPmlwMCRKOeZOdac3pa+I +9ZeOt/C5HOyVKL3NKpqT2qngoKg16ZwolzcDxaQwCwvg0l+PynenaNLg6uBUHT8xbtKWw6FAJXrz +gGwQmBSwe1qUn+nTZlR4QHuBaV2HpxocBXf+nk990nWlpjkp0yTiFsWkaBZu2tnmJUL21SdtFt2W +P2Z/qzbp1rLOlbQmraSpX3KIaV9lr0HXwBP/7jXVJgVUSrrcmUf3RG1SohQtphSTchwGn6r1/mET +15h0MCJKo0pHdac3pW3ctgw83KtOWvbum0CV6ntlLI7Fe+ZOfdKEOQDmTsuKJnUfgLddcqfDGTMC +b3iNJzXZJNM2wrkBN+nA51RMytw3lg/spMXnZUm202GGaDwVQ6qT3lT+wPYNLy1tRpxWMumte/Op +OWlmOc5nNSZ9chH3scVWnBTXtAnT1n3P9fnCu1Od9H6cjmtO2nyu1HJak+YBkx8c/Yj6XhuW/f37 +dB5RnfShQa40J+2VA+VvcVLAMdm0deJhTWc0Jk27Hl4eX7Oqkz6mp27NSUEzGmd3jxp7fQ4So7uu +S33S5t37V7+QcKtOOtr52+KkcC7yaX9aHntfa9ISMW7/JdQnvcu4Nk/ZbV5tUjiX4peP0dhrpGJ+ +bBINdtLJza4sJ5r0Zv/4FESTeg6I5s4Sd73sf8YwaXJjsin3+uruWLlJl1G3bNLQh5245SQN5Ug5 +K/JJ/Zvte82CJvUpJjXZgEE0/OZnC1OCaTPbA6n6vIqyk6adRa8CvOZs6c7BTjraxWpyRtjzxCvJ +Gpo0gHBMyQp7pC/csH/BpKW9ctLNZ9rFTRpr++U7rfRyNnsCT0qne42GOKnJBnu1PG1D06cWmpY4 +ZPpR+01/167CpNQBd95kp789j41OqD/NRRyDXuO5hiXy4fP9xJwgqs+encZTR4qcbFsWtadwAiWv +2ZazFtBTNQ5Tmf4y4ZKVRM8P0Oam8rFmfh0MrfH0dxO+G1VCak/R6Vd2uwiZGobVf121mzN3j8W2 +xtNdvF6tWbbqT+vEqOHxhPYsxFSeM+NmJrV3aDytv7Vi4Qef6tNIc0i6nOmnEXrqVYFYg7AKZ6nE +eXjK2HuTp2JK42nC+ZBPPGbUniKINXLuR+vmM6fx64p3nGe6z+pPb7Olr6SLdqk/bXY+vrbjooeF +mMrz/tcPvQ1QGk9//la+5SKi/nQwavG6M/dUDrGR+wnjt/qvx38PPD9UeTrpU8kbb7ikBbFFv1na +3dwt1H/9Row+HF/VG9Wntsf2/MFpbqbVnm42yXGbzrSdThZi/sPnVK561879oKeBQ4of/2zNI0dB +fJpauxJrwQpcYzaTilasX5z9AsZZK48Mtg5wpUZYy/TmjGt3PU6avYXOo9n78AK25njeNTufXHv0 +qYVsUjCy6+OQxHpLJVdLvJf7DJ5RnDtwG/l1gCnY3yOO7gT2+JYQJrUEPpNTF+hoN8VtpBWQc77N +DeVItnysaovsHJk+lrLQiIXXfrAYQZbOUmS40kmDrmftSW9KLz61STkrCVs6Ei4vnRRUW7B0xhqT +Dl50Ji2bQwpMlu4VWzrCpLRs0kgFaf/P/KTlbzl4R9JJg/dWPKnJxgG4nelI9jq32y3ipFj715g0 +9IG0/7X6pMHBAE8q6GP8tDyA3wnNSbH2rzEpY0Ha/1QxKfYqsNNO1PbKA5iIaU6KdQrNSZFG0RP1 +MSWAvTqTlqp2BSqRXtAW8PT4E3cMzf384PTV37yzLIyMeHOXNGu+B6cvvLnZj5c2Cb9Au5Y5xKSE +C7/2OiVuGfiURxpcFYOFhyxH7yZbKlq+6wCUb73cP2miKprrnNco6O1Iqall/5H6jyadHCwztkqt +nfOukjHB9DmTLfCxKOB/LMIEbjXnF6zmqUC6c18l9Aot8z0B00ulijbJP6wji9OY2+j0pZ67Nlro +H/8St2FxyUQtZLPhfxAyyEwFbl13wg4KntSUrnCeqwPIl3st+GpHTo29W7EolSVt9ZcU+LTEvCb2 +PyxEVT2hLNAbe02gCyDH/3SkVjW/P54n4x2myXpDgiKq+8P/TPoF/fOj0w/dW/H8RItPfoLeWw5j +WJtGdX9xt9Hz4z0k2idYvv89DVgqQ8Es3GAP2uh+ErITb46/vgLunB/mZMxakROro3KMcni4o1l0 +IB+4DuVg7+h0ezawFKxn4P1Vsp7ic34NfEwygbD/E0/jpUgWR9uyMACtAKCJB2G5bueUMhXYFZ/v +drqrwTLAi/55krpNVaiyiKzguhrj1qJKl+bWaGu83hC3pkWVR7b2bDkOaDtLQ6ysVFsKsZiMe0d3 +5bLjXakj+8C7FsUECzHlaRnbUMEvw3OBDGV4TixafjvCMam2fic5plT5+e8kwKiC5S3m5D29h4C5 +awtoI0ppj85gef+T5lCsdqE3mILuptRKSXeTm8aRPZsM0t2kJLyiSnfAs4pe9h/urEhJPEuOyVP6 +xsiBon846YPd0Cq4Mbm5JcWhZOeCngc+Vp7k4cpif+oIO6X+qNwwWlPfpDfnxOqXySbXwvSOZBlZ +K44Eftvb6HJalvWwp6/KfITXywgwJQ2F4LjGKEYT4PV5Wc5XDwWT3vlKX15G9gqxJOhjMv3JgPYE +i5+a9YGF9seKQUlcTGVR0RtNWSmuxsCS8Ol/WLQWlRFp1sj5aSl0WOdHbHa8d+ifoHh+CpXOwPkJ +nP/gBDeCsLoYGTboXByT4nUG07Q7BLl/ymAnY7wOxI7pdSdBTM5rLxpMztFOhhjn1+IQjcr1Bz65 +4VpBpFLUtEpMNuPa8S6l5BzaCq0WH3uvGFew1TWFitISv4Aq3yvUaJ+rn2AoB1daOLZL286Ejrga +kUfwGuwZ0Cm3foyaCpp7SW2PMQUjC3kQrKTjS9FcyDEuwC9EW7esHOiWZy2Eg5hR2xDpUS5VqZnr +j4P6qGI6sA3ZsKTg5Jbmc8VwmLsjdWw7CzsDuGiSTiB3awjQqSIDt3zMqSFhHmzCggSAOLsDL6qo +LeNV7WHtJR0yALm9b5gBfFVPYgAmm9oOhf3Zr7M/RC+x9u0lQBfxQFNTMNnUsVZDl6dG2w/y9P1x +ceSDEywP1qf4M7Rs8q8q8UbeDOSWxfnA0pfrppOAFToTGVieLCfx5O6AxMna3oCRpuldknhIakoS +P92XAHqyVW01SLs41aigrTG//bgjQOJlxFEeVVKqKTX4s7bmFGn/mINDSwTVDsSyhnvDZNNzcPzU +iMV2+Xjhhmp7gJiul86A34e2Rv+C+hhoMgiY8eYUz6PSXyNyfoCOjsdGjRXIPA1yVRqlKxOiKs16 +retKZfrYBBqqNLB3yzF6OQ67umZMSl8MqnkU13W5INTACJkmrLW1K9BLXSkBtfDcZNPB9FjbLBd/ +5+B5umdDnl6DHk6ds1KIPC1fn66Hc13H8u4SBsBqF+Zj7kJjuiyCTtgQJhvTZV1Ojzx/A3bVv9ek +OsHiM2rCAhM+nfPJc+HQrhaTsU8fI4xKOzRUwBi9HPe3osGIy3lyHuCZ2V/ii8fngs/NkNDTw3g8 +ijxSKImKnjjOMQpUG0WaocqPc3GkAo8ilXsyu9Kg5JMNJo8Pagwl8VzpucXL979KfQ== + + + E/3NaIRB5JZafi802KXihrcr8WpR2OeUGJ8mKLsKUGqfizTMrcfR3CocrafgaPL8sdM42sPKKEdj +z0VVyiG1MnAdjoZuLd0uSSMC0whH2y6pyzWlPBgI9zeX037vKhytp+Bo2jh2fBzjHE1iiauMczlH +62GOJs8ikIVeiMWuF+CwSF0XkB9YnNC0oJGmJAkdqmspHDJwC3GAAZxyK5K6cOKD5sZPyrnqP5xp +Rstjr3CglwRylUMJTFY3vn9cq0eDKbIf1IYyHVGmUabOEaPRADEj6/W54Ll4HDSKthpnsp0yjuEU +CMUoEj8MHucIEza4GiXlHER4dVVyxWCGvX58/pieNPSqSMPHk6xqLCs1peHz38WeDWRhkccsPsP6 +PQxGG8MxA9IQBjuDfGR1SfhUJzcL66X8/lEhC8+VYo+a+v1pUuzxTP3+cJTnPyO5cMfHGWsmkrCy +0GQzLA0nN7eUJhnqy0KTTU0aoqRwr0IaHuS+nJAEqNSU+nrSUJqHJaZhaO4e1vWyl0cSpSuTKRYi +QWp4LJCpoKpRSm1k49QdcxoiSBXaPvQqwGAhA4MZwBeA2K9NG2InGZd9Azqv6Wj8FIhBz3VtKDNP +9PTiRWmrrAZUTYVY8otiSTLL4EruXmRSKsSSXOvjc9d0MtekRzIQc+n1QSnNUtNGllx/qW8bGc+2 +RYP9GRAt2gn1sqF2tit5SAaG/MlwkqLc18pChLM0lHzLoYWqigF7ecv7A/JsKdVsRjF/7siSVNzC +IiYfJy/OAyRqlGxSuMp80mo5Z8caNtnM3o+ve1Qb1zD7Ir7xmTV0+hV0uFL4CjV03HwaFXQcxC6u +odOvoMN3qlyhhk51UqGCjrf4Lq2h06+g4+9UubSGTnVSoYKOt18uraHTr6DjqwUvraHTr6DTrBY8 +sYZO/z2T7To1dPoVdCqVXGfV0OnnQwvxygtr6BQJyQp5LZfILfvagNkr1eu064Ayf3IpdsKi5Eva +HCt7S06dkiw17Yqp6+SvIm7ZshvJCTVSK+DOtlRzySVRHoNwchzJMxPhJL0fRg1OSkGvTC1CMt5Y +EZ5HEeO7BJ/iXv39mVR3qLo/lco5o/uT+pTQovynA119SbJQDs5PPhfo2g7k4/RirGhOX21WoKtW +tu3Au7nU61cUWasoKw0lgxyewUvRQGzOZMxtPPAZKiXS2hpL+0WjySD6xW6aqSDyTMhjxW5HAv9G +PL3Fa7iqUH2ans5vHDA6AQcNM0Qbk9cGKrS0bRp5ChboY5ObskeuRJSO2eQG2cPkpq/jUzJi9kqW +dLzE1GSwyHRS0otlH3OcKT29Jd3EACOOM7nb0MNxGJn/fl6+XgGRpLBfflfnqXVggGNPO31N8JQ6 +Prm75VAiHWGt0jq+o7rX7Up0WuksaZeuKZYksfeNFBdKlqSdAy8cnXB+R+r4rMdk7gl1fL+aweST +6LOsWRMj1S1PGOzILQjKoYSbWlUHO3ILguF14djrkaz6UzapXjFzJsS0QyFnQOzIVQj665I4fjFP +Dm8OUp12qaP3ixjRZd8r2OerWzEkELvmEMfKFrkBNONi75WjDKdLsv8c4c67tNVkpMTNgLGncO0q +DlGIJnBqgqoqRuUGN3aDpr6GDxYVYhm2WjRgcqxQzmTkkJWREW2LR6PAzRDtH4Nnf6wdYjywKzXB +cZJ4U4tJsBymYoDOjeqR1Gg79cu1yCp747R2XeyBHqld6fOrXQKvxGTd8qNj5XFyriNRIBWx16/q +lcqTYUk2HX3sNIof7ZxGyNV0tL7AWXScCSdFfvJX9UT3zqmVcfLqp6OL4srZTvLIwJKEO7sOFkVf +DCduSco7Vc6H05GiOKXnSrYouUcmTda2Co8MbY2u9dPWlTimVZ5D1i9yW+DCJgSxs8pzDs/gp6bp +kZH7LgyU55B1x+lbU9qVtcs9MqgMTeGROec+JVSGdiSdQ7Eh1YrU2jU8Mqj+jPfIaHnhjAHGaHEO +n6ekWZ4D0GEuSCnhT58n+8z+oA411jYfy5Qzoiyv69eoSUz3SP3MLYvk1iZ9q6V+yb1hCom8rhvI +nT26taRLsTWJR9Eghq7rp98bdngnJDpzndQF43V1QYV2cWZdnfHcdU0rCdXVGSgh0SodlcMGWRaa +TtCjxXWKRD2Y2eJQxFFxv5kjOYrGYmVH6+EM3dd3cT2cLD9ZqIi7dj3cuTh2Wj2cdobqNevhLs9Q +NVIPZ6Ai9Qr1cGK14GWV4LIlHbi9VbmlxmDn18MJVWmnlWqcWA+ndw/J9erh2HNRVsRdux6OnUVZ +EXdmWAd5UlQ50en1YiX9Pat6GVV1y/zBJcPn50TiLInLab9nQH83HQ0dAhu6+BpS7IdB41x6rQUe +RWE8a9SJGxjnrBp7RSUXGsdYKO84R+uJRKh6m9bpGc8eBRlyJWw8EWpnERgiQzgIIxVRpuO1TJdd +BCzxKKLBHsxXIsPi80CZMn26Ng7wPtmMVrmhHaT4FW4DxqPwRHi+9YrH0SLDE+7uYMe58KoLPArK +tb6Kas8uSX7BzOHdgydcMYP251H4sNDfjtYkGjOpUQ3SNSpSn/+uVpEKQ12vIvX57yoVqeSNkaKb +oxWpk5tb78XjoFG0+eYJFakwzrmVpLKKVBjnyIUiBlejvA9AavEZqOVWEIjmpamKJCONag4lGcac +3gMyjDmPCDCj2bbXKoXjpJhYDHdmRo98k0rf6dl3QZ9UCmc6Wuh6jVI4EWK/J/U2OK0UTseu1GBc +55TCaXsVrlkKx+r8kmI4YZajpXBGFcO8X6+2+sQb4VFdnSxBQhEZOb2u7tSIjfa5DK7WeKKP7rc0 +cpGhER1mupVfRK4ZSzLAifP+gGZSreY1wQfV6CjzQFvInCgcUFUdwghJ1s1ZOaicB6jN9oxTRWcx +4w43uQy/Pb2FC8PSw30msMs1ipuX5DjZLSzJfC5QeyxYFrX7Qtpz302uXj0MfCq34D1HvtR/Ls0p +R+qmwAoj7O6V+JMFn5Ks2K2ZllZjKYrdLA+DltR9JSsAS8XyTwO1qjNUYRd09TXrzjb71xipOSlR +Ity3GpMyFmu44xppVtgNdCvs1rT2pGXLsKc2KVdh56hO/e9a1VgunWK3VoiSTCovANs6wvaNRFNS +FruhJpffGnVnLp0Ku5vSxK82qdCPr54QT/Wg2C3YLLxqFbuN9drFWRmZB15RYVduW4Yak0YqtrvP +24nWpB3dfnzN+oMmgIlisVeSn6qVva6A/8RV4u3dyYDaewjHFG/SecLAiMSrO5Y18J4nttoVpff0 +wq4HQaUqKoRwVMRpXi/nXppyq3GXmlyDBaCGXPIYUeGk9Cb9PlZJA1c1H2n6hZfEzqJ3mbjh0p68 +dj6pWs7VZZ3k1LTfg9sbLu4kJzk6QdZrdcozDCf5pWdHc650+qIRWveIq+b16fZ9u0ITOX6og+Rp +pTZuFA9WR5uNSPeHb6DSXNSRXgOGl2Sgz8gxoPNL0kmlPI1eVsfuy1dLdgVlSqb1XaWaTiuacN1q +OjVt22S7djWdmsNLxdN7YTWdWi2d1s2T51fTqSWAqOcoXlJNJz0rPox95K6bM6rpTvZan1VNp43J +16ymU6ulO8yCvrSaTu0EOA5zxWo6NbtZrYL7smo65boQG9WOvZ5bTadWS6dfM3JONZ1CuQlIOuRe +sZpO7XSV9v7l1XQisERa0+qXdH41nYAlklo6iUS+UjWd2vkJOSRXq6ZTq6U70JQurqZTG4rLubpi +NZ12hPea1XRq9TSXQOyYTngSxE6sptOH2LWq6dRq6dBerltNp0ZX0r4816mm08yGumo13bGaketU +06nVfh1YrxdX06nV0qnEki6splM7IUWu9RWq6QzR/sXVdGrAkEfer1FNp1ZLZ+AOIq3wAVqSQQNQ +HhlRFO84Cxtl493R9v2IiqFWRqeSne4smk9hONqFTyK3MKRdnNSvTk3hMaBdnNivTi19QtKP70i/ +OqNwUutsq8iDNQino4qFAgU07iFBrdw0O9GeuiSUQXQ6XqouSVf6mE5Z1DENQHNJMg6DW95pp1Kc +BqfFzjCH6WhZRCqR55+aXCSoxSsNucHObXMnh5hGo7vTVXJFmztjfUYubXOn2y2Lb3R3SdEjJuGL +85MNtbk7mp+MCukuLikz2Qw0ujMGGJ3iBtVOE1ppCme3ueNlZV6v0R1fVHW2V0iq9dHpnsdyITKs +61ers0jH2oaKXwWVG99wqK50w9Zizou3hkWnVq6C8UI6I912juRa10+6hl9zQyjb1lj2rw7hovpC +rbQe41VpCDCXFL9KMyHrBotgDNYTtX5EQ1nsY9X60RR1pwg6VK7mV57kGdnp99fMhrq/XjbUvcFs +qCOZ4a0fzUSo0yofXSeFQhSj8PY+Gufimlp2FBWRJ+eWBsfRpUDDfRJd12k0yQ6FdNXj3NJgYa3K +BcXwt+TmSrcCosHy+sUrNpPhihMYjDLUY0jiLlJ0AJEC82vhNlSjLDEk9TKoQVtzoUiiPIca/nqk +SZPBQoaeqLpfUpnysLpiB8OH1RU7GD6sLr4gAEFbtdHQ6ZWPcffp6u5hj6GDe4rPKh2AUSQh4rMr +uA8vKNYZBdkvOuPICyuMN+I5sCwwgRgtZTBUyOD4cyuIkNXHjhyEQTLU7nB3Un3l2R3u1GvfrtS3 +Wuhwd5k2brTDnYHKxyt0uGM75V2cY3Gkw91pnfKuUpek0uPu9PoQYShSwWFOG+yMDncqWTdG6yfI +G8MA1ONjugkbJ6k5uPZtbKC5qqHC2snNVNVhcFqv58cz76c6qHy8RmEtGkXmzTov5wqNc4pprXVH +Nx7n8sJaNIrevXCn1bc/6gaiM4hbnljf7lMhw76+X8tkM06GMafBkpWDIiY1KTbe6FhbJxYx9bHZ +LjuXsy+eg8F0zXbhVnNDhnv/zCImdYjpW+/Gi5hiTj9HLyeVMSkYF8DzQZsxixhhMrwogxihqhgK +nb5F1TDv9x3UuOb9R3t+6ymG8k5512v3mOt/mLUjI6fWuOb92v1XxYgNlwt3rMY17zdULK6VsyHL +iIDBLnJPSiEmy964sFOesUuqLFy0WkM8oCZ5F7Z7FC0LvKgr1LiK1EsESmOfeg4JX2i2yG82adLG +Ful10+FBYVgadAvD4iaTrTDdWj7nn+XzuUAdpXHer3nBY/uWL47zLqHKKUwvfB+23vr7Sb35W8L8 +pNPmrh1rSbFSVg/nic/ubuWZ9vI+bLaEeaXVcU678m97U5oHFJPi+/mF2r9urq0xKWORVYkpJ33V +a3Pni8o8V8o+bDHPVphUWZoW7H804hqVfzdORWkae+usUOVIqpbhsQBOxH+0O87p9NYLDp5MNr3a +vx/tgkOitOp2NSe1NxYfc3FS2Its2oVOlWOz3deetNh8KmuC12STNS9U7rV9cKpAmtz0+BOH5zH9 +9xAf496MGxox+Nww9p6rxb7H1yZQDUZF7eRJt7T/VopOwU+sxo7UpJ2yo4FcW/Uc3g== + + + L9eyr05Pm1TvYnYsFUbpIdGu/vkTb5+7JJcTlnQ8EdNkOx7qKhhNrTLQmeWpcHFqFQ8nhzIBTScT +Uh9OaqlVZ1alnZRapVuVdixH0zg+rTRR87TcnsIp7Q8kS1KxLNCijGYJH1vSWBFLOh/oBrK0DNKL +LE9LYWazqzm0c5Q3hPhXB+xq4F1fw8f8UlT2TDnDB2v01jgjvZ+KF8etRQ7zUrw4ygNbe77cP/ZS +PNOvJfePwZlfHLJW8ywfcEtjVYAnXkKrJitRFeCVrmxEQ+X9T5p+GMMtuXmlekqtlDWzk5vG37Fo +tSEOM6X217KRL3YGS/z8Jd2sudMcAegSMkrh5z/15iG5T4W9GUKWQFA+9PNfUN2mo7cZuSNC8voy +sru4kIyLIx/cP3ZJjdWh8ibvX6nwxmpXty007zkwpI1LF6Xg91qlgAbOD+WOSvn9BaWcUe3GW8Kd +kIZLAR98pyODRpcZGOxoBy3j65LcRHH5YNrxwTMgptrf51yIHS0MMr4u+poQC+pATByHG0xDP7yk +o56k/uWMKkCjNYAoXnl+FaDRGkCT7ZIqwHP8yadXASpRQKsGULUDu+EqQE07QCsb6qwqQKM1gEKm +yllVgEbhycvK86oAFZSjiW0aNrLBKkCjNYAqNrJ+FSC3moNdKbQneVM+FseqJ91adXpTPlVM1q3a +Oqcpn5plcf2mfDpeOMOFw8eb8mE/vxE4XdSUT9T6/sumfEe8cFdqyqdTM3LFpnyHt5r/F035VO8b +14NTI/ispTv3jN0NdUFfP30rl60auLyv3xXvhtLp63fq3VDn9fVTbu0Kd0Op9PXT9wqp68mn9/VT +P6tr3A0l7eun7y7Tr6803tfvWObwdfr68USq3tVP55bmExy66/oV+osZ6Oun73OQVXJdqxDpoKvf +Wf0rVfr6ne63PKevn2rVneBx0u3OcEJfP33C1c5QPa2vn+YJHeYonnlxNoKOfsWM6Qj9Gu3rp4/n +Cn3s7L5+hqvSLurrJ3lZpaufhp//uN6q6Ot3Lo6d1tdPK2Hq/jo171xfPyP1Ypf39dMfRezHdzEF +6nT1U0aszu3rp5/mpncLzSl9/fQtNc1c6xP7+umVp9z/GuxkdLSvX0q3q5/yXM7t65fS7eqn4ofR +TbheaPT1O70q7Zy+fmrMQ7zw+Yhuabiv3+W0b6Svn8F+fJfXPeh09Tu5H99ZVwqo9OO7vO7hoKuf +IsZ3dl8/tdiVGOE0GdTlj/X1U984T4RCX54L+/oZqEq7Ql8/vn5LvaufHh87pa/f6dr4OX391MoR +RSK8sB/f8ct0DPbju/RmD74f3zX6+un7v4TKlAv7+p1zo87pff30DWrFDYdn9/WT7fmgq5+K9XpW +Xz99Ncd0pb5+x25tuk5fP/2ufqf14zuXbyr78Z1bPysfRWk+nZFzpdLX71gxPNIurtHXTz87h4sm +XNzXT7cYvn/YzeSSmietrn6sFLu8r5++2c7eA395Xz99s521Xy7v68dDTL2r3xl2pWpfP027Uisq +elZfP70lPf8ZvG3ekGKo3dXvSK2o4b5++uWPJhWBck5fP/2CWFV97Iy+flrnwnb1O+5RNNbXT78g +9iQdRqevn35w4fB2oPP6+inpU97VTz/f0nhfP32MUHhHde9KaQT9B8KhEdSp6mblgtAvSfMSUwdt +jS4DCteubgxTNfFe2l9MXriozBKW+7DsMrJ3/kgdXpgxCw1BUJGAWCnciEjd3XJbFFWEmZ1Prr3Z +F3Dc+ulG1Mq/0thuNtQ2a3a/b9oBny1mpx9vQ9kQ49l+VAOr/cRRWUSiJps7/WQd3pirO5c5W+oE +bgYvTMx6/2gp2Ja/9w3H4mPtY+4bf+Pwct54zyxfmx/1xX002nyu/D3ck+v62/1H+/O7Vw7c7h/G +ZZdzPM57XF+D0NfdT8sTf1t7hpmdybax3Tsdmw1tNd+sFquAjbB+xF3DxuzBE/XcOlN/1p8GMbf9 +FjabdKxldo/Kt2Yqd/ftic+CGaJEpFNEqftYIsqWVZMo3zU/NpvPtG+z/0g5tg5vc4o2bub68Xni +qb+iJxlpPqEjMeOyN6L4EB5vtu81CxG4W6jydu5ccHVparsrDEvZRimZTc7EFpC4VNNkczlyfx11 +YH2TwfuPnvVvk/llmubHZt2jvdP9q9/qttv6LWsk/p2zte7LNcfrfTUZjNpvGbEiNfQBB/Vc9IUb +9i9ADE9pe1Oq+sybz1EAFXB2QLTcbeTUlJeSz6vtW+ZZRcoE523NIarkNyfKHykk0mFHzL6igsXH +3N9DJrBzFzzR4DSQK1KVDPzttpZ563Wb2Qrz2vREQ8l0KWrtzPOjmqWCd0rlBp4ip/WxvfBS5Ucn +irA4PQWvbV9yVqpVsvgSS+Q/JwESHc5vcbb8ixKB/tJHjStzLxGY/PmQjLeijAgf+i0IzORqSad7 +N34crBFvnbU4sDFEBEJBF/4KEMus4GvMg78COXf+4GvGx34dbRde/Im2JhKvpbHrqU68vWTeM/GG +eQOrrjs9xYd+JVt/fBwRc6czZrJxC03F3NmfVWOLH0l3kMp4xQcgthop/kHJL3nwYqbHeD7Su86L +85EYLCYbC5hy7g85b5tuCbDKPeeUf73plT54D86FB35cHElWrBkCw46s+Eo0ekBi2JGVdIfG59KW +jj199yBlpO1lX5pZwzEObYABYowhZ74kiV4JoOqnH3KWrkbQV27YWbuHZmmjstSEBUHWg/MuNjb2 +BF2+ILr+o+sTJ6Vc6UwczRJH9912ct/+d3e2NXtrFOpV871o7xP8rYB5ueOI9R5Jogk5ylUpJS4e +UTpeu5HE45lsaMRcaNeyLsqjYeQ9e7+3fhaH8xaBdkUKyPIKVvdLhjv4wQtdKlK3CE7doGTjhXR4 +xh/Yow8DkCq08wF8Lo8B1pCGTzD2dORCn0hOvIcesXRaoU+08CnIDlGM/zDwdciNOJ7hgx8G+N8O +CSEqGhqSkvW8Ui+f/HqGtPRBYWnlqHL5FeL3MuQqcwmXNUJQ3/e2ojfqesnEiQeryEYwVTq5S1XZ +DYn/cMEVTl6nQiO/OCltd90hoI7gn8GjE30ihU+U9L3b9yDeyyiosp526fVhkC94Iq5SqXj7EOFE +9e4nRCymMQZzE4H2h1LFASkEklLj5NqGLAuec2LGdiLfDAUT8ClRywS26zRmnoX9pHWn4JtgWWDO +qWg8zB1e7Ye1xUCyuVjCntzUMKvz8K88/CHE9iMYI2A9b9HTgICazzgRHOX0hkgn5sm4kSh8DbtZ +ljm5uQ/isZFR+McdPLBMXKGOVLEh8IOHDXZBwD/hBCtz3nqxJw2fErDUZ+Xpowek1/ERQGzPJWFC +3ugOucrrHunfGh7EN+osTpPe92SgUEusCMxVTTaRryIN7zv3ffNbIn3W6ofAD10YN1gWVm7c+KmC +78lDBMoZDzq1W9xMmpMV5RIWDi5OVpQbASI0rbP1L02CY59MQxybYv82fbH5DOh/rMaIzkXUYEXX +piTfckJWMo4isMz3oiftiqfRkpOUK8NEEHL2uGGTg3sJNYkOuNRgRAQ+p08VAmQKSZbzpShtfxze +amV2SdyqP0Oq6GaKRG35VDtn5vJ3AJj6GvYCpsaCBoR1pqjCTyWmapJIVFtXJEpn3b4ysVj2COr1 +8bMX+HizJZCwesW4j9dKunPzAot83H19gkMMtvmSorPNdg0lGgfZmYvmROjYzJQ9BMrGT5qcZdIx +tZk5L5xibnFmQPGvAkzfAONk8Ab6yipZoFzfLxMdVRPl5NiLiUbg05JPI5wOg3zJBVYNojZolDhX +K9e+OKgip3Cw44b0fjiAwsh5Fd3pzhiAttBnhKJogDeYbrVBRwJv2v5pnWvCW9xz4HYURtYimYHf +mmM8jj12DOAYYHe50YAfJuD1NBWgYFhPms4m0sxJ2A17AfwOUM73nyLp/YsawTFYfL5AFelunLYn +GNRxLw9U4rQNT8exjyBaBRzjxr04dtJmphb4LHeK6KQjCFUiaME1zrMK58z6kzVP2o5oowCHM4oB +Y+4USG/svaHuaJcTc+HHXaJcHV8NAxrv5RRQAzmT0z/rLb7a0eh2AZPtiVwp8DmAhYJaGVTbsAHE +JmdP0QbyWNBqM6vcDoRBfd2ZUYTX2K6BDh47QEMkvDzeAhlWaThuZy/Nua/0ZuayCEAD/MkSbw9E +E1TonIP0LDug2jd+gkcRO46Yp7lAvTZfk0CG9TtAbE+SqG13AxGxUZ93TRaWn6cAYttbkHw1LzCF +cIbOgppyHMeeETHH6ezr6x3gWASsV8RXMlQhY6YM4Zgl4SCnjU6WGj/5goHbN2cUQL6uIcXhRRPk +XC4cbaejRdhrqUBnb19iJwEdHzex2HUSZPkPqCTXv/cpNi7lY1Jvz0EohPPIKFsoY3UwGfjCTitk +z1eIxU0oIO4F/81kswWbhTbnA0luPFJQ4yES6XvJENVnr18+xEeqN3aj0qzODvl9erL7dlhfkAXf +dBTZs14j+5CqSVCJvVsocScO0T4cYm+RDlCxV0RPGIKIg5OVWH8CJbFJAdNIgdLmrXjQJ7/wt4Dw +N9CovPegZ+2cG1bVJJz+oURn4veM78h65a+CSlJYU7r9xY+cU2vnGfTWYFl5SxRnfKANBV0j7CYS +74vi/UOuAXpg4bxH372mCBZcM2L/4c4l56oLbpnKyH/z1cMeGeTKQeppa4VX43Kmn75l3ryUm4UY +Hb5bcjcdUXsSTXqDH8As6IIw5P644dcjuSzJLQHC04ae8kCIkSIIXPnh/IUHgd8nA0HwD4PAZENj +v0iBQL23BSAMpUCA1Ui9RrvU3zEQTBJNDALAMbQe+umbjCiLyiSTctc9jUQg6ILAL+J+37wKFBEf +Q0DY5AZPxvAA59JjxN6bRRCYg9snuwCCvgIP5De2oQwjHpWetVBJOYRsgMFaDRfh9A1iI3u763lr +4KPVOBp22TamW02SMtmMbePjjNNQUOWzCMyzcLo1/lMfgIcDSy96kGgttke34bZKBkjn/1ayAVZm +fKOOziqOgbK1ueEHGPyIAxCV28FMDrHBs4C/A8nBE6VRRaUJzmU4hvN3L8GxxU5zAAmO6Q7xbb4Y +xx5+L8SxwUp/ABbHdIeYbo4jyFAPQT52Ehw76zRay72BAbB2oTXEYGyAXPXWMJhKpdhZ2xgsNEB5 +eJxCLElxGoOP4xSvv4alBLFZiJ28jd/9SVjJaReyITYX0QYMsL9RrIGHmGHaGFosx9ZAbZ/FAcyO +h497uUSeTi+UAdPFn9oaTDb9VciG+DCMVIo1CNxyutxeRp/T350mKEVuqSuJpn9GSFyXW073ZumI +M8uN7KvdIvvqskq/Lj/+ZF+XG9nX360cYsu/nez5bi/9+m2RLeTbLlvIt0u2kG+vlTViUqGKE2u6 +bDZUVBZgdwfN3vG8b/b+rRtm723/jlVP4TeSUBbyjQcEY6ijFav/MjvW3Rbg2E0+ew== + + + gwKdYSHfoKlqUqIfSkP7YGixvn93NuLgbC3W999aceGB/tKDXwE9uZz7Y2Cc9zs2kpgqD4PIPZlF +EZYAWX7BpgsKGCbX+MLVGPeJjcmUvylHylkRchFiarkIii7MyFQMFj7xKnBAQgxF46wbyvnecYtx +Xdoa3YXRnV1BfhtdvySUQwYs24SnF9+YbLH3X0evlCgGVxwtrnt2s/fjq2u2FiJms/3rh0b26U7M ++OBSq8r9Npd3K/4jZuBSjSiVe3K/4HisyUYVZncUhqMkrH4IiZDoAwGTo+zlIix9wqL0EMjDSFxl +PesNkUSsWjcDEWJ8VOk14kkxlJcIhPz4pO2G/eVspgqOox+O+BBB4H+UTv+6KsMZ9LcHD9z1LEoB +dZFeMh+n7Y8jZOdVvEAqnxT16m7G2TshO9zhWdKOwKe3WqLG3w0ce/YEPlsvZS4HSjH2574iobXU +MrIGnA7/olVP2PgKC8pU0Ml6FcRr3XBwt8SfL84V2+BwVJYqunMMnU04kMvutSUuFLmi+vj6OrBZ +WwyWpCiUwyY+SnMVeGDd/lIF309eOHg2s0JINszR1nixRr02u53AZ6iURgwAZt6MKlThKdGkRjtb +ivRZt1Vy+jLJIR9dhvQs79LIBzvoY9fYM75dhbYn2lVyFjbn8G+owtxaJCvh6B36TRx+0yjS9s/H +CBzyN0w1uEui8NaY5VlCZA9gF3CKIMAxvrAbdrCGsYdPNAq3uSSOLBaTuZDmWuuBVo7MfBX6nqxn +JlukEmee4fPXBD415zH7cgxAF29elwW4FONszSNHgY91lr857pUcOFkGV3zO4mwRt1DDC8NyL5Vj +LjF2R8ztlBeIwVoGsLkBY8p5rxjF40K2/aeNQPEhbKRI3VeTv4gko/sYJ8axdSEIzMVoW29eFkm5 +0P3zlvSOzUHk0gpwCRDpTJydJS5LJZh+5b4jlghCfAvSOCZI3HThn9nQbO9PIma797Mo9TLyV1/z +UVjpP/gQuYwIIjDok3zIHqUSlNuIAbbyYn4Dgp1bFpusOGS+p9oPO4D0F5J6MT7+zVYC4bgu8jHj +Q6ZzEToSmw/TAy6cKmcAZNURxw0kVaIlDWAjZAKlMyQlcbEsZiTsgaqyK8THckO6Ik4fz3UebrEb +T/EgWhnsUa581o2JBjg/IhsgmqRXJBoWyjj3+XZkC2Gq5AVvxEO9Ftsdjn3IJx39jGuSIP7ia+HE +vI3lyUrudhJvI73OlwzlYrY1IJB7v2QNjrS7jFYdxrHXZRSrhuR0TRLoaxh/pVxWPyH0fx4cyPPS +OBD4LFdz8jyIPL75S2R6+IRQZIQ/IxnbcwKnSkRrpPfPXBTZnpzp1Yi68ytHlvP9AqwmnJEyPcqL +JBtdo4qJGYojn8L2zmR6Qr7lEbbX+Uw8lgszpplpF0/ncly2rSafuw6XE3OtEZ9bRt2GElf4dSNX +6h+7BoyVcl886e09JbBGwXXKQ657gip890ghIw859hc5Xtlw1SLtaKRcyrbzTzgFC1abrAAok9NC +2nPfLaSd8yFlWbUjRPXZs1MkaLFVA3kxDKpSbJujXMN7M5epMu0TxGIaZGRxowM4IK4T5G0faoX8 +yfmnoSQLSJ5jzIPI88sbC7UfmUbVGkggJqPjIstQEf9RVKTqpniwnPgeKUQhv3zEtrpCx2t6Ik/G +jwoUzn+Uca8QwpgFwXIOLTaDMVAgpIliUoTJzCCKuaU00AA4jdfN5eQgdRjnUbICU8Yjw1+OSkoo +5LiRKJjpuNdPzjr1JuZjv+QBi7OGaZTiEcaeCO5CDRDgcvEdQqofieo6EpJ0HFxxwKWBOQdYi8bx +SlGPnrWBATZKVNE1idPZZrdKZ1+LFVTPGoOvdIWolcM5vBoQRs36Ef1vun7KwSuzOySRD1hhl5g7 +OwM283SxXTrkWrZbVF55MQGSW1dvk2SpaYWL2WjgLzJDZ2bnPPCMPk3Qp7nZlbh1yNLID3POhRwS +iZ0XZjP/jWepKTOyvIgUUOi+ieJLTTYDFVmv61hAUNC8ekqLYGYa4MScKhIRfBcwGYwY4rS0XH/s +5RKNW59glYbGO25Dgzu/iL9MLxnLZ3v2+C+f9Xi/xiGq0Pd0bsddiTzRYMRMDVvNZ3n/Ss2cSHnx +pCypdIKLHtEKaTEkjWtiBM2L65lylmmKC4gwlRw1TPFepKYpinG6DCdUsWs4apgCjl1qmhowTFFO +rwHTFEc0zudtqKOBuMbWIxX4TOXTdPZhHpWax/3lA3aNocTtEDC4PwY7GNmvjuQ4iD1lWMMTbVZR +mnMxcTWbFSmgD1K2pzwhCdNLkN4Pd4G205WaGtPDEGvWFTq6Qv8D07vboIrmdu9Mpoe0vhPYnkGm +t0YOuBnicmPsfmO18f/QAYfdb9jiO98BlxuQVX0HHM/H/lsHHHa/mWz/sQMOu9+4jDulA04GibO4 +HK5j47kcDzGDDjg0i1vG5fQSKAUuZ7L9xw44zOUED8klDrhd6k/TAYdVW1YbN2KkgjJ1l0A5xMi6 +CwYVGhyqBCGRFy7A8rvpi81/qhcOZfNJDVJZKi3PjtI1dP12jPQ2einS+/JVlnnh6uSWEQ1SWMU6 +R3rX27zUC5chUOJkKAzc8j0PxvMXIZqj1Ovtevb/1Av39Rfx7oszky1m/xmNcRKZTk3XoYnHl7cG +7GxVFscAbn85Pna3cLM6kSN57+Yyu9hxWMQoJ93Em/M9R7z1tnVksLn5NPqqn2XbuCJB8DghXPXp +621SK0lfc7tEbzPZjGpul+htMIue5uY70+0mHiwmCq7O4mS3m+/A7SanIXkyOutVuLrbTeF0A03p +em43wIgBWy0oVuJxlY8sGR4w5pBPS2ckUdZ1HNQl361KSKEMhxMPCOpZhEDNuNhbAoy62MTQUuI4 +O2JQvizKMPaFpP4xniGNdygv94Wo5ycZUNTcFcT2kvCbpxydLRbDtL1Zb4IWEs4Sta9fCmD3WYX3 +rHzZQYh08k7jigvDAfv6WEgE0H1DJCdVujtSKDI9opRJH0ir5CValslmdr0uxmYn8zYwu4r3TgO2 +6OmWKMvHTrNF9SzRzFYRSJDcd/EfBhLUahKvH0gQIolGAglySIDOxPNNco00rm/so5M45eQHy1am +eAWy6MmVjTumvbCmVK2t5iSdJNgOJ9J72lBgLZoFbvF4j9SACBgxHlRlY98MmwK1RdWYFOJezUO3 +m6o/DmFJxSPnFgE2i4BGVFJBZi/1n3A0rh6ZRd3TOVptV0W+qTe1IGkZBHmNxnk6iCf7kkHM0y7g +aIrTCMPMxVuQL6UM4k4x4GPjqhlUw3kxiipzqqiSAuxTJj/iOZqibMgboW1zukR68xOklL2C7Ap1 +SkhZRlUfkzRRd06KXBkAz9GwbsnxtP+Oo/GRRGwl/Wccja0ZOde7ZpSjIao88K1enaPB6csqwf8b +jia9c/i/42hChR0HIt/5HC221eRo2DfO8bT/jqPJ5f5/xdE4H6xCS7s2R8P3W3I87b/jaDi7g+Np +/x1H4yq4FVratTnaYYdclqPR5V+zy539RkGDqdmZ/u6hTw9nprSxGUSn+dRO96iZJD415A4N//9R +0cMsGBmDY7PUjihtbHnO2QwuuWO5pcjiUGLAPEMVftJV5EqOXofBKT1XqkrbxQwOZaroZX9cIfeD +vIvh6tpEQT37o92LAC/6iOA8WMTlaNoas4lMj4Kn870BpsffcaeR/SGtZvZ+ECU6m6CLoIpMQ4gL +Vmj766MW05MWJSMOI2N7tJ2u1+FIwhkUTg1rKnInMT0uG+oS09QA0zshf+y8QAJmeuxNFGcEEk5i +epwP1ijbO5Pp4XvhjLO9M5mevNfAUbZnkOkFFExPktd3nO2hcsSzmB7S+q5rqaoxPb6/2FVS3q4Q +TcBs70ymx1qvhtnemUwPeeFOYHtnMr3/B9ar0/f6ggKmH4jjdc2uzd+n2U04l/BpY72khoG3Xv8z +hY/XYDHvAxBF/xOFj7Mr/2OFj7uf/xoK32Ctz/lMtuO8zyGE5M9I9sWFDLJbzdNUAKWbJZGT20cp +r2UxmC+iFkeVR3j1I6l07k47mnlyLhzu91D7Yd0yfIlQH8GT4QLxCuh0fAkNfTNFkJ5lJo09il+0 +bBX3a1jty0iMOwDy+YM4Kw5dWxcC1jTg037bjbABe1fQlHguiLPrpFxQfruKjAtG6OxjNAcQe+zi +y2bQDY45cgYoJomylt/nCaTBuhM1QO0yJXUDUpEQSoKMU66feuyQjZ6Y9nuK1nckzpqfx3JB7yeO +sjLNvGMWqcRnS/hn9GmyJbvZnyfPlUseFKnApquUPMhp/9Crp27vXydSIXr1TLb/LlIhevXYexQ1 +Sx68EhQ4L/aK9Wku3/KMci6kH8nv0RmR05c7YFH5r7ziUizeb3leRrDRfGCkwxS7t2hEQjUvl0VJ +qWNtIF9Ih2WogphAiYEehWuPiyOf7NyjKBczT1MuH+qYfeDcK4LC5wyy2SSIEeIYX4ASFMIgl04H +X9HNm4Ra/pxHM3sON1iRZs9x8gpVC2KJRRdbgc9pL4OuYWUot7lSgmPcNlldvk72EvAeUxOThnXZ +KPzCeRcnart3/s4uOSO9etKwpNuvfv7cHKUKv6IkugcUzHhGsY3pSUogW/N+kQFsQAk0aRjAkzFz +RSUQZRFcaAAbUAL5rhkXGMCHSmDrR6EECn1GjBvADrZd0ylKIFCloAYivuM0fIXZKUogzPLfJg3j +ZDo2LqabNIxuUrmwIAJpSlzScEDItk0cJA0j5x7KEgb28cBe8IDqvAKo7CvEPtUtksCYLC+TwI03 ++LtKUaRiikpZM6Bsde9RBkqSGlcdRVD46mHQ5egKLK6UBeTrxKhCx5ejc4FRg20+xN7oBaeL6yyE +822OuogBljHLhCP5ApFAVvOYASK6KoLBTbAsE8nKH/4m2qBLIbskLgEEWRxLWivLII4ogSo32+GE +MOZz1GjHh/XUO0M75qPQ92Q+Zj6fhiWT7T9W+LC6x1LlBQqfnM41wrgyD/x/ofBhdc9k+48VPqzu +4Y45qgqf63KFT3AinFW/D792ywvA5CQVYaTXJrI1if+twoeJhvOQnG72qhi9Tk2jF+tjp5m9Hph5 +nmILFA6N3hdcv48uew+iqC5bGgF8DHNB+APDd4E6SDBl+QUwqSBfzMemqN8rg7uo9gtVqTaQGhen +c/b2LfE2tlZwzMJFU873pwJwqm0QWHSzAfrfT4mcVe7GvMNPn2Wi6gmLH0zm8VdCyTKRw89k+4+D +u+q0b3Z9LufIzbdD0Y2Z2dmxvF18VQm+r++/dPNx+hioXY2GcIzatRKXVErgmIWhWolLKiVMfKfA +o7USapUScjhoV0oItwSo1UqUn//OrnbFFxVKKlOw58eb78dJn41A1N0Kozuzs0Bevdx1ElfYTEj9 +EEf5YttW4iEJXM3DFyewYoQNPEkWtMDs5k/4sivkw2O4OjBcNbEmKTjQzvaUsEZd5A== + + + cqrnwoh8Dle4wGr9SeBZj3ENLqe4/lfO5YrpMvJarzIlHDRR43PX4XKHXZmORHPP4nLSyMh/Z8ey +EV5tPncdLidI5AsrwvS5HHvn8OUVYfpc7oK61/J4Y5TLSSK8Ap8bK1KOL+dyklnODOQa4XJcfeVx +H95FXM50hM9dh8uhHEU9PncdLoeq0fX43HW4HEeVZ2hzrB8m+5z1HG+3JfSxOr/hFnG83RbWlC5r +uGWg3Za0/8uZDbcMtNtiefJFDbc8x9ttCTccnt9wy0C7LQmH0W6PxSKQRnusQ6fjYc8tOJfLh+Vb +b2k23sLncq3WWx6txlvi/WNXaL3l0Wq8xfbkulLrLc1iRX4vV2m95dFqvAXW62mtt6hGWOFeN+Ap +4zuzIJ4FfxigrlRBJ3LD+zHjFriug73EfvG18HBMGF3rD6zXw0nSwYrlbZQjYx5xjCnvR61sW6h7 +6WifqAY++zs/i6afXtDJkKTBMXG1Zss4ynPgtHLOe1yZUirsknA0/mawVNIj+evkprqGv+Ux83Si +O/SXbG8r70t4IbAwOKbwQyX/uszOYdJ1jsN9ZbA4Qgo3gvacEUEB5WtB3oN+XulE7Mqa4Ttsle8I +rNDCTt+z/Ng9Ch8Ewd+I1A6u/m/KFCEiwX/4n0Bn/73Y3G0+3z9//3lNcVMgWyXJ3u98VdosFt3F +/94VVrP9z+J39y/2L5C9z1erkVBhMVvNF/+87PUiIjb4ONTh1CxaS99lmUThLVpeViyd5KTwRgxS +Sr3fse7+IRW1YrKZPTO/DTkhn8xeqnRvdla2XvR1wN5/K+rcB85hrB66LYXFJrcvem4bjwomh13H +0dduOWmyFR9zi04msH1PBCrZYb0wLD3cZwI7YsXrVRI/5VoIc2iZIDgMt7ObXYlmEPV8fYB1Lguw +F1C4A2avK5NBf62ZPe2bJtpfEz1Im31Zeo7ura2Y3X+WjbSCGjtZ7RRnm4AGEefOuDQe8yjWWokB +dVBHve/vKY8k5rW88fNWw89OdASjII+T+/S1cHNkhyq2JWSHv8aciHgrPu7SH3yPLteBrhfb8X7/ +KiGSBtgKuygv5+WUJO5AQUzWfJJ/kPfJlIbcsJfmH1UD0m5yIsqn7kjhwQun+ZaTolbyIp25nGeb +gLLl3y/SuVFdPCqTp3L9Zw/rvh9tv/bwoEOydJbumeFrKyOOPYZfBEGvapWw8uTmQ4qFJerJF2GN +nwjuBAsvgREJMtYLE/xZ4WsPD+tmDyfQeqIDt/dLJJe6HonSMLf7QVgMGj5h0ldZ4HIIECsEJgm7 +YPJ9aZh0QpNtvtO2aNLBCn/z4ohq47HuSMMj8mEVWXA141h0C9V50nwYH+hS0garlOt7bOHQazAJ +ClufSNFreofZr5dLZZ32AhzaT/sEOW1UXfDpieTE0PSFSkWrFJzVdIIS6LnP8yAegjvaZQeP6MON +sOFrP8D9evlE8J9eRGybSpXa5ZyWPEBKLewFG8mvt382XlX4YSSG5eLF9Zb/YEp3XPjleICFFWJi +gGXXlzZZnHHIsnshyDKZQdJ2QvKf5pT4Hqf8776CB6sJ7R5KblcqHn7w3dyWXm9tUa4sHzXOCqPk +5xDSLBiFBS/11wtBGUl6g64zBLN/96gEp48EQN/sfXgpAlN87JtdzaGT45v7WAux1Arw0nTX7Pr8 +Tpl9v+1nxEuj8tLNI0qKypW1/4GSgrglr6b8d0oKy8dGHAn8V0oK7EVQU/4bJYVLCNbokb1Wi/4p +wrpsFFQUyxiprMWXkKJtlvwyJmrrkzbOmkXqkgQb/Dfzzil0lti2DjpvBd1lf7CS5RtRJVdurkRH +1iIM3UzBt0minNEBLWsRxljMtpy1wA8xk/WjxwPkApIByFK/TEpcqzmO7Nl8htvfwGeqV8TKAUK0 +FMZz/m8Pf/zfBpvA592vRzT3McrJoiwXNcPALIxtp56kPELPdHfm0T3hm3ORfo/QnMtkU7bnwvao +bnsu3c5ULhFiuDMV7kuFmpQY7kxFntvEQmyHEFnzQMjQEiDgjmkcEIIBEQhoNUtJc65cf+DTBAHf +2CMdW/7yQHDb5EDwCUBQtmkzBoKk2KLmvIYk6VhrZ6BJm8nm0WrThhLpXDwUcWc1NVTS6fPGhvfR +AHD6BrHxYAjyxmN0DVyjtYMhYk7vZdvI+30iSZls52yjFwuc1DLvkCq90Z37EpwmvXmbRzEABzGj +kEAZUT6jbe/EpnfSpqTI10iobsMgKNF91yQeYHtTruT4ARiLyYZaAf5J3izn/lzcm6UvUnwT3Qn2 +KsXzydhxIY7hzOWLcKwR9IsDaOKY7hAvGeJSHHN8OC/DMeLXpYFjhodoeLxHEUQ6AN6EHMdewv5L +TgO3U1cbAHDM6BDlxs1xclUfgEtvRQqfYd6nvoYXvzoo0Rrw1Q9HTwMUzKMUr7cG9sLiy04DabX6 +oMTyRW8bFV/pNNo4WAPTQIGoS2iDLSXVXcMmFSAlErkS3Pl7CckQ0xfbZTJg+u7x8BJZdxU6a1iT +2kilWANH+8pVzKxh30UYMfMl/SIoJdzyiCSSDsHkVUlccw2H3HKWrqalXyt3GenXdi8r/Tp8ykkU +TJfVH5N+9QXjUtqnXEwsIX2eziSlXyullPRru5GWfh12MtKvs35W+vX7JSeU6IRIJ9Z1xSJlDMWI +zzwLFtKecb+wn5Qb+VEtyicMhDKiQ+wZbNv5lo3KCWFWNisfhVnZS+WUgdZrh1nZWZSB1jPCrOIy +QYq9Cg/cUv8YUqKmwiNp7BNUIyH2WfdLH7wn3yRGv/gAFJkPIVrqEq53b9xMhL96pMHVF78QoWv6 +pA/WMRScagpBtSbBRkaBZyGVu8neCoqYx0QMqrU97EtAzgjJ2z7BdLGypT7wNz8XYWXyaJw24Uk7 +CxuE5/grNywgNsn5/wYlj+BK9fIXGAEmC4CR5cwYDtOJrdGVQbpuQF7OeoURCbWsHpONSfWCzWx4 +NHcelJQMnkQP36uIXpRrP18KIVWvNNZaSSL99pG7ta4wrPKBKJTXE2JJoPDdo7hP+6cXtjar6JqM +uU/UO3IHPoa4uOowg0Yc+nHrDqE0w0qN9x12bOrV1f+QhFQpaUg1Pv/iFzoMCnHjqWQvr4/mvIEI +uXZhtk0Rx6Zt+6rgCxsFWDq3U70gGzexx59C3KfC5FN4j+bee/jJShIcufXc5bujUuH7ZpbtdJ8d +xakv84hzXRA34f3JuzUjZrUjMzokuzZX/c5fk/LWXy7dv7T/xpwKOUwIjlM9FidcFdpkjI4EdVBE +Lkuwpb0ethQNB3jImwAq6/XgZHHJRQY+nOgAf837U9HyXV8IUru4cpVQKcDlpcsCADgadJBDhh+k +gpjH+3H2iJDmkorhbTgVqSOsy5JlnqlqgAhN6+kDjgYmHOdlVMaAuFuQcWlu0g2a21eK5WOSy/e4 +pGWf5Mo9lntx7tAFlio4/COOLcaA2BKr9Mf2/6ZMgAAoijou/s6lEVSTzQZ/uV/s9mv0QmicW7x/ +/jYm/2exMRH/SPw/gvtfOPqPpCL/qFAIvoTQXxpTk7PykM3/q/5OZrvP/7Vw/Wv8wu+yRZNtHMhu +doVP+PPqd7L5P/9i6E/920avWvgX+4d/NhZ/Fv/nhOURY/gNvOBCcdwxLHmMBjOR//r/Ax/wP9mF +aQ9/yK7hcwH+/w6+EP4gt8T+/4E/1eDDF6z7f/6RxL/bf08j4t8c/bxjooiInyGC4RBBUQxDRP75 +IoQ/SkUpMhImKJIKMf9+VF4i6bCfjFIESVDBSDAKMGEofzQaDAdDUYYkgzS8EqH8wFUJMhgi6Wgo +AlMz/jBNRkPBIBkMA+gOX5mZQrByJgqjRZhIkKQplZeC/kgoSoYiDEFFg+qrOXzlYFcz0+FLVNDP +MEyQCpOhUJih/h0shoJRgnQoHCaJaJgIUod7OnhjZjoAzcE7h/BVrsTAMc1MuSmcvLP3+zv5Wcz/ +vW8m80+UERANugBEfpoiGIoJBhmaIaNRhK9B2B1FUxQMDmPA2v00QYVBclHhUCgUpTlE5//NvZuo +MOUPU/z/YBQ6QvojJP8/JvyPjMJMkSjsM0rD4CF0OAAiggkBqJhIOIQ2RwT9APYQxVAhOgz046NJ +WEswGgyFIsEIFYz+6/+YgsFIxB8OhqMhgFMoEvoHxxD0U8EwYAFAE07DyFxBhqT8JIVSEpkgTTL/ +fAygCJxHFE4sGqUY2BccEYwUIgG4BOBQJAKgYCLwK8AngEYI4GNoLpKi/XQYDo2GbdEk3inhD4dg +bthyiIr+y11pW2h1QSIcZOAHMA71jwn7aXhEAYpFo0AxaFNvQOG5nAbbUXx3Tj5jseL39+d6C6wn +0Pv9RLkj97vN5+/7P/ywAUzp/mOyXsRilcnv/HuxaQKasWxJORpF0LBFQCFAfZoB9A10FpPvf9JJ +YJTF5/vHjh2A/BfIrVbKN/Lfq9nyfz63C+GlKqCz/J3q7+fuc/Ld3k/mm8kvNxyhOmHrEzY02eyy +v+/fiyMvggQ4+lpntZugXUteBBIISsiSVv1dHohysRnwv4gSEg4S0flFn/2FIeA+fs53H5zMODi/ +1mQz+dmqP5XLmYXJvUf/XZsIQephgfJuIomwP0SEEUMBhgGUD4ya8dMgDkmElvBnEBzoJfhTKArv +0UDwKi+hV0gySgcjQDWRUEj1FQaACmRIACXBX/lXSIJkouEoMDTEzSPAVJkICYSF2CaWLiGgcypC +RcNhJgLsjPITME0YyCQKtMIKjog/xDDhEDC8CBGMIBYYooCPEdEIkG04hPlsKBKBjzAQGabDMBUF +vDnMAP+OolOLBoHOkYgCjhkJR8MRYNn/glE/PIbhyRDipsDAaX80AsQKfJ+EVQfxvkFUBRk4SSIa +ih6+McPgY4BRAgSDkVBYYxQ0KUNGaFgkqfZGxE+EaZgjygAj494A/g6shAbmwWAJxfiJEAV4C3sG +xoTegS3S8PsIwZBoccBFoyCPgFED0waR5YNXwgwRIoggwaD/x6/AgYGgjFKwHoAKyIYwHYlEgJkC +T4tE/uVNBl5q4JdoGjgf8G0mFEFHSUf9cC5AJrBUgCeoGyE/kltwiuFghNFCrCMImgceSYLOxJ4F +UFMwCAoEwyAJTROhMMgMwCSEOj+mEKwzCjCiQF0IBUPBw3dgcBq0jxCwcoBvhMJSPBJEGEJEETSB +1wMGAoSJMPwfEWKiGL0YAjF+CnCADCP0CoGIBWkaBjkIsipMs/wfDgy+IqkFuA2KCRwnHAysBuRC +mNWSaApJNBJETYQjGpgbWEWYVZLgDYaK0lGahkPDCgOmPTh1OgSyGNCbewkoC9AF/sCwUISjAORi +QgQSYeqvhAAKaCLYJaXyCkIx2g+cK4LEF6I+lZewjgObImE5QMKcXgcYGGWQxoJBDkQOCAA/BSGO +lEOEPUCVWDDCfxFxElE/BfQL2Byk2FMAgAI3jgLviIK+BWoNMGngJbAdIHM4TJC4CA== + + + nCEQ2UTk/2PvXXttO48rvV/A/7C/NCAFra15v8ifKLWTVkA73VarrSAIBDZ5IjORSINmx9a/T9Xc +pLTGmOPZZ1M4NBqB1W2bPHrOusw15/vWWzVqVP2mL8/MWhHfuo11kx4vv/W3V67e5vj22h1bPWvL +tq31A9/vh+vp3bcryFm3IdxV77/vfvFtUPe37/756X/5LqD71T9/+s1n//D02Vf/+MenqWK7WqEq +tjzqpqyn4+znd3ha6vE8K2CsW6sC5+la/I66rBUg1MO21sLQt9BZK8GwVeRcK8RcfzLUt95qb9nm +jlf2fmn/o/tfW8bn/qy1zM5TrcdjB13P+1FxSIU603EO40vwWJf3eTiHY+rl96yVqH6Q51646rau +tbLXqoqUl/oJ6grUT36t4fv43CHpWotcPVR9h851Iy3nUFB/v75L6u1qmepIfa1l4woea0Hf6wKM +Y6381yLXV6hu/7F+/wrkj/lN71W36vhci1stSBU6T7Va9e/4vNTjuU91KKhwsuKsf7Xv9fMP9L3G +o9elsTbC+p8Kep/GOgoc43jU6WrqwPwhevyffv2GAPLpp3/71Td/9+6zr77+vA4eV8T0r3hzXfHP +33xaseq/1Ds//egXH//yu0flv/xfX339h5f/6k/hzseff/Xf3v3241+efbL+1Td//P273/75u0j4 +U4fsz/v5m36Q5+92uLqu9/b0ox8//ebvXwTenZaoq13hZ8u8W+5dH+/6twq9f/nl5+/+pf69AsBf +ffPV1398+Pf+ex9/2XHxF5/+U0fwLRn/6ArePv/TO3ybOPhTzmCqvaAPGXPfxb2Kn2ctgltteFPt +eLX5dDx3g6ba9Wq16rW0Y5nevu/QWJt1PTC1oW/DXhv/U91rtatUNNFb/HSdyp6n6/RT2+BS56iX +XWXpyzpUVFe7aEA+++isfXGvc+1Qe8RY7xago56XOuXVnjJ3uHiET3NHbt/qFx8FqDajunP3CjCX +ih23+upnbWn1t2p7qtBu72D2bdD9It6hca+Ho0KQ3g/raLo/1e/ToW3tWHUdK5oqpB70ufAKAvo0 +sYSLeENqJ6sLUrfl2qeWotb0OhXgXjfCPix1g2/h09yRcBHD6wxX/Fe74FBH/3O67p8+Rtc2WMtX +wb2CDbWm1VbaF3CqJ6qhuR6oOqrXkXeutfaC6iPVla5jc+3/dSa+skIdpldMUdt0r7H1qa+VZOnd +tY5nAambd5nrLD0e43Be4X6Arqe7woj6zHO90lN/5LOXzvq+te7396p1ehyGeauVu6K2l/u5HokK +xbZ64WUPSN3PdeE7GqwbbeqbLUB7hR39BWq5H+ou3sOnCcj9WwVorIhxq8i0VtY6KI1PFaDV6lV3 +V51jjut7d6RXx5x6ujroX57q8y4dOdWvUtdzn15+qs5QjdPSv91SP3q4letHr5ipIvpaJSr4i/f7 +Mj2P9TtVGLzWdjsWc38E38KcR+1ttQzV0tyHw3649qO2yL7KPXFyuj71+jz2JjPUPlnXYq/zXO2W +HWqOvb70xemwvL5oHRzqCLkmJFzkO1Tb11rng4pQ60PVNn/UZzmWqf9lOzv4/Env4HVxj85mznUC +S7eOI3WX1uPWS24dQPuQkKCxL1f9W52i61ee06cJSHgg7tDYB8ha7/s614P99HJiGca5DgX128wv +l3jts9i61cudvWC8d8N5Y/Rbi0XH+3Xn1A1V4czwdJxXIPHtf+rWHZ/7AFM39zyP9YFCarODke/+ +cx0dnirAq+tXwcm+1j1et9JeEVr9p+7YvsEr0PvJ418a9rVOJPvw8IsP9TV/Uj9tH+Lrm07zUV+2 +w9OHv1en9oovn46+YvVD1MK09XX7vm82XAfFCvvqutevXSvlUe/Zgdy/3hf7+Q/xxfq4dTxttZes +9Y3qxepJPMeHCPXlmLXva60Ex9hr77ZWRFwbU73SXLH6VIFLLQLb/nJorCeigsY7dNbL1K07nZ2M +Wra6mhU317pff6vesc70S0Lmjv3qvH6udXhfr+XuBo2d766Vpk7ztWVeq93yvOy1ANbGWDvaywpU +54ouENTS24nhl6Ws9rLaCJY6P9aG2Y9ZHUdqNz3ra9Tjs/QK3bmtin/qqFHXqpFa7uoh2/vUXJ8p +IfcnOkAVeNez2UtmLTv1dJ5zve5xrdd7f5PemmoZuPKQ9U16WXo5ztZ5vmL6Ze/j0g3paKPz8cux +1t1wLNeSeHudWk22ucKDipyPl5TgWjdEl0Pqhjg7aT7WSXntY0JdvWO/ciRLLaR1k/Wif8zX0bm3 ++zqzX3mSjriLWa7woza0vZagK1gd6+gz7HWV66HZr3pTrYn1rftQXlFbxaZ91WuP2fdpH8frzh+X +iiPqb3Z+rP5nTd/ckZdgtS730b/4dq7pda7dqzbkrVMk87Xlzkenlc7ac65DUELC7xmgzmMOXYQq +aru27q78jMtwRTV9BetSzEMnrLbOO11PRO3RdZOetU6MVw5pHOo5qqd5rj8ZKtSoizx0Rm8+r2it +Ys2XKKHuzwqvp7UznH2Vb9DtwYnQVJ+5f5p6KOrid8Lkhgx9AqiDVcUbnUR5ui8HN+TlJlyWuY4I +HZvPR3qdO1Lbae+lWx0s6umNSK1tHUDNHY/Vr3vdhA5dWbf+SkMfcutc33fhUX/Utci6C8br1qgr +3ZnqTvL3D/RtXHxUhFRxwHi8pMG7bFZXaB76l+77sG6FekjqZDxP1/H5+t3rsT3nY5srlFsiYvfP +L67ous5lc+cGz5enwqFPElRfo7PPV3xf4dX1ZrUUVjx55ePGlyWsQv169uvQsA0vT3ItyHt9o/qd +9/1lKdymjisrZusk6cuT3Mn1o8uDLx+61tSlntF16BTLdN0/N+j2cyRoO/tCn/XTVjQz1TJ7hXpD +bQkV0RxxP3nDlvPZ20KXCjfrB694d+yE/ZFCl7lTgnW16mvW2WZc/4LQ5Xxa57oJl04lnVeJ0zbd +ek4rEh0eNoGxNwHd4euzeOjSbO3wUx8c6hxaO2XtS9/3zTonfMUuS0ewtdzU9jds25tilw/2zTx2 ++SDf7Kw9frLYpZbwP8cu21WbaXlBxRhzH7278jK01mGr8KHOGhW7dLG3M8gdFuxbn/Nv0CcNdWBw +Hh1azX1GAKhVBbUpnvM4ITRXYD902qKuzIlQrdy1f9c6Nm4TQbXdVOi318Hq6GctQ2v/BlPXS8cp +XYIXqNN9c6+bR+d5MlTRWj0jV7Vsxg++V4hQR6QrsMFLcK1HFZTUkjwSc9Ta2z/L1BeKoNo464ev +cKLuCPxIXaWpK1lnvEuikKA6G1UYUPtwLa0V2xE09k551nGvPhN88IK21p6stX0ME/x053PtD7Xc +bF2KGhjqomAdIKc+TxPUJ9eKh/v8vcHvez7X1Z4qHjzqkg/w+xZU4ULLOIYRkbXPwLWPbyc9BGcn +5wuoc9JO91uvDlOtDvW81Q2Mb7a3bKMiuor5DvxJjnrqt14vlpe0WIb2tZNg09qnFILOpQUptcHU +5ph/3L3Xo/pQ9YfntMFz2dDWKfRa2eqViBnneqd6v2Ha85VspqLodb5uSoY64q4gtMKmDW7cgub6 +Qerx7TI8LHENXWXs+ve6KfNyUlDtDhXgdIC6jniV1rGTPfvYO2u+3g216qtOE1MfIAhqPVFtB53H +GvES1CJRMc/YcTOsJw3tXfidzs72IXR0IFnBda+s+NPVx2ltUy2XXe8kqLVn17WcZ/jgYysm6iXq +UDhv8Ow2VPfSXI9tBfsLQmOtSHVH1ieD57vLVNN+VHzdKo9XoHpM+sjQdTG4TGPtuLW5V/RW6+6K +r7R0AfjoTMM4wmUqqMs2tbkvl4YEoN75626b+s/zOrh3TfBKt/ZSf8KTOV7Hq4p++//P8ByMte5M +59mVwpa1EVSnvYpwe73YZvxMXQMcOvvecStBtXvVHjZ0nm2Be66z8UNvF1sdU+DdiumHZa8Vc2hX +I4BakVC3Qa3fL8WRDNXXr2NRx2ELXIE6ndQVqqNzXag6NRE095Gvop3a7SFEaahjxa667rXaE1SR +/Ni58U4+w7WcWmZYgVWn1ScIURqqz12nm/kKdAlq1UBtQGu9544XswUydXyocxvtmQ3t09nhSW35 +O16Co/6xk9gV0KwI1TGqDla1YB5XFgSgbevlsNbDYYQfeK6FZ6jwa7sEj3CdCjo769Ill2WDH3h+ +7vTP3qe7b9WnEWrlU9f5a/Whda6go9fKqbeyHX7guQVk9ZgvvZsRUs/JUSvl0ZkGuEoFHa0cazln +51AAWusOqcvUDy8tBPMlMDo6bOwcLEL1T3WY7bz7Crfc3JW6rZ6nimhOiFIK6hNBHdbOivonhrZL +E1OH8nmDu2mudWfskLDi3g1vgU4T1DKwrnXMh8u01LpTB5quc60TXculs5JnJ9nqkw3w0xV0dEG/ +pUEjhSlLrTtznQ3Wuc6scJssz/XV6rRT29g6UZRS0FGrUj0B9bgc+Ep9Hr0yGgMGfMtzb04doVyF +cYSu+60uQa0Y8MsttezUgWbo23eGg1hBnf8Zu/g70HNZTJekx7219RSkLLXqzK00r5BooEWuoLN2 +ij7QHgscVQpqhcDRD1wX0TK0Pg/TVvFVb3cHHMQaOoetbrijE9TwmdbOaLfqsPbVgxa59Xm6btwW +PlY0h1BLOyssnnOC4GLmpXa4CuiH7hcgqALwvaP5rjPCLVdQ/ddHVyZqL8fLtPYSOG6tEKCnd60/ +qvi5NpQKIBeGulRf92TFVjt+pr03wmXoKgitcgX1Vr92LnCnIGWtZafPGUsrfOm8sj63NLXlgPOV +5SXo7BLMtg7TQmexronW01L7TpcS4BJste5cS9xZywFFKQXVCXrvlFMt4vDBt9aP1a7aJe2Vziut +gJ3Po27cs25NeFgKaonuVFvYDsf6YjrDW5fqbFk2XoG1ayt1bKtz9I4fae02l7qS3csAF7wrQrXi +1N667ycFKd0lUU/w1nnhnQ5jBbWm7jr3LHQY255bXHapdNeWbxN0zrU/HVPvv/iZOoEw17JaPzCt +c3stPHU7DXVGmhe64gUdW68qdQ+M9GzutfC0qvUqqtM611Wn9ZI01gshsteuO3ewftIqt9e6s1zF +vKWFuwS1MKVWlIqcT3p8C6pgoTuTVjxn7s/dLbTttdB39xRBvQZWVFzn1Y2/XL3JWTvPOtcr4Ufa +50617VcnB0PddXC1Ey2QUG2lzVo//jj2AZFWuf35RYddZ9vephC6CoEVNEwjxUTHpeXv0/bRwi+C +xhYr1mdfO/OE0FEXYDmvABJ+lqOWnbWbAOqn2SBdXNBcd2WLs+aVbt2jm6e63l+HrPWAy3Q8L52w +r0PG0ts0QbWYdGdIRyq0yHXnRzdMdYg102HlaIn61oXdPmnD71tQi+Cu1MZOUcrR7RKdb62IBoOi +47mV7bUGdA2CzrUFHbXv1mmzfjxa5Vp2OK+17yy9Z8Ciej4PnZuvSGav4xhcp4LqQw== + + + Db1ibhMdxc7ncemjWoVY9ZngEpzP1zNwzGMLxhiqYG5piUNdBfiBz+e5NrGplWfd0kDQMtQWVT8J +HQyK2OpAM7aMeKMH86xlZ7pUEUut4vj91y721Jm+bmB6es9ubzhqyVn2LvgT1Pq1sWvj4yU2BKhi +9E4kHec6IVQPyrl3XaF+F/xMXT5duz+iPhNeybOD/S467xTwHcNzV8nGjgiX48x3XEFjhwP1Vvt+ +qTYBann7JTGkk19BUyeU6yBe/zv/vsfVTdE1rFqgTjis3KEXBU2HY/XqtZKmd8uMfWyA9AJkyC5l +gO4/CkD682bIbpQM2S0HkN68GbLHIEP2QAGkj2aG7CEH6GGtyIQtORmyxQsgXQYzZAtqhmxpBkgX ++QTdtosM2cYDkG5hGbLNMEO2rQKkG3SGbKsHSIOGDFn4kSELZACSiCgzFlplyII0gDTcy5AFjgm6 +haAAaTCbIQuLM2QBNkAaqmfIgn6A9PiQITuIZEhPNMDo0ShDdsjKkB3XAHo89mXEjo8ZsoMoQHqk +TdDtcJwhO2YDpAf2DNnRHyBNImTI0hEZssQGQJoiyZAlWzKkWRtgNP2TIUskZchSUgBpcitDliZL +0C3hBpCm7jJkScAMWToRIE1MZshSnABpsjRDlnbNkCVwAdJUcIYsqZwhzU4Do2nuDFnCPEOWegdI +k/gJupUDMmSFBYC0RJEhK3YAJFWTzFj5JUNWyAFIS0IZsuJShqxMBZAWvDKklbPMWAkOIC3mZcjK +ggm6FRgBkkplZqzkCZAWTzNkZdgMWUEXIC0NZ8iKzBmycjVAWvjOkBTQM2KFeIC0pJ8hEwdkyGQG +AKlgIUE36QNAKqLIkMkxMmTCDoBUIpIhE5tkyGQrAKkAJkMmpcmQiXIAUnlPhkwolCGTHAGk4qUM +mQwKINFTJeYmzMqQSbwAUrFYhkx2liETsAGkUrgMmaguQybPA0iFfhkyyWCGTHwIkMoYM6R6yMyY +sBIglWgm6Cb2BEhloxkyAWqGTMoKkIpiM2Ty2gyZUBcglfxmyMTDGTIZMkAqaM6QSaMzZCJrgESt +nRlVfQOj8vEA3YXoGTJJO0Aqjs+QyewzZIJ9gET5nxntIMiMNCIAog0NGbLWiAxZkwVA2q6RIWv8 +AEhbSDJkzSgJurW1AKQNMhmyVpsMac8OMNr8kyFrI8qQNSQBpK1NGbImqQxZuxVA2riVIWsBA0ib +yTJkbWkZsgY3gIZu9N63WiqhbLTtz1cKuL37Tsg33ZhQ77u/GUDv6cv75C0NnktFFRUzbxWG1w11 +nKm/cxs68qjDeh3qKzDcv3d/59k+xNtzdxeO/UbrlYuSxsRe85+29eHq7Jt3QbYhpvV31letz7PX +AbKf9zZ02fd6IL7vm43XaeBo27FadmvT727cN7R3fsAv9vMf4ovVZrtqe+fUwdWf2zu72nt0xXDp +R7tX3Pml675OZR2pXObaDa1jbdvtDdHVohuTysYZqpt23zs2Gbeu3wBUy3pd66GtkfMr7S9+iOOV +amqXO4Jqp+2a4rheBTOAtACdoc4vVTDYqcTzQOgK9DvSb1NkYNpgs5Pu07HnK9BF6vb/rG82t6kc +QlrJztB22Y8O7ZJ64hWoO+Uqu531eONn2tpQp+LKuvFO/Ey1TdQqtA29x+G1tJp4hrpGXUf1ihgX +vJb1HO5tx9lxPH65ZXw5NJ39AAHTdYm1NudeAvBSWnkdoKFLSuO2DjtfyvYVv+pza1vXElSP05Ug +O3vNBaiCrvmKT2tlxitghXqAhsuAsR7Qga/lUCHnXMHCelkUETR3xWWfrlNRho6rWFI399zxEny7 +W8kfoPagaTuG2mLhM9VGvG9tw7Lu3V6P0NwHq44+RrovKz6rk1fbStVTRRfzJh4AqK7A3s4P+6VV +yFAtJfWM129SOwJ+u3pqW/IwtAMNMp1prxer1ZceqJsKAaCprTrm+ZUnqkLGs7fMrl+MzNSjW8tc +nT72FX+ULgR1bN3xB345kzMAVDdTp1i2aeBL2RapW2+5faxHqE7oc+1y83DO+PO2Y1qdQLtaz9fS +lBEALdPcpi5tDoU3yti2TF13O3a+CYb2NOrRDnO7vhI0bUvFrXUE3ehi3jQWAHVSb67L0D5ZCHV4 +fuWrBrqYbSFeH3g7O7FFt0rbBc5d5ag/O3d8JVNrAHTVQda6gY8dv11d7qUe8LEfBWK2ij/aQKWV +H/hCXTGrFWNq/QC/kso+MtR6rVp1l/VyUCJoWrruVmvrpbbKUPtfbT2Qox5j/ExL5/Xmtv5a+Vqa +giRDc/+2W+0/9XKw0hc0V8zQHjYvnn4Zmuqf+8mrmPnEz9RVvLNlPdtVOwfoUYuSkfrZulIwnevG +l7JP4EN7K/VdR1CtABUZj5fZMCwE+1UOrH1nrQVjwR/FVC0J2lqZ2btmrxh0X17u7L3SH72TwY9S +UB9h2ry1Fgv4TFtXFvuBqs33quYDpPqYDNXnndtGcemJJQitXXjapxanwY1S0Nj+VlP9r3adAqhr +lB2FX5UVhFRpk6H1bH/N/ao84CVYLxFkr7+0+bQd5tnl1/2y0yao0+hTTxKoF8RraZIdgDq0rAXj +6FMNQXNnLNc6ZJwjX8uK9Y4KL8daeA78Vbpwurf31zHQ8eim/gFoHNow+FKfwkLQPnpdw+tnYaY4 +ZevMdRvO9QkJL3itSl1K2GrL52tpMiKAKircz/lo1zK4AnXCr7DxKrvMGz11nQZouWQdsuqS8isN +Hci0O/xG1/ImSALoKqj18rvSsX193iu6ahvguTWzCHXtsbMrw0zno/WqCneRpyuHxJiyCaCKsGup +q+PYztey/vlodWbFlxteph4L0UWXzuDzK9V5rX65rurTWfOmkQJo7mWnrcXpdLQ+t99uO4l3FIIv +NLfEaO2476TT0XrVqbfWpnb8SJCKrYBZeq7FWp9p4ktZa+XaPpDDtNPhaO1qQdfNe64UnTTXLni3 +2H3vxDr+KCbbAmjtFXy4Hit+pVoB56NnsAx0LZfnS+HZPnLnQifN5aqd191WB78TvtxN/wVQ3f/X +s1kYfqSj/6S/fUXasDovXcC4JgvVMZJO7QUtPYqkPvg20bV0JVlm6m5rg9MeATHDDV5Qj6Dr2sxJ +kVzPcqtdsPbNdT7pkVuuYv5ZH2i+Jk4QpJK0DC3d7tLbfUWz+EpLHw37der74SvVLz+3C2SdWXd8 +pZYF9BmzgkO8lKZty1CFAu2uWyvORuF8D4LrclKHqgM9cwVVyLh0xvigdXBpecE29l4/XzVKgFQl +l6H6QH20H2pF4UvZpelLOdAG/QgNneCsc1jv0hmaL6XC1qN21onO7K63y0yPDWnxzN4xCkJrKyl7 +XtNK4XxBrVutp2DpMSUEtRV6pwfqU9Mx86bcA2hoP9c60G2XUDBD23ZpIGsbu+SyAE0vKoxWROMl +aPHE0XMezoPuy5sGEKCe21Lr03hstH7N3Y1Vf1Kr/DxQOF9Q35NtXr9vfDFrFRyWWna6KQ+eOlMT +AtLigsus8+RLWT9rRRbL0fMm8LtNPeSuU5gVE+LP23KOPmN0Cgh/FNMlAjT12WGtR33kS1mhZ+uQ +6vy0UaKsoCuk6DFDeByfL2lIZyPGbaX0x03hCNDU9bUef7nQxezJCcfRtcNrouVbobWF3b3GjvUo +wrtFxj72nbl//8jYhYyM/SKJ8Z82MnaPRMZutsT4XRsZu/0T489RZORxjIQ91Ynx5SEyts4kxhes +yNjKFxlbQhPja3FkbFFPjO8OkbFtJjK2XyXGN77I2A4aGduKE2NbekQsNLgz9xgjMhasRMainsR4 ++BQZi8MSY/FcRCwujIwFmInxSDUyGvFGxCLnxHgIHhmL5RPjh4LI2OkiMnZMSYwddyJix6bE2PEr +InaMi4ydBxPjB8vI2Ak1MnbUTYwdmSNiR+87cz/DR8aSAZGxrEJiPD0RGctzJMYTJpGxzEtkNIOT +EM8ERcZSSpGx3FRiLMcVEcuVJcaTbpGx7F1kLA2YGM8nRsYSk4mxBGdELFEaGcu4JsZTt5GxHHBi +PJkcGctKR8bS23fmniePjCXcI2OZ+8RYBSAiVklIjJckImO1jchYkSQxXm2JjJVtEuP1n8hYISky +VpFKjJe2IqMlsohYqS0xXrOLjBX/EuNVxMhYOTIyVtdMjBdII2OV1sR4yTYyVvuNjBWR78y9Gh0Z +K2tHxurjifFCe2SsYp8YLfxHwvQDkTEhQmJc0RAZk0YkxjUWkTGxRmRM9ZEYl49ExnQoiXFBS2RM +GRMZk9gkxqQ6ETHJT2RMO5QYFyFFxtRMiXFZVGRMXxUZE2rdmbviKzImHUuMa9AiY2K2yJgqLjEu +r4uM6fQiY4K/xLhyMDImQUyMaxkjY6LIyKi4MiEu0oyMqT0T47LRyKj8NCImY02M62EjY8LayJhC +NzEu9Y2MaYYT4+LjyJiKOTImh74zd111ZEygnRhXekfGJOORMe15YlzEHhlTwyfGZfWRMX1+ZEzo +nxhrGIiINR5ERhsYEuKNEJGxjorEeGtGZKzHIzLWLJIY7zqJjLWvJMb7YCKj/TQRsb6cxHiDT2Ss +Uygy1nJ0Y0LvUmSsCSox3k0VGe3Kioh1dyWm7tC6R8+rE41e5xpOPi9XZpI+jrmUvom5l8zCm2XI +PnWE3tfc9qYeybm3nfpEyzUWd4zju6VHsre4790j2cNjx/af6SRx5277YKHdfZ0vuQZPf1dR3Cef +cr3tt/Hd0zV5u2+Ty2hja1/T7lv8nm9WN9vaPZJn959XtHS2veBbeiQ/3Bf7+Q/xxfahyx6v9Eje +W22Xo1Ogddis43o9yWscgXmDUtcyQNr/nCHrpAZIe7IzZN3dGbI+cYC04zxD1rueIeuCB0ja6TNj +ffkZsg5/gNQrIEE314EMmX8BQOqEkCHzVABI3RkyZD4PGTLHCIAenScyogYWmVEjDGDUUSND5s2R +IXP5AEj9QjJkziMBunuYACRmKJlRUxVg1J0lQ5P6vGTIHGMAUu+ZDJmLTYbMDwcgddbJkHn0ZMjc +fgBS36AMmQNRhszLCCB1RUrQzV8JIHVqypBaPmXGvKMAUheqDJmfVYbMGQsg9djKkLl1Zch8vwBS +B7EMmRdZhszVDCD1R8uQOa0lyC3bgFHvtwyZixxA6keXIXO2y5B55AGkbnsZMt++DJkDIEDqJZgh +cyXMkPkbAqROiRkyz8UMmXsjQCo3TNDNURIg9abMkCkFM2R+mQCp82aGROSXEXMCBUg9RTNk+rwM +mc8pQOqYmiGT1mXIXFwBUj/YDKkqDhh1qE3Qzes2QyZoA0j9dzOkRr6ZMS0aQOotnCFzKc6Q6cgA +UufkDJkHc4ZUAwaMukJnyPylAVL5VoZO9bxO0M09GyCVXmXIHL0zZN7gAIlqKjPmVp4h8z0HSBVP +GTIv9gyZqztAKlbKkDnNA6Se9RkyoVGGzEcfIHXkT9BNI5QhmxIAkM4byJDpezJkMw== + + + EACSYQqZMWVOhmy+A0A6KSJDpqrJkE2vAEjnYGTIBDEA6WyODNmUjwTdtCwA6eSRDNkMkwyJDAUQ +namSIZvOkiFTkAAkA2MyY5NnMmTaD4B0Gk6GbK4OQKrbyNChs34yZFODAFLJRYJuk4wyZDORAFK1 +RIZsTlOGdOATMKpzyJDNoMqQTbMCSDUKGbIJWwB1NerPs7oyZPqCDNn8MIB0ElmGTBqQoNt0NIB0 +zlqGrKqfIZv9BpBOkcuQFeQz9DjWDgidjpchK6UDpBP7MmSz/zJkVXCAdB5hhmyyYYasgg2QTlsM +0H1uY4as+AyQzpLMkA6lzIzVhN8GdUvbPL5Yt3ZrQHq3yPjHzpBdgAj5pbxD4UfJkP28EfIbJUJ+ +y2XIbt4I+WMQIX+gMmSPZoT8Ic/Q41oRCV9yIuSLV4ZsGYyQL6gR8qU5Q7bIB+i+XUTIN54M2RYW +Id8MI+TbaoZsg46Qb/UZsqAhQh5+RMgDmQxpRBQZD60i5EFahizci5AHjgG6h6AZsmA2Qh4WR8gD +7AxZqB4hD/ozZMeHCPlBJEJ2osmMHY0i5IesCPlxLUNy7IuIHx8j5AfRDNmRNkD3w3GE/JidITuw +R8iP/hmyJEKEPB0RIU9sZMhSJBHyZEuELGuTGUv/RMgTSRHylFSGLLkVIU+TBeiecMuQpe4i5EnA +CHk6MUOWmIyQpzgzZMnSCHnaNUKewM2QpYIj5EnlCFl2OjOW5o6QJ8wj5Kn3DFkSP0D3ckCEvLCQ +IStRRMiLHRnSqklkvPwSIS/kZMhKQhHy4lKEvEyVISt4RcgqZ5HxElyGrJgXIS8LBuheYMyQVioj +4yXPDFnxNEJeho2QF3QzZKXhCHmROUJers6QFb4jpAX0iHghPkNW0o+QiwMi5DKDDJlgIUB36UOG +TEQRIZdjRMiFHRkyiUiEXGwSIZetZMgEMBFyKU2EXJSTIZP3RMiFQhFyyVGGTLwUIZdBZUj1VIG5 +C7Mi5BKvDJlYLEIuO4uQC9gyZFK4CLmoLkIuz8uQCf0i5JLBCLn4MEMmY4yQ6SEj48LKDJlEM0B3 +sWeGTDYaIRegRsilrBkyUWyEXF4bIRfqZsgkvxFy8XCEXIacIRM0R8il0RFykXWGVK0dGVN9Z8bk +43coCNEj5JL2DJk4PkIus4+QC/YzpMr/yFgHQWS0ESEj1tAQIW+NiJA3WWTI2jUi5I0fGbIWkgh5 +M0qA7m0tGbIGmQh5q02ErGcnM9b8EyFvI4qQNyRlaNLWpgh5k1SEvN0qQ9a4FSFvAcuQNZNFyNvS +IuQNbhnSqZQJ8vGWb2Lu9b7wZhl6T1/e29o7tzpgVEjR57R29fxBRmC2jdX3nxTZtUfpglyO2wjM +qSuUHRl3uaZOkVP7K/6lEzArBGufmLlXlfrPG9o7P+AX8/bOD/HFOnqX5s4+ar46AHO9/vLUnhb1 +v6c5DcC8MalonCHr/QZIm8gDdO9GB0jb2gHS8nOGrNEeIGnYB0Yb/zNkDgIAaR07Q+ZpAJCaIwCk +LgsZMrsGgLQiniH1jwBGfSgAEj+LzJgvBkBaXAdInToyZJYfAKl3SIbMhAQgLdMDpLYoGTJ/FYDU +qCVBN8cXgLTgD5B60GTIzGwAUlecDJm9DkAqHQBIDX8yZM5BAIkDETDqZJShVTUIAKm3UobUowkY +9XoCSE2jMmRiBoDUxipD5ocFkBprAaQOXRkyXQRA6hkGkJqPZchczABSO7QE3RQWAKlBG0Dq9JYh +s4wDSL3nMmRaDYDUDQ8gcdXLjLnzAaQ2fwCp6CNDZjwIkDoYZsisEAFST0WAVD+SIXN5BEjtIjNk +vpMAqYElQI9KlIyYnSZAs/hyZsgMPgFSp1CAVNOSoJt3KUBqggqQuqlmyGxZAVJ1TIbMKBYgdZwF +SK1rM2QeuACpziZD5soLkLj7AqMuwRkyu2GAFhHsAKQGyBkyJ2WA1JI5Q+btDJBqfwBSt+kMmW01 +QGJ/nRmz0QZIRUQAqbF3glZ3CAdIrcYBUs/yDJkcCSB1Uc+Q2bEDpL7uAIk/fGZM1wTQLIb1GTLn +e4DUQh+gUbz4M2QKKYBkOEBmbMgAQDqtACAde5AhlVoBo2MYANJ5DhmywRAA6YSJDJloCyCdeQGQ +Ds9I0G0KB0AyzSMzpv4CSMeLAKRzSjJkA08A0skpAImOLDM2yQUgmQiTGZssA5COqAFIBWkZsqE5 +AOn0nQzZGB+A1sdxQMCosi1DNp8IIB10BJAMTMqMDV4CSDVyGbJRUADpTCmAdDhVgm5TrgAStV1m +bOoWQDq+CyCdA5YhGygGkOr2ABpkxFmGbFYaQDp0LUM2vQ0gVQACpPPkMmSD6QDSCXcZslF5AD1q +CQHRwX0ZsgmAAOkowQzZTEKAVJUIkE5JzJCNWwRI5zYCpAMgE3TTNwKkIykzZLMt3wRtw/Mlbqkf +a2ytV3w7gPSDJ+h2CQDSiwmQ/iwZsh8YIL1VANKbLkN2+wKkD0KG7JEC6PHRBEQf8QzZYgGQLjsZ +sgUMIF0KAdJFNUO2PAOkC32GbMsASDcfgHQby5BtiADp1gqQbtIZ0t0eGA0bEnQLQADSUAYgDYoy +ZOEVQBqoZUgjPmA0dARIg9AMWTgLkMTFwGiAnSEL1QHSoD9DdnwASA8iAOmRJkN6NgJGD1kZ0tMa +MHrsA0gPkBmyoyhAeqgFSI/HGdJzNjB6YE/Q7egPkCYRANJ0RIYssQGQpkgyZMkWgDRtA5DkfzJj +iSSANCUFkCa3MqRZMmA03ZYhS9wBpClAgDSZmCFLSwKkCc4MaaYUGE25AqTJ2wxZGhggTShnyFLT +AGmSGyBNlyfolngHSFP4AGkxIENaVQBGyxMZskIHQFoyAUiLLxmyMg5AWhDKkJWWAFqkSAWQlrsy +ZIUzgKQCB4yW8jJkRUGAtLyYIStUAqQlT4C0eJohK8MCpAXdDFlpGCAtMgOk5eoE3QrfAGkJHSAt +xmfIyvoAqUAgQyI0AEQFCwCp9CFDJqIASOUYGTJhB0AqEQFIxSYZMtkKQCqAyZBJaQBSUQ5AKu/J +kOqEgFHBEUAqXcqQiaAAUjlVhkyYBZBKvABSsViCbrIzgFTAliGTwgGkojqAVJ6XIRP6AaSSQYBU +fJghkzECpILIDJm0EiAVaQIkas/MmGwUIBWgZsikrAAtj5pYYFRcmyGT6QKkgl+AVDqcIRMhA6Ry +5gyZMBoglVgDpGLtBN1k3wCpgDxDJkUHSEXtAKk8PkMmtAdIJfsZMvE/QNpGAJA2JGRIOxuA0RYJ +gKTXIjPWtAGQtn9kyBpJANKWFIC0uSVD1iYDkDbcZMhadwCSHiBgtJkoQ9aWBJA2OAGkrVIBujdd +AaTtWxmyRjCApKMMGG1Ny5ANwgRIR2pmyDxW3wSFmt/97QDSD56h93Xnva3Fc65jbXdBd6K7wucf +ZIJnLex/waDLPl5JJ+Q677cWzzpAbU912Frq5N2Jnnr72oa+/wTPjigqnF+ep2Nor4mKM9/U4/nh +vpn3eH6Qb7ZfZi/S5dm139dGeF414HrS+yA4H3Vd0gjPG5S6rgHS/u0MWSc4QNpTniHrTs+Q9bkD +pB3zGbLe+wxZFz9AYgeQGfMVyJA5FACkXgcJurkmZMj8FwBSJ4cMmScEQOoukSHzqciQOV4A9Oic +kRE14MiMGnkAo44gGTJvkQyZSwlA6neSIXNOCdDdgwUgMXPJjJrCAKPuMhma1KcmQ+Z4A5B652TI +XHgyZH4+AKkzUIbMYyhD5lYEkPoeZcgclDJkXkwAqatTgm7+UACp01SG1LIqM+Z9BZC6aGXI/Lgy +ZM5eAKlHWIbMbSxD5lsGkDqgZci81DJkrmwAqb9bhswpLkFuOQeMetdlyFzwAFI/vQyZM1+GzOMP +IHULzJD5DmbIHAwBUi/EDG2LuCpmyPwZAVKnxwyZZ2SGzH0SIJVLJujmiAmQemtmyESOGTK/T4DU +OTRDIk3MiDmZAqSeqBkyQWGGzKcVIHV8zZDJADNkLrQAqZ9thlS8B4w67Cbo5tWbIZPcAaT+wRlS +I+LMmFAOIPVGzpC5LGdoVX0bQOr8nCHzkM6QytKAUVfrDJk/NkCniMkyZJ7dCbq5fwOkGrAMmSN5 +hszbHCBRbmXG3NYzZL7tAKngKkPmJZ8hc6UHSGVSGTKnfIDUcz9Dpm7KkM0BAEgnCiTopknKkE05 +AEjnJWTIpEQZshkOAMkwiMyY/idDNp8CoF0mXWTIZDsZsukbAOkcjwyZ2AYgnS2SIZtSkqCbRAYg +nZySIZvBkiERtgCiM2EyZNNlMmRyFIBk4E1mbHJOhkxDApBO88mQzQUCSKUfGbJZRRmyqUcAqWAj +QbdJTBmymU4AHSKzyJDNmcqQDqwCRrURGbIZWhmyaVwAqaQhQzYhDCCdNZYhUyJk6ND5ZwDpJLUM +mX4gQbfpbgAdMicuQ1b1z5DNrgNIp+BlyGr1GXocyweETvfLkBXYAdKJgxmy2YUZsrI4QDpPMUM2 +mTFDVs0GSKdFBug+dzJDVoMGSGdhZkiHambGisJvgrq2NdQJ7pIV9WE4vFtm7GMDZEX4CNmlDND9 +RwHIxAoRshslQ3bLAWSajgjZY5Ahe6AAMu1LhOwhB+hhrciEy4MiZIsXQLoMZshlVBGypRkgXeQT +dJebRcg2HoB0C8uQy/IiZNsqQLpBZ8jVixnSoCFDFn5kyEWeGZKIKDMWWmXItbAZ0nAvQxY4Juiu +Gc6QBrMZsrA4Q66tzpCG6hmyoB8gk6BHyA4iGdITDTCm1I+QHbIyZMc1gKSfISJ2fMyQHUQBsq6P +AN0OxxmyYzZA1h0TITv6A6RJhAx5F1GELLEBkKZIMuTNVhHSrA0wmv7JkPekRchSUgBpcitD3roX +oFvCDSBN3WXIWxwjZOlEgDQxmSHvBM2QJkszZGnXDHnHbIY0FZwhSypnyPqKM6Np7gxZwjxD3n6d +IU3iJ+hWDsiQd6lnSEsUGbJiB0BSNcmMlV8yZIUcgMzyIEJWXMqQlakAMmeICGnlLDNWggPI/DMi +ZGXBBN0KjACpzUhkrOQJkBZPM+RuLBGygi5AWhrOkLvWRMjK1QBp4TtD6u0TESvEA6Ql/Qy5A1KE +TGYAkAoWEnR3isqQiigyZHKMDJmwAyCViGTIxCYZMtkKQCqAyZBJaTJkohyAVN6TIRMKZcgkRwCp +eClDJoMCSPRUibkJszJkEi+AVCyWIZOdZcgEbACpFC5DJqrLkMnzAFKhX4ZMMpghEx8CpDLGDKke +MjMmrARIJZoJuok9AVLZaIZMgJohk7ICpKLYDJm8NkMm1AVIJb8ZMvFwhkyGDJAKmjNk0ugMmcga +IFFrZ0ZV38CofDxAdyF6hkzSDpCK4zNkMvsMmWAfIFH+Z0Y7CDIjjQiAaENDhqw1IkPWZAGQtmtk +yBo/ANIWkgxZM0qCbm0tAGmDTIas1SZD2rMDjDb/ZMjaiDJkDUkAaWtThqxJKkPWbg== + + + BZA2bmXIWsAA0mayDFlbWoaswQ0gnaqZIB/P+RYm1PvubwbQe/ry3tbfWXtqPbprbyhTty/+DzPC +88qM6KTLWlu8v3NZ6oY8anGuBW+qKKTNhf6SGZ59d3RPZS1AFTS0od04/VAzPPM38/7OD/LN6u8P +u/Z31un31Sme9Sd1ROzjZG2N2x6neN6YVDfOkLWBA6QN5QG6t6YDpE3uAGkFOkPWeA+QdPADo1YA +GTJTAYC0lJ0hMzoASC0TAFLzhQyZjQNAWhTPkDpLAKMWFQCJ10VmzDQDIK2vA6RGHhkySxCA1Fwk +Q2ZTApBW6gFS65QMmQkLQGrnkqCbMQxAWvMHSM1qMmS2NwCpgU6GzIoHIFUPAKT2QBkyoyGAxLEI +GLU+ypDJEABSO6YMqa8TMGoQBZBaTWXI9AwAqf1VhsxICyC15AJIzb0yZNIIgNRwDCC1LsuQmaAB +pHZqCbqJLABSizeA1CwuQ2Y7B5Aa2GXI5BoAqakeQOLOlxmz+QNIDQMBUt1HhszEECC1Q8yQGSsC +pBaNAKmEJENmGwmQGlBmyKwsAVrFFBOgRzFKRkY16QRI7T4zZMahAKkFKUAqa0nQzRYVIDVYBUit +WjNkpq8AqUAmQ2ZEC9AqlrYAqTluhsxmFyCV2mTIrH8BEg9hYNSMOENmawyQanYAUqvlDJlpM0Bq +/5whM5IGSOU/AKm5dYbMJhsg8dvOjBl3A6Q6IoDUTDxBN1tygNTgHCC1Ss+QKZIAUvv2DJkRPEBq +KQ+QeNNnxqRNAKldfobMeB8gtfAHSIcBZMhEUgDJfILM2KADgHRkAkA6fCFDqrYCRsdBAKSDJTJk +IyoA0mEXGTLdFkA6gAMgHeWRoNtQEIBkukhmTAAGkA48AUhHp2TIhrAApONcABIpWWZswAxAMqkm +MzbyBiAdngOQatIyZAN9ANLRQBmyIUMAybQiYFTcliEboASQjmICSGY6ZcaGQwGkMrkM2cAqgHT0 +FUA6RCtBt3FcAIngLjM2IAwgHTUGkA4ty5CNPwNIpXsADTKSLUM23A0gHROXIRs4B5CKAAHSIXgZ +snF6AOlgvgzZiD+AHuWEgOjIwQzZ8EKAdAxihmygIkAqTARIhzxmyMZFAqSDJwHSEZYJukkcAdKx +mhmyAZ1vgypsG9Z6EGvzO1rHFd8uQ/bBA3S/BBmyi5kh+1ki5D9whuxWyZDddBHy2zdD9iBEyB+p +DMmjmRF7xCPki0WGbNmJkC9gGbKlMEO2qEbIl+cM2UIfId8yMmSbT4ZsG4uQb4gZsq01Q7ZJR8h2 ++8xY2BCgewCSIQtlMmRBUYQ8vMqQBWoRsogvMxY6ZsiC0Ah5OJshjYszYwF2hDxUz5AF/RHy40OG +7CCSITvSRMjORpmxQ1aE7LSWGTv2ZcgOkBHyo2iG7FCbITseR8jO2ZmxA3uA7kf/DFkSIUOWjoiQ +JzYyZCmSCHmyJUOWtsmQ5n8i44mkDFlKKkOW3IqQZckyY+m2CHniLkOWAsyQJRMj5GnJDFmCM0KW +Kc2MpVwzZMnbCHkaOEOWUI6Qp6YzZEnuDFm6PED3xHuGLIWfISsGRMiqCpmx8kSEvNCRISuZZMiK +LxHyMk6GrCAUIS8tZciKVBmycleEvHCWIa3AZcZKeRHyomCGrLwYIS9UZshKnhmy4mmEvAybISvo +RshLwxmyInOGrFwdoHvhO0NWQs+QFeMj5GX9DJlAIEIqNMiICRYyZNKHCLmIIkMmx4iQCzsyZBKR +DJnYJEIuW8mQCWAi5FKaDJkoJ0Mm74mQ6YQyY4KjDJl0KUIugsqQyaki5MKsDC0q8cqQicUCdJed +ZcgEbBFyKVyGTFSXIZPnRciFfhkyyWCGTHwYIZcxZsgEkRFyaWWGTKSZIVV7RsZloxkyAWqEXMqa +IdXEZsbEtRFymW6GTPCboVOlwxFyEXKGTM4cIRdGZ8gk1hkysXaA7rLvDJmAPEIuRc+QidozZPL4 +CLnQPkMm2Y+Qi/8zZG0EGbKGhAhZZ0NmrEUiQ9prERlv2siQtX9EyBtJMmQtKRmy5pYIeZtMhqzh +JkLeupMh7QHKjDUTRcjbkjJkDU4ZslapO3Tcm64yZO1bEfJGsAxpR1lmrDUtQjYMEyAdq5mhWW1W +3wbda37h7TJkHzxC7+vOe1OX59RBw1x7z3kdR48fZIpnPRw2frJPDu+bddlHY511ed6aPC8fhx5w ++dytxfV8Tr13fN/3qhuun8faDp/7889HRyNvafL8cF/Mezw/yBfrnPwiPZ7T2PNC/9Tjea8cn3WU +qM2zVv06A5/j0x+CPZAznwSfochYsTcy5nyUGbVQiozUZyNhhk6ZUWeoyFhJNTLmVZUZNb2KjFVB +I2M2XJlRP6/IaOEyI+ovFpibUVlkrNaYGbVOi4xasEXEyoOZUU+4yJi5XGSspJcZtbuLjPnmRUbL +cBnZxMcvMmYImBmtnEXGLAoDc/M6zIxWuyJj7ouRMRvHzEiBKiJmKxkZ86fMjBaVImOOmZEx683M +aB0oMmYGmhl1FY2M1W4iYz6nmVHD1MDcyi2RMQvXzKgXbGSsRBIZc6fNjLjcRsSKGpEx293MqH9v +ZKwQERlzFM6MWhNHxmoHmVGz5MiY63Jgbun+zKgPdGTMUDoykqHPhNpbR8Z8siNjSfXMiHF3RMwA +PDKWBs+MWpJHxrzNM6Op68iY23pkzLY9M5ptDszNSD4y5kifGU0QR8Y88iOjXvsZ0ZRuZMz8PzI2 +RSAzmoaNjM01yIwOSIiMpU4jYyMbMqOzHyJj2c7A3KZRZEbHWkTGEpSRsUEbmdGJHZGxnGJkHgeI +ZEDHkETGsoCZ0cEokbEJK5GxxF1mdOZLZGx4TGQs2ZYZHWdzZ47bXJzIWH4sMzqpJzI68Scilq16 +E1PH/IrKal+tL1rfN75XZPwzZ8i+fIT8Kt6h8HNkyH7XCPkNEiG/0zJkt2yE/N6PkD9EGbKnMUL+ +WGfocXGIhC8xEfK1KkO26EXIV88I+TKcIVvPA3TfGCLkO0yGbKuKkO95EfLNM0O2C0fIt/MMWVwQ +IQ8wIuSRSoY04omMR04R8hAsQxbLRciDwgDdo8sMWZgaIY93I+SBc4YsAo+Qh/IZsjNBhPxwESE7 +pGTGDjsR8lNThPz4lSE5xUXED4MR8lNlhux4GqD7OTdCfmDOkJ28I+RH+AxZLiBCnlSIkGcnMmRp +jgh5viRClnfJjOVvIuSJoAh5RilDlpqKkOe4AnRPlmXIsm4R8vRdhDwPmCFLKEbIM5MZshRnhDxX +GiFPumbIsrcR8jRwhCydnBlLS0fI89sR8kR5hizjHqB76j5CXgPIkBUTIuRViQxpdSMyXiWJkJdb +MmR1mwh5AShCXknKkJWkImSlrch4iSxDVmuLkBftAnSv/mVIq4iR8WpkhqysGSGvj0bIC60Zsopt +hLz0GyGvIWfIitER0pp2RLw0niGrsUfIi/UR8qp/hkw+EKC7DiFDOl0oQzZdKEM2XQggnS6UIZsu +lCGbLgSQThfKkE0XypBNFwJIpwtlyKYLZcimCwGk04UyZNOFAJLpQom5TRfKkE0XAkinC2XIpgtl +yKYLAaTThTJk04UyZNOFANLpQhmy6UIZsulCAOl0oQyNMl0oMzZdCCCdLpSg23QhgHS6UIZsulCG +bLoQQDpdKEM2XShDNl0IIJ0ulCGbLpQhmy4EkE4XypBNF8qQTRcCSKYLZWaQ6ULA6HShAN2nC2XI +pgsBpNOFMmTThTJk04UAkulCmdHpQpmR6UKA6HShDNl0oQzZdCGAZpkulCGbLgSQThfKkE0XStBt +uhBAOl0oQzZdKEM6XQgYnS6UIZsulCGbLgSQThfKkE0XypBNFwJIpwtlyKYLAaTThTJk04UyZGN6 +ANKBPwnyyUFvYm7lvvBekbEPnRj/9onxyxgZ+z0S4z9sZOwOSYzfaonxezYydvMnxp+ixPjjGBl9 +rBPiy0NifJ2JjC1Yd+a+8iXGl9DI2FqcGF/UI2O7Q2J8m0mM71eRkW0vEbZ5JsT24IjYXp4YDwoS +49FFZCxMSYzHO3dxxD1wiowGYAmxOC4iFg8mxgPLxHiEGhkLdRPjMXNiPPiOjEXxifHjQGL8XBEZ +O6Akxk86ifEjU2Ts7HVn7oe4yNhpMDF2qkyIn04jY8fcxPh5OTF+8I6MneAT46mAxHhOITKWnEiM +ZzkS4+mSyFjeJTGewLkzt0RQRCyhlBjPTEXGUlyJ8VxZYjzpFhnL3iXG04CJ8XxiZCwxmRjPcCbG +U6WRsZxrYjx5mxjPAkfm9ba2t/VGrs9714wr2KtNrp7AH2ICZv2JjG5crvD8fXMiF28h3Grd8+bI +rV0+6kmsSGjoCmI/3Mf3frPvJmCuFUyetdV1ZbtWrPc3R37Ab+bdkR/kmx3tyafdkfX3Hrojx2V7 +7vp8nR5qye/lY6xrUDdwKwnGfa3g9A8v0FSftn0gh17Kb9AnF3TUZ6yjU8uxRoR6BOjatd7hFab2 +ymns576faoC27Zzaxmi71BwEdTG8C0FT96MDtHanc8U661UrAqjCpLF+va7i7gyNPaq09s7XPlPr +E2qnb6cXvpZ1whqGtT0H+zBC0Hh0/fLcXvtMbcxSz/HeAQRCFVgcWzsAjL1dEVRLeh/9Dn6ltWvr +Y7txVQh6INQOn1M7Jcxbuue+heapVpyudOJnWru2PgwtTLwq4gQNvWPVz7fS7dSGg2crAKf5tRda +23Gh3nG7LHMJGoflRUc38tv1HbL2DffKR+rpyfVELcdrLzT3YtDuJFcQAdC0zq0cGPbXXmnsPv/x +aEvnV6CpAuOWZE47X6aKQHuvXIfLfjhCy3MfFeuU3AIKelbanXSs1XAe8cFc6s/qXjraI25/BWrT +jVpTW+uMUAdR23r0pkvP3PLcJihHBx3rQLfA0qX1sc2l9tdeqSW3U2tlz5Xu755/XNvu3JESPXJL +V9bbeqU2pJWvQFu3HG0wNR58uaejXWdanL7Qr1tQHVHrYFmr6iuvVG+2zG3EtQx8wevj9KGwVoxX +XqmFuZ1MWpaRoLlWnV4GOyc403WaO6oa+iLM/JnmWnXqFmjV+HVIAGjv7amjomOjn65Nv/e2kKsz +ySuvVAtX7dXt/rfSFZ87hB0uqexwvAK1uKSA/bXPtLTO+ezk0yuvNB8d5naWZqRbvKC6Akf9xr36 +IjS1CLItJ197pbHOJnUPtHSP1p222m/xSJ+RR/7thg5R6p6rhZXugqmj27Vi8PnYcVEpaK4Vsz1h +VvrcFcj3iaAilE4nMNQOPq2WPXGLnvrUOW51HNhe+0hbv0+rZc+TfrqC6gRztofpxB+p3R/Ho5bo +K58FUIvc219omvB6T33CH/vurpWM3+46Vfb5/LVXmq68xlAb/kLPytTJi9rFzqHPOQjVaXnvPbwe +K74HWn1f0cy2Xdl7gub2plnajxyYOsNvZ+vYp+4xYKgi+K3FsifGvOPzUYvSdFxCVw== + + + ZPZ9u8Yo7AfeAmNnwNq7sTMmdL3HWnb29UUNjzv0+LxeHRqd8eWP1Ab7dW4+53mlyz3WqlO/a32/ +bcUteuxs47h19WHGW6CgqT2Jagted/5RajGpcGcbjwO36LETqV3mOJfXPtPY+cjOxr72SsPW8xb6 +AeYrMFQcW79a3Zd4CwzPXTRY9mMaLqdbgOpqdy/TUMExXYGCxmGf+7CJH2moRacC/rV9z+hyD3VE +HdtFsn4/jPYKqn/pJHn/OUItpd36vLbg0zTUolMb5li75o4bdEFText2BHbQbTl00aNdfpdtH+nX +HWrRWVuY3YsqX6bacOYrV7MPfAnGPoG1UvbqvyCol7e2oh83frs+77TJ1Y6faT6fz4pUOy024is1 +NJytFa59kbb6uf3aetEdr0cPobr717Pnssy01TfUsw+uhhfa6gvaerm4zBTpLiio9521/WAvT1WC +pnrEz1qbY9LihekdbO6BMdvIV6CPID26ZT/op2uoNtW95wpd4myApj7M1RNTe88r0OWQ2PNgKKAv +aJy37i5oDTNfgdoulrYZP1/7THV46l6P9kSmC348t6Ns7zvrihe8/qzuyLFvlAlvgvqzir6Ood0b +J7rix3MtYN0k23kSZCr8HLd6mObXPtLWvpx1kXrQCUK1U7TKe3gxBAZoqdt7qmge94JmpuOqQx+v +vVAtumPvrdPlKQtQ/RZHX6L9tVea5jpAzksH/fxK495uktO5XN67BA1breFDbXevvFJXqXrmxLzg +L7fXurN3P0CXqejmbePkupu6efO1VzranPXoyuwKK31B+1XX6DovbfYN1TLfp4xlw5tgr3Wn+yjb +U+6gK74/r92i0gbxI630DVXwMS51/D0oeVfQstV5rgcAXO0lAM1n3wO1Cc+02zc0d62gDhmvvVIn +i/tGmV57pan2+nHonCJfgYpU+rTdtUp6DvbnDuPq3Lstr7xQrRJjP5V1vxDU3vf9y9ZesFISsKC6 +jvVGPXCAvn8xtSxN69C1frrBe0TAsrfZfgWO9MNtz1sFTG34fA4UNjQ0tQJm6zoXrU3bc/1b3XJL +N8jxZ1rOvZ7gWuQnisIb6ppURfQ9KwGhCiyXzv90BxVD3XZ9dH82ZdwKqntt7QTBtr1yneqfK05b +egQRPb4FdZJha6HUyTfBcI0ZmHqcEV2n9fnsgv/aBVd8pYLGfe/K137ibr8+H+s8v/SuUoJr7kEv +dRvUQWM7KTRuqEdrjdf/8Ctt9V9XqL7MM+72PQ+njX7H7pDjS7C2V/fVAbrTFV9r3alF/rLExd2+ +bV271Flh2rzTY7fWunMlXTvlwq/UVfCu39eRhW7fnq50bj31CWOitZadtW6mVpNN/GZDT2WpxalW +MLp5ewZVF8ra1h1faXk++9NchxF8peW5Leb7rSbcxHpS19ze8RXxUN61oB5wc5z9mPMLdaRTu8Xa +Ye8boan7t4aWRNTZu/22w7sBox+boMfvD4xeyAj5T0KQ/LgA6W0C0OPtRojctgDpAwCQPkoEyUMJ +kD7eBMlCAZAuOQDp4kWQLIMA6YIKkC7NBMkiHyHfLgDSjYcg2cIA0s0QIN1WCZINGiDd6gmSoAEg +DT8A0kCGIAmJANLgCiAN0wh6jPeA0cAxQh6CEvQYywKjQTFAEl0TI2E6QBrwEyRHB4D0EAKQHmcI +koMRQHrEAkgPawTJsQ8gPUACpEdRguRQGyE/HgOkB22C5MgOkB7+CZI0AkCakABIUxsEPeZIgNFk +C0CatiFIEkAASSYJGE1JESTJLYA0TRYhT7gRJKk7gDQJCJCmEwmSxCRAmuIkSJKlAGnaFSDJ3xIj +iWCANKUMkCanCZI0N0CaMAdIU+8ESRI/QbdyAEBaWCBIShQAabGDICmbAKQFGIC0lEOQFIUA0vIS +QFqoIkhKXgBJ7QwYqcERI8U8gLQsGCEvMBL0WKkERkueBEnxFCAtwwKkBV2CpDQMkBaZAdJyNUGP +dW9gtIAOkJbiCZKiPkCiDgBGZQYEiWAhQqZ8IEYkFACpGAMglXUQJAIRgFRqApCKVggS+QtAKqQB +SBQ5xIi0ByAVCQGkciOCRLgEkCigiBEpVYRclAWQyrsIEqEYQCo5A0jFawSJDA4gFdQBpNI8gkTk +B5DKBQFS4SFBImEESMWQAKmskiARaEbIpZ4EiWgUIJWfAqRCVoJEEguQimsBUpkuQY96X2BUOAxQ +Z5D/LEEmSMTMAKksGiAVWBMkUm2AHiXfhIh0PEIuQgdI5ewEiTAeIJXYA6RifYJE9g+Q9A8Ao40I +BElLA0DaHAGQdFkQI+0aAGnjB0HSQgKQNqNEyNtaCJIGGYC01QYgbdohSNp/ANJGIoC0JYkgaW4C +SNukANKGK4KkdQsgbQIj6LGbDBhtSwNIG9wIOh9b5SK017rTLsRz/XaUcbtBUQv43s68N3V49ump +Djxbdwx2S/KHn365dfLJWxP7MHdvTaxQ+M9lzGvIt/RB1t55a/CsJ7fbIOuY1LnOrW02v/dbdRBz +9XfWIbGvRcfideO9p7/zg36vW3vnh/hePZxcuzs37e7sgnAXi9ZhbrOcp5/M15JY797J8zq3/eGl +1jt2vbCWpMuJ3ZlPXpjlqNhsmIbLuAOYx5pxRuox6+nHtbjP+DLnVnFbXYAryk/I2tmOpQ9e2zUC +HZilZ0Ms3fYevvknoe6cmbEf3HocK3rDz1Mnjn6WOgm1IFMrfp9yliuMykwtmlM/iVvnCwCR6nVm +2rynTtT1wXtjAKbdZyr6qQcefq2ORNpW/2zXbfw8y/Ti4b4MC15CLYFnZq2TbUWil00IMnX2qRux +3Ybxe7XOoA5/19wEYurpW5c6uY9HH8qBkTo6MC/2yPNy0h3fNuEdXM4V8vBvsddzs3aIOfBv0bNe ++sR6rie+jhbjganbYrn8IAZ8nXOuH6OigVoQ8Rq2odB5TD3kAq5hLaRD+0T0WYYWFq/oA3OstUB2 +tWeHz9Nm8/Uml/UE/RZbp6P6kDrPK/0WFXlVfLq1JdBIS4vLAoCpr15/1oOO8bvPPUxl2XrKMjwX +vbivdeeM53iNHAGmftFxbF1MWuQ/CdoCYOq56sN+PTz43dehFrpOsdBj2oFihVzrtnT5FZkOgpf2 +LMNvrvIEYHoiTU9V2mmR75EOPfdg62wHLM7FLD2/aRy2k3+Jve0YWi+w0CLvGgdg1n2rz9L23PiZ +63QzHbXZvtiwZeasdafzgcuGv8RZ5/u5HZOmBT6OCyWAqTPyudXXn+mn6LkgZ5dN5vq/8JH3TvMN +bfA+0bO1d52qqxR1Z9AVNLUFIEt92KO1MiN+4rrCPa386DuemLmCiDrxHC8TM4BZr6kpFWnRsuKS +jcws814BSb8bLSs9WGatHbke4oWW+L3TjbVrVdRy0nZbzHUCXbqWh59HdR+Z2frXnNtqjJaVnr3T +c6zODsjwdfYKxPr5WnfabveuunWataU//DoiHslMCyDrSNDTNvB1KqCus1GP8Dnxd6+nvKLZ2nTX +FW/niow6Flt6sg4yokBJzNEyyt4De1GA1+kJTmuv3+O5029RTN0WWxed5wmuT5tbTv3wtKgNEVGx +ZKalmD3eqJ8OZJYKIc62G5thZy+mwvyhQqR2oyNmbrepbdqGjXZbl8JkphWddRCuJ5Ein2Jq22oJ +S19FZI5aneoKXfmUjKydl6lItqMsZERPA0xHhLUo1P6GH6czvPXtK67jn6JnWnUWpJcWYmo1Pab2 +7RppjTdRDiBHT1QYW22BTN0XdXrumx6/eZclukJV8QHeqLXqnNtcHJ1gXNcDTPu4DludCOiHOJ/r +cNyqtPrAtKycnZReOtofRlriz66sViAynB2rEaPiIGB6ktnc6ypc5B5GWGe3jkMW2myL6bFhQ6f+ +6EDVPqQvQ8rOa1xhZlRgBEzFw0On/Db8OBW/13LaGhzabItZKsSqZbeeHvzIy9GK5DqhTLTAm0gJ +kG28DId76yJmu6YtLbUw06JSTJ2161atVYV/iX6k5h6OMtD67konYNZWpVQAcdVYgOlQr+KQ+kR4 +gx2dMdyXPnLiL3q0l2s9XtPBP4XKpYBpCVR3GlzessAcW/0c9ZFXWOBbUFW3xdEqqAFix2bqxxh7 +sNUGe+1NcwVM3evXM3iNkgOm/ZjnHs6Jb1VR0zy39OWA0LGZ1roP1zgu/Oqq28pMG9BWGDuNCzwV +zexTbRKtFMt3T2u2xrGHsNXZHo5TzXShoKc0jRD13LRfmWkJcxeWT1o0muljW7/KwZd5q0877lMn +bPHzbD3ctRP3J/8UKiDLTG3pdY/u7RuL71VPTbtwX9JcZCp0bNXE8Mo1rLiynqvetfn3Uh1aZjoD +UYfts8N0ZCq42juFMMOxvpmzM4rjXj8YXMOxhQBrD4ftpx6ZRzFbRlqQXf92ZZeQWXoaYM8Uw0/T +4706bdJiCWIqPLiGgu54BV0QB0yd2eYuQ82wS3ZBp9eLY6utCQKWq+hTkWWdFLudhpjWUYw9UG/g +X0JVdcCc1xy1+j1gjW9NXT3G9byvnVtDpm/As0cBwhrfurtOL9T1m64xl8CINg+Yo5PAtRucEMS3 +Mm/qIKGbzvi3qKPWsnfOcODfok5SYx8HKobC7y4CP0D2jvOXnv2HTPdY1YJRhxz+KV6Cg/pOO/8U +Zz3JnRw4LsVlYkwlCEg/Dl1jXFZ4q+n50jzVde67/o3M9bjVGnG0WfgKbwaQfOjE3L48QHoVAdKf +I0P2uwIk9wcwep9lyG5YgPTOz5A9QgDpswiQPtQZstUBIF1mMmTrFUC68AGkK2iGbCkGSNf0DNnm +AJDuMgDpdpUh2/cAkv0TGN2HM6T7OTAaFyToFmAApJEKQBryZMhiJ4A0CMuQRXMAaVgIkMaXGbJA +FSCNeAHS0DlDFoMDpMF8huxUAJAeLwDSc0qG9LwDjJ6bMmQHMID0JAeQHgkzpEdLYPSICpCedTNk +h2aA9PQdoPsxHiDNBwCkiYUMWYYCIE11ZMhyJgBp8gUgzeJkyNJBAGleCSBNUGXIMl0AScYsM5Z5 +A0hTeABpLjBDmlMERnOTGbIkJ0CaLQVI064Z0vQtMJoGzpDlkwHSxDRAmuFO0C1VDpDm3AGS3H1m +rAYAkNQSMmM1CYCktgGM1kgyZMUWgLRqkyEr/wCkdSSAtCCVIS1sAaMFMoC00pYhK9kBpLW/DFkR +ESCtRgKkZc0MWX0UIKmzZsbqtQBp4RcgrSAn6FaKBkhr2gBpcTxDVmUHSMv1GbK6P0AqIABIlQgZ +MkkDQKqNyJCJLABStQZAKvvIkOlHAFIhSoZM0QKQSmMAUo1NhkysA5CqfgAS9VBmTIUEkKiZMmOq +KIBUXgWQ6rQSdBN8ASTCscyYAA0gVbIBpJK4DJm2DiAV6QGkar8MmWwQINUfZkh1jMCoHhIg0VVm +xvSZAKnQM0OmGAVIpacAjaJhzZCJYQFSVS1AKs/NkOl8AVLBcIZMeQyQSpgBUi10gg== + + + OvUtomqAVJ2dIZN5A6R6cYBUeJ4hU7ADpFL4DJmmHiAV5wOkKv8MWbsAQNp3AJA2MGTIOiEA0paK +DFlvBkDa5AGQdotkyNpOAJL2lcxYGwxA2k8DkDbmZMg6fADSViGAtOcoQd67BMwkPVAZ0l4qYLQn +CyBt7sqQdYkBNFcUs9VaP+CP4i6lb4OCmOf2bpl5tbntTf2RfWCvDaduo9qg2ujyg/dH9pzIWjbG +rhZtXSeoo+PV/q3NfbVhex/hZn2E9Q+3Bsl96j7CrqHVcWXp+uD5/d/ruwbJbewT99CZvnrDtwzA +/HBfzDskP8gXa3cp7ZCcttXnX0rnbxtxVMzTQ0G7BfT4dv6l9hDfoE/uzcjESFczQNofTZB0WgOk +PdsAafc3QdJHDpB2pAOkve0ESZc8QNpvD5B27hM0PXoAROhaXR7cBABSXwKCxOEAIPVKIOjRdAEY +dW8ASH0gCBJHCYDEmgIY9bggSNwyAFLfDYDUwYMg8QIBSF1FIuT+JAQ9+JwAon4pBInzCkDq4QKQ +usEQJL4yAKlDDUBidUOMeOYApO47AKmPD0HiCASQegsBpC5FBInfUYTcOYkg8WACSN2cAFJfKILE +YQog9aoCSF2vCBL/LIDUiQsg9fQiSNzBAFKfMYDUsYwg8T4DSF3UIuR+bAQ9GrsBow5xBInXHEDq +WgeQ+t8R9GikB4w68gGk3n4EiUsgQOo3CNAkzoUEiQciQOqmCJD6MhL0qIKMjDtFEiSekwCJdhEY +dcEkSPw0AVLFIUBi8UmMeIUCpDJBgNS/lCBxQgVIxX0AqTsrQeLzCpBo8ogR59kIuYctQKqkI+jR +VhcYsecFRtVvBIljMEDqPQyQatYIEj9kgNRZGSCVmhEkbs8AqW80QaIQA0i9rBN0c8UmSHRdAKlT +N0Dq+U2QqLEAUh9ygNTRnKBHDRUw6rEOkLq1EyTSJ4DUQZ4g8aIHSBVLAKk/PkHitB8h1xkBpO7/ +BMkcAYBEHwSMTjYgSGYkAKSqHoBkbAMxMv8BINXiAKQzKQiS6RYAqYKGIJm4AZDO7oiQC18Iknki +AOlkEoBUrkKQTEsBSOeuAKQiE4JkFgxAOlUGIJWGECSTbgDSmTkEPQo6gNEpPgDJOCBiRIYRIZ9Q +BJCMOiJGxBMA6fQlgHSOE0EieQBoldlSAOmUKoJEqgCQTs4iSGZwAaQCA4B0LhhBMmEMIJUFRGi1 +qWcEyfw0gLSYD5DOdCNIpsMBpCV4gHRiHUH1R3+efQeQFs4Jknl8AOlkP4C03E3Qw6xBQEaZWQiQ +1qgJkjmKEfKJjABJaZkYmREJkAybBEZLvW+DWtI7tS62AvyOpNK7ZcY+NkDy/TNjFzJBt58EIP1x +M2S3SYbkdgNEb9sM2QOQIXuUANKHMkP2eAOkC0WGbMnJkC1eAOkymCFbUDNkSzNAusgn6LZdZMg2 +HoB0C8uQbYYZsm0VIN2gM2RbPUAaNGTIwo8MWSADkIZEGbLgKkMWpgEk8V5mLHBM0C0EBUhi2cxY +UJwhja6B0TA9QxbwA6RHhwzZISRDdpwBSA9GGbIjVobssAaQHvsyZAfIDNlRFCA91CbodjzOkB20 +AdIje4bs8A+QphEyZAmJDFlqAyDJkWTGki0ZsrQNQJoAypBmkjJjKSmANLmVIUuTJeiWcANIU3cZ +siRghiydCJAmJjNkKU6ANFmaIUu7Zkjzt8BoIjhDllLOkCWnAdI0d4YsYZ4hS70DpEn8AN3LARmy +wgJAWqLIkBU7ANKySYasAJMhK+UApEWhDFl5KUNWqAJIS14Z0tpZZrQGB4wW8zJkZcEE3QqMAEml +MjNW8gRIi6cZsjJshqygC5CWhjNkReYMWbkaIKl7Z8YK6BmyUjxAWtTPkKoDMmMyA4BUsJAgVz4A +oxKKDJkYI0Mm6wBIBSIZMqlJhky0ApDKXzJkQpoMqSIHGJX2ZMhEQhkyuRFAKlzKkCqggFEpVYJu +oqwMmbwLIBWKZcgkZxky8RpAKoPLkAnqMmTSPIBU5JchkwtmyISHAKmEMUMmhsyQySoBUoFmgm5S +T4BUNJohk59myISsAKkkNkMmrs2QyXQBEr1vZkw4nCGTIAOkYuYMmSw6Q4cKrAFSqXaGRPINiErH +E3QToWfI5OwAqTA+Qyaxz5CJ9QFS2X+GtH8gM9aIAJC2NGTImiMypF0WwGi7Roas8QMgbSHJkDWj +JOjW1gKQNshkyFptMmRNOwBp+0+GrJEoQ9aSBJA2N2XI2qQyZA1XAGnrVoasCQwg6SbLjLWlZcga +3ACSWZMR8qmVb4OSFvD2dgC93pn3tv7OvnVrFWgTx6kLOT9Ef2etMza8sX/8986JPKwNct33W39n +Hem2p8K3XvK2s4sHtZ993zf7rsFz3/p8O7fNwP7+CZgf9pt5g+eH+WYdBkiHZ7c5vzYCc+s8yFxb +eR1dj71ON2kG5g365KN7wzVBj+VlYLQFnKDHXvLIeFM6QdLeTpDUqQHSlnuCpHmfILEBAEj8BIiR +kjdAanFAkJglECS2CwCpgQNBUjwHSE0lCBJ7CoLE6AIgtcwgSMrwBImNB0BqCELQ/mgtApCalBAk +BX2CxDgFILVgIUjMXCLktjAEiTSAILGqAUhNbwgS+xyA1IiHIBEZECTmQACpzRBBYlhEkFgfAaRy +BYLEjgkg8XUiRgyiCHp0mgJGZQ8EifkVQGqjRZAYchEk1l4AqYCCILEbI0iMywASBzRixEotQi7F +IEjs3QgSoziAxHGOGLGuA0hEHcSImR5BYssHkBr8ESRWgQSJPASgRewLCRIjRIDUUpEgMWckSIQm +AKlhJEFiPQmQmlgSJHaYBIlkBSC16CRIzD4BUttQgsSAlCARv0TITVEJEntVgsSoFSBxfCVGVDQA +qQktQWJnS5AY4wKkFrsEiR4HILX9JUgMhAl6dCIGRi2NCRJlD0FiswyQGjYTJNbPAKmJNEGPGiFi +xNYaIPHHJkaMtgESx25iRGtEkJiIR8jtyAkSY3OCxCIdIFUtEfTo2g6M2r8TJEbyBIklPUAqfyLo +0SUfGLXbJ0iM+wmSEQAAiY6KGBlKAJCONyBIBiUQtD+OXABIFVkEyRgIgmSgBEA6moIgGXIBkGq7 +CJLBGwTJCI8E3YaBECRjRQBSlRhBMuqEoMeZKcDo8BWCZIwLQSI3A0hHyxD0OKMGGB12Q5CMzSFI +dGsA6SgfgmQoEEA6XoggGVREkCjgANLhSQTJGCaCZKATQDoaiiBR0wGk46oIksFXBMkIrQj5MC6C +HnV5wOh4MIIe54wRIwPLAJpk9BlBIvAjSMaxAaSD3QiSEXEA6bA5gkQqSJAMwANIR+kRJEP5ANpk +vB9BojokSEYOAqTDCwmSMYgAdWnzzwMVCXrULxIjIx4B0mGRBMnYSYJkgGWETAlJjIzUBEiHc74J +WtfnPt/WCWhdel2Pb0fQ4+eOjF8AguRSEiQ/CkD68xL0eJ8QIzccQHrrEiQPAUD6OBEkDyZB8ogD +pIsFQbLsAKQLGEGyFBIkiypAujwTJAs9QLplECSbD0GyjQGkGyJBjzsrMbJFAyR7PTESNETIww+C +JJAhSEIigDS4IkjCNIA04CNIQkeCJAgFSMNZgiQwJkhCbIA0WCdIwn6A9ABBkBxFCJJDDUByOiJG +jlkA6YGNIDn6ESSHSIDkNEqMHGsJkgMyQHrUJkgO7Qm6Hf8JkkQCQZKSAEiTGwRJmgQgTbgQJKkb +giQJBJCmkwiSxBRBkuICSJNlBD1m3YDR9B1BkggkSFKKAElukhhJcgKk6VKCJPFKkKRwAZJcMDGS +VAZI09MESaKbIEmZR8iT7wRJGp+gx3oAMFpYIOixQgGMljoIeqyZECPFF4C0jEOQFIQA0tISQVKk +IkjKXQBJ3YwYKcARJKU8gLQoSJCUFwHSQiVBUvIkSIqnAGkZlqDHei4wWhgmSErMBEmxOkJe9iZI +CugESSkeIC3qEyTyAIBUaECQSBYIEvEDQCqjIEgEGQCptIMgEYkQJHITgFS4QpBIYABSMQ1BIssh +SAQ+AKlUiCARHRH0qF4CRmVQBD3qqYBRYRZBIvEiSMRiEXLZGUHzg34NGBXCESSSOoJEnAeQyvwI +EsEgQSI9BEhFjASJHBIg0VUSIwJNgh6VnsCoZJQgEZ8CpDJWgkQQS5BIawFSkS5BIvclSITDAKkE +mSARMwOksmiCRGBNkEi1I7Sa6JsgkY8DpEJ0gkTSTpCI4wFSmT1BItgHSKX/BEkTAUHSjgCQNjYQ +tDy2SBAkzRYAadsGQdIAApC2khC0PjalECTtLQBpowxBjx03wGjrDkHSBESQtBMBpI1JBEmLE0HS +LBUh67oiZnps3wJI+sCIkYYygqQ1DSBtciNIZmoCpGasb4KiCsjfjqDXu/Pe1uQ5V3w9LMPZCfMu +B/wQTZ71lW3+ZAdf7511eWuFrHvPmzzPPqgcQ7cxtu1I9zTWUeL7vtl3TZ79oY92jNrrk79liucH +/Gbe5Plhvtm9ybMisVfHeG7Hc7tYHWPdSF0AjGM8b9An98ZrYqSDGyDtBSdIusoB0v50gLTTnaDx +sWceIO2+B0j7+AkaHx0BAFJvAYDUpYAg8TuI0GrOCQCpBwNB4uYAkPpCEPRoMAGMOlUApJ4XBIl7 +BkBiwwGM+nkQJM4gAKnHCEDqVkKQ+J4ApA4qEXIvFoIePF0AUW8YgsRlBiD1qwFInW8IEg8dgNSN +ByCx9SFG/IEAUqchgNSziCBxPwJIfZQAUkcmgsTbKULuEkWQ+E0BpM5VAKkHFkHipgWQ+nIBpA5f +BIlXGEDqOgaQ+pcRJE5oAKmnGkDqzkaQ+LwBpI5xEXLvOYIeTeyAUTc8gsRXDyB16ANIvf4IejQN +BEbdBwFSH0OCxBERIPVWBEhdGgkSv0eA1DkSIPWgJEgknIlxV0yCxF8TIBW6ZkYdPwkS71CATA+c +IbEzJUZ8UQFaVDadIfVqJUhcXwEyeXmG1ImWIPG0BUhF+MCIy26E3K8XIOtVAOjRQhgYsSIGxjo6 +ABJ3ZIDUZxkg63wBSLyfAVIXaYCsQQggcbYGSD2yCdI+qgypb3eCbg7gBGm/WYbUlRwg9TcnSPvy +MqSe6wCpeztB0r6YGfWTB0id6QnSJs8MqVs+QeK7D5D1wmZIZwEQJFMFInTrGc7QIZMOCJKZCQBp +Y3VmdIoDQTIPAiDrP8+QjKggRmZdAGRd+hnS+RsEySQPgMzNACCZLgKQzimJ0M30ASCZnQKQTmEB +yMwxAJLJMADpjBmAzEQEIJl7A5BO0AHIzFYAkqk+AOl8IIKGR0+azOjEIoBk9BExatyTIJ/GBJCM +dSJG7Y0ypJOmANKZVQSpDVSGdI4WQItM5CJIzbIypFPCCJJ5YwCZqViGRpmBRpBMUwPIzNcStNqE +N4JkVhxAZlKXIZ1fR5BMwgPIzPwypNP5CJI5fwCZ6SFAMnsQIJ1iCJCZQwL0MFcREA== + + + nc8IkDloAiQzIyPk0ycBUp9RYGQeJkAyWBMYq/e+Bdrn5z7e1M3X2oXa/cO7AaMfm6DH7w+MXsgI ++U9CkPy4AOltAtDj7UaI3LYA6QMAkD5KBMlDCZA+3gTJQgGQLjkA6eJFkCyDAOmCCpAuzQTJIh8h +3y4A0o2HINnCANLNECDdVgmSDRog3eoJkqABIA0/ANJAhiAJiQDS4AogDdMIeoz3gNHAMUIeghL0 +GMsCo0ExQBJdEyNhOkAa8BMkRweA9BACkB5nCJKDEUB6xAJID2sEybEPID1AAqRHUYLkUBshPx4D +pAdtguTIDpAe/gmSNAJAmpAASFMbBD3mSIDRZAtAmrYhSBJAAEkmCRhNSREkyS2ANE0WIU+4ESSp +O4A0CQiQphMJksQkQJriJEiSpQBp2hUgyd8SI4lggDSlDJAmpwmSNDdAmjAHSFPvBEkSP0G3cgBA +WlggSEoUAGmxgyApmwCkBRiAtJRDkBSFANLyEkBaqCJISl4ASe0MGKnBESPFPIC0LBghLzAS9Fip +BEZLngRJ8RQgLcMCpAVdgqQ0DJAWmQHScjVBj3VvYLSADpCW4gmSoj5Aog4ARmUGBIlgIUKmfCBG +JBQAqRgDIJV1ECQCEYBUagKQilYIEvkLQCqkAUgUOcSItAcgFQkBpHIjgkS4BJAooIgRKVWEZhNl +AaTyLoJEKAaQSs4AUvEaQSKDA0gFdQCpNI8gEfkBpHJBgFR4SJBIGAFSMSRAKqskSASaEXKpJ0Ei +GgVI5acAqZCVIJHEAqTiWoBUpkvQo94XGBUOA6QSZIJEzAyQyqIBUoE1QSLVBuhR8k2ISMcj5CJ0 +gFTOTpAI4wFSiT1AKtYn6HiU/QPUf/Sn/gFgtBGBIGlpAEibIwCSLgtipF0DIG38IEhaSADSZpQI +eVsLQdIgA5C22gCkTTsESfsPQNpIBJC2JBEkzU0AaZsUQNpwRZC0bgGkTWAEPXaTAaNtaQBpgxtB +MlczQj6h801Q1AL62xH0emfe2zo865BZ0WU7EJ5tV/o/0BjP8zbrcvEGz3nsXNsxHHXkrFi7nq29 +7tS/dIpnPXfPZ8WYcy0c05saPD/cF/v5D/LF2qHThnjWGeq1KZ5Hlzb7XD4O2xVppimeN+iTj+5N +1wQ9VpeB0TZwgh77ySPjjekESYs7QVKmBkjb7gmSBn6CxAoAIPEUIEYq3gCpzQFBYphAkFgvAKQm +DgRJ7RwgNZYgSCwqCBKzC4DUNoMgqcITJFYeAKkpCEFiLwKQGpUQJPV8gsQ8BSC1YSFIDF0i5NYw +BIkygCCxqwFIjW8IEgsdgNSMhyDRGBAkBkEAqdUQQWJaRJDYHwGkagWCxJIJIPF2IkZMogh6dJsC +RlUPBIkBFkBqpUWQmHIRJPZeAKl+giCxHCNIzMsAEhc0YsROLUKuxCBILN4IErM4gMR1jhixrwNI +NB3EiKEeQWLNB5Ca/BEkdoEEiToEILUwJEjMEAFSW0WCxKCRINGZAKSmkQSJ/SRAamRJ0PJoiUmQ +KFYAUptOgsTwEyC1DiVITEgJEu1LhNwYlSCxWCVIzFoBEtdXYkREA5Aa0RIklrYEiTkuQGqzS5DI +cQBS61+CxESYoEc3YmDU1pggEfYQJFbLAKlpM0Fi/wyQGkkT9CgRIkasrQESj2xixGwbIHHtJkak +RgSJkXiE3JKcIDE3J0hs0gFS0RJBj87twKgFPEFiJk+Q2NIDpOongh6d8oFRy32CxLyfIBkDAJDI +qIiRwQQA6YgDgmRYAkEydgEgFWQRJKMgCJKhEgDpeAqCZNAFQCrtIkiGbxAkYzwSdBsIQpCMFgFI +RWIEybgTgh7npgCjA1gIklEuBInaDCAdL0PQ45waYHTgDUEyOocgka0BpON8CJLBQADpiCGCZFgR +QSKAA0gHKBEko5gIkqFOAOl4KIJETAeQjqwiSIZfESRjtCLkA7kIepTlATPKiDCClodZY8TI0DKA +dPwZQaLvI0hGsgGkw90IkjFxAOnAOYJEKUiQDMEDSMfpESSD+QDSEX8EieiQIBk7CJAOMCRIRiEC +pEMVCXqULxIjYx4B0oGRBMnoSYJkiGWETAhJjIzVBEgHdL4NqqW4wt+zI65+GvPbASSfOzG3CwCQ +XkqA9EfJkP28AMl9AozecBmyWxcgfQgyZI8TQPpgAqSPeIZssQBIl50M2QIGkC6FAOmimiFbngHS +hT5DtmUApJsPQLqNZcg2RIBkZwVGt+gM6V4PjAYNCbqFHwBpIAOQhkQZsuAKIA3TMmQBH0AaOgKk +QWiGLJwFSANjgDTEzpAF6wBp2J8hO0AApEcRgPRQkyE9HQGjx6wM2YENID36AaSHyAzpaRQYPdYC +pAfkDNlRGyA9tAfofvwHSBMJAGlKIkOW3ABI0yQZsoQLQJq6AUiTQBmydBJAmpgCSFNcGbJkGUCS +dcuMpe8A0kQgQJpSzJDmJoHRJGeGLF0KkCZeAdIUboY0FwyMJpUzZOlpgDTRDZCmzBN0S74DpGl8 +gKQekBkrLAAkFYrMWKkDIKmZAKPFlwxZGQcgLQhlyEpLAGmRCiAtd2VI62bAaAEOIC3lZciKggBp +eTFDVqgESEueAGnxNENWhgVI6rmZscIwQFpiBkiL1Qm6lb0B0gI6QFqKz5AV9QFSeUCGTGgAkEoW +AFLxQ4ZMRgGQCjIyZNIOgFQkApDKTTJkwhWAVAKTIRPTAKSyHIBU4JMhkwoBpKIjgES9lBmTQQEk +eqrMmDALIJV4AaRisQTdZGcAiX4tMyaEA0gldQCpOC9DJvMDSAWDAKn0MEObihgBUjlkhlRXCYwK +NAESpWdmTDIKkIpPM2QyVoBUEAuQSmszZCJdgFTuC5AKhzNkEmSAVMycIZNFA6QCa4BUqp2gm+gb +IJWPZ8iE6ACppB0gFcdnyGT2AKlgP0Mm/QdImwgA0naEDFljA0DaIgGQNltkyNo2ANIGkAxZKwlA +2pQCkLa3ZMgaZQCSjpvMWOsOQNoEBJC2E2XIGpMA0hYngLRZKkHedQWMtm9lSPvAgNGGMoC0NS1D +1uQGkIzVBEi9WN8GJRXQ7e0Aer077009nlMdIee581pT3QK18P4QPZ5dQdDxk10teN+sy87qaC9k +Peze5Hk5g9TuO9aWNla01UYZ3//NvmvyHIfno3a9qeKnziu+v8nzA34z7/L8MN9s6RzTY5fn1HfU +a1M8z/m5E6LjNtd6XXdSnOJ5gz65910TIw3cAGkrOEHSVA6QtqcDpI3uBEnLPEDafA+QtvETJIYA +AKm1AEBqUkCQ2B1EyI0TAFILBoLEzAEgtYUg6NFfAhg1qgBILS8IEvMMgMSFAxi18yBIjEEAUosR +gNSshCCxPQFIDVQi5FYsBD1YugCi1jAEickMQGpXA9AmxjcEiYUOQGrGA5C4+hAj9kAAqdEQQGpZ +RJCYHwGkNkoAqSETQWLtFCE3iSJI7KYAUuMqgNQCiyAx0wJIbbkAUoMvgsQqDCA1HQNI7csIEiM0 +gNRSDSA1ZyNIbN4AUsO4CLn1HEGPHnbAqBkeQWKrB5Aa9AGkVn8EPXoGAqPmgwCpjSFBYogIkFor +AqQmjQSJ3SNAahwJkFpQEvQohYyMm2ISJPaaAImAERg1/CRIrEMBUtkhQOJmSozYogKkWkGA1KqV +IDF9BUgVfgCpES1BYmkLkAjziBGT3Qi5XS9AKqcj6NFBGBhxIgZGJXAEiTkyQGqzDJAK1wgS62eA +1EQaINWbESTG1gCpRTZBIhMDSG27E3QzACdIxF0AqSk5QGpvTpBIsgBSy3WA1LydoEchFTBqJw+Q +GtMTJPongNQsnyCx3QdIZUsA6SgAgmSoQIRcbASQDjogaHwcmQCQiISA0SEOBMk4CIBU2gOQTKgg +RkZdAKSCHIB0/AZBMsgDIJXRECTDRQDSMSURcvULQTI6BSAdwgKQalYIksEwAOmIGYBUaUKQjL0B +SAfoAKT6EIJkqA9AOh6IoEdVBzA6sAggmXxEjGgxIuTDmACSqU7EiIICIB00BZCOrCJIdA8A6Rgt +gHQgF0GiVwBIh4QRJOPGAFKVAUA6Ao0gGaYGkGoDIuQD3giSUXEAaUUfIB1fR5AMwgNI6/AA6XA+ +gmTMH0CLVM8JGh5HDwKkQwwB0po3QQ9jFQHR8YwAaaGaIBkZGSEfPgmQ1JeJkXGYAMlcTWC03vs2 +qHa+rXfQZeibPr5ZROxDZ0a+fETsIgbm9mtkRn/WyNj9ERm5zTKhd2tk7LaPjD0/mdEHMTL2RGdG +l4bI2BoTGVusMqOrXmRs+YyMrcOZ0QU9MLedITK2xWRG96rI2KYXGds9M6PbcGRsP8+MBgaRsQgj +MhaqZEZjnshY8BQZi8IyI9FcRCwqDMwtvMyMhKkRsXA3Mho2Z0TD78hYHJ8ZPRBExk4WkbEjSmb0 +rBMZOzRFxk5fmdFjXGTsPBgZO1hmRk+ogbkddSNjZ+bM6OE7MnaKz4ymAyJjeYXIWIIiM5LoiIgl +TCJjmZfMaAonMpoKioillDKjuanIWJIrMLdsWWY07RYZy99FxhKBmdGMYmQsNZkZzXFGxpKlkdGk +a0Y0eRsZywJHxtLJmdG8dGQswR0Zy5RnRlPud+aeu4+MFQEyo9WEyFhZIjNa34iMFUoiYxWXzGjp +JjJWA4qMFZMyo1WpyGh1KyJaJMuIFtsiY1W7wNzKf5mRMmJErByZGa1rRsYKpJGxSmtmtGQbGav9 +RsaKyJmRYnRErKgdGauOZ0bL7JHRcn1ErOyfGdUPBMZ1CBlRPUNkTBgRGVNYZEalGpExzUdkTDyS +GVWhRMbkLJFRWUxGVF4TGdPpRMYEP5lR5VBkVIGUEVUyBWZ2SVRkTFuVGRVpRcbUXpEx2VhmVH8W +GROyRcYUcZlRaV1kTKMXGRP7ZUZVg5Ex+WFkTMeYGRVEBuamrMyMSjQjY1rPyJhoNDOqPo2MyVgj +Y3rYzIiuNiKmz42MCX0zo4rhyJj0ODKmYc6MiqEjI5rqTKg0OzA3jXdkTCyeGVWdR8bk65ExHXxm +VFAfGRXmR8QE/pnRToHIWMtBZLR1ISPaAhEZ66XIjDZlRMa6OwJzaxPJjPabRMYaVyJjHTCZ0Vaa +yFhPTmSsuSczu3QJRcbajSJjfUuZ0QaoyFgnVWakIysi1tkVGWsRy4zMpUyMD7h8E5OkdLc3A+j1 +xra3NUh2gWWtM8W0DnOfAj94g+TWaSKfFbnfOvvCrEhvI6zzz61Bsvbu6alOw/V4r7W9np1CnL73 +m33XIFlXY1vqSalAeX9/g+SH/WbeIPlhvtmtQbK+6uMYzF9/dD796MdPv/n7+qd/99uffvz1N//h +i8+++eKrLz/9+o9PP6s/+qv6nz8xn/z8o3/38S/X3/71l59/8ukf3339k5+8/PvP3/3uiy+vP/mo +74jx23uj/199xK7o1rpa/7L2n3zy3z760X/8rx//4unjeqP/992Pnz75sv7Wx3+d3w== + + + /6e/+ZtPfv3L//D0s6frL/32u7/0V08/+viX4/Db+hv1X//46d9/91nrpequ/80/1z9c/+vjdx/9 +9/qDj/+x/vl/+6izKxU51uNT/3epSPNpqCCnDRUqXlj77Lxcf9L2ZNvSFby68+tPKm7tYkGfi/v6 +f/vlfvNpvWgnq7779z/Wv/+v9Q//d12Bf34ah6e/efo//s/h6fP+MH/3US3jdetUcNKJ9+98imoh +rAVqned2iXn6Q4Cues851W46VOBcZ/96xp87yJna1Ovo3XU8+vQ2XTYza7sW1w38XBFimz92AmgN +yGcfrZcNap1T1743OhtwgyrwqK13qRcZtm5tD5/mjty+Vb3VDZqWq398HSsWW9tR7/ZppuHKfLeb +a29K6/1L3YjPPrpdmxtzv8C3j/KGH6qfoHzD2r//6NMvfvazv/7977/4x3+q2/anv/7yi8+++vzd +r775+osvf/d0/Zef1A39q3/49B/f/exn//HTLz///buv//bTP7x7uaX91eq61x28drJtaqfgn/7d +u09///T4HvUi77743T988/L3x6ef/vyrr5z4xe+/+uz/+ecv/undn6Bf1t6gzC+//OKbLz79/X/+ +759+/vWnX377ckN8w//0RX2fT7/+5uMvf/f7d+8Ba+l4L/Z3X33zaX/pB/AYt+XxF4h/7xe1w737 ++n//7m90b/l3d8v6yl/4zctfsEub3+Lvv/j8m3/4drW5/Xr/6dOvP/3DP+X/Vlao8c/rxb+tCf9/ +WhNeIq5ff/llPcCfP/3uu6hrX3/cG3Vnrtuqc+4z2LUh7rV7t091u+5dnj9TBXHt9NZKlqNtrm6x +1osB8txWs32cmZ8qfHjex6ElOWsX8586tKjgejsvD/e2O9wr1tg6BBja+aszOB3Lt5ahDiGtQul7 +YRufj56ffvZ3Pq9Qqy7P+Ly0RqC+Xn2wp31bL2flOhSPl6XbW95rqqNrO3cvbZ55+Xu1FcfzVIeo +OnNM9Z8OSI6ugHeSZZ62FmI8TZ1tbHemOgLse33ED/S9fv6BvtdVIFjbb20+Ltf2vh86sdCipmOp +v/PnMOvfdop/2yn+gp3ipxXijv/l3b98U79oXYD/+et373795edfFXD9W/32v/zy83f/8vLvv/rm +q6//+N2/T08/7b/38Zf9y3zx6T/1LfTvP/qrjz66tp3PP9q+jeiH7wLjuvXrGgydI9/aILAOlO0c +vF3ebpdxeTul3KCpxWUVLtdDVzH1i3fPDRpbwdjpgHEb2oP1aRzb2rUO5K3TnDq1sVUQvez1Z+e6 +jHVRr3W9M/tt4H5ctf8b8tlHZz3tV95nODu/fwSoF8euGa6dh7uGHdw+zR25fatffBSgoweFzPsx +9QH/2Oqrn12LGdZj6jPe3hnct0H3i3iHrjV071karSMa96ezbatr/6pNdFynLp6NY6sBx/pS18yG +JVzEG1K749hiza0VJrUXtiP1/XWmrq9tLSpazrOr27dPc0fCRQyvM4zPe9t6tv10r859/8zPc/21 +fWthWnsv1pLcstStL+B0nsula5ha8tIZtDqPHRdUH6kf4aWN8SpUePH6XPd6nS7Ejf299r5kc4sq +rgzf/8fe2/bMkl7Xeb9g/sP5YkA24kfdXV1V3fInknIQBmPHkSxYQRAIY3IiT0INDYp+0b/PXvXM +cHqtWteZM8KhYwSxLGrm8Dr9Ul113/vee+21C3KTRaoMdx9yVtt1fc6QCiLz8N8vsjt/6IS7zJKj +GR8TYBwDPK7r/KXLRQ7XE5Xc3+/neSS22e7nhWVsf0Lmfr5KDDyByqZvrqzOCdr3IyF6lYZi7uK9 +fJqCnL9Vga7bXMB93yVaklvpxH3PuwKL2eAex/e+yK72qadrnrm5L54auDK3zvwqkm7f3n+qm2S9 +UiJt81P9ot3K86Mrkygvr1WTcdr9rrLv/E6SLD3kb/ZleQQ/hXlKhzXL0Lbpjj4erl0W1brK0j3e +jk+9SqDwVCXsMtdiv0lHLjc7ZVoux6P1nii7SUu6z0NSkHKRz5AClOtDRr3zofbHh4d8t+83/cv2 +7k8+m8rbMUTgIsvb+6PdOonMXTqPm5bc5y7pzbVB79OW5Ft8mV95aZ+mIOWBOENz61y03us6z4P9 +4RD5rhcZSUtDv7xfYqWf5U17uL5/wobzi0/JYGqIh2oIunM0I6l6vF2P4uTc3Iv01OtP93jTrbQv +KgVquJBucNXwLPe2rxM3TkD/wy9+UbHLndCW5ymFKc3Lh8d3nrtXTchQPvcnvtnlcbhlLqty9MtE +rgp/90+wePuMXywzmJ/li0ms+bAMppRGrxZvejrmPlxnJZCGbWIA+YPK41pjVCZWn8DlKVv+Y/DV +3CaHkOkEPedlNB1MZpnv+vY5I8y6P39r3lHW+Q1Z5nKvUtOojroey90Jul7ukh8umzwdjy3ueX+7 +73fVSbSjva9A25wmZi+dpXcOc+v7UjZ7mWxs5aN/OTZvjUmSjHG5zeNz1wo929JsO5cjqXlscZqb +IGndXL1VFntn5PxEF+hQda1aMmfZmafzuczrPo71WsqzI46aZeAIgu/vo1qOaGPOeU85kO8SFp8Q +RRu3t2PWhhzr78eSeHqdWU3mRLxuc6JVH4qQuSG2+wQ5c9OtOvXfJMm7aL25PQ4z97mSb9rWteg/ +lueiaENBynzR+fluRynzvZivm2rZZwk6gtWritMyC5Z0SB7lR/lufy7boYyb2FRX/XroXfZZ9Z7H +jjtxxFU69fu7ZWj55om8B6vPQ5GunXFtr3PsXrMhSwC/H4bhh4B6ecyxUorc+aIFKb9ngeaCqV9p +PSaGHFu3ZnnIBV1Rja7gXIrlIvvWbX7f/XgiZo+em/Q568Qhtp/vP8/RPM1Ss18m1JiLPBv+rOjP +I1q739f3KEFSmdl/1rl/j2jtBJ0enArd3uSWfFuOpJLitTNy0Qlgvcvsef7nu83SloMT8n4TSt19 +l4prVzn4/DpnZLZT7aWa7KLJUg2ZtU0B1KJ4bH7d4yZM6MhY6SvNpqUl+bgLNTFifgjdBdfj1pgr +vR9SW52SHvt3cfFDepaLfun79v6LKfJZLvqldR/OrXBT8U9agl3qGf3u89g+l4f0h8u9InH//OKI +rlUnn1O0Jh7dCvRlg64aEbMvR3w/4dXxZrMUPg5Vx/M9BFeIK+ftOTTMOnU8yQ8lTCaqWB5qJ9NS +uGnco2I2VV/en+Tl8I7WFI/luzVV5WO56181DO7LAp1+jgZtEmNLSTV7j1pCPhyh3kUO+etctbaf +fMKW86tPC12khl0V7141kvHRQpc5DCkuvs7XnLPNdf1HhC7PD+vyJimrLMgvl+NRtk13ntOH0lc/ +bALHkAXf4eezZOgidnb4mw4Ocw6dnVKa0p/4ZtLPHrGLdAEKGmf7U0PAp8Qun+2bZezyWb7Zc/b4 +W8Qu+/ISu2yPN206OnZf52ZTKmDRxK7Z+DY5YM8R6+8EXdUmqLBgP0SyJ+hLQQoMjgFN66IzAkDH +qJEJwJdDRNyhZQL7i9IWc2WeCGlW1mXWFgnjCZrtZkI/Dat76Fnr0Krf4KbM7zGQAqCHdDlaNx/K +83RoorV5RmYZP+JRgPYJESR7V2CDl+BYj9ajJ+lKjAS++llu2zGPokNPqTPkm/44rMwBmn15O3QI +yxV+36daNGZFmOB7zq4IaS7iLln/fCb44ANtEp/KP/5yg5/u+Tb7wyw3s6pNSMrQbDu3OUDedJ4m +SCdX6Zye10Ps26G52reJB9UGdoHfV+Plnjo+ziVFZNUZePbx7UkPwTz5moMlje5O95tWh5uGB277 +3MD4ZrumdkxENzHfA3+Sxzz1R0Xj/p4W69C+Kgl2W3VKIUjNJUrNaHPsP67qSZf5UGrPvm3wXAra +JDmXoP7Zb8pd1ap5p3k/NW0gM1H0uhw3JUOKuCcI1bAkuHEHWuYHOabIqiaEkEZ8TRh1fxxTATuk +zms10EqrgVdpVa/JMc/hBveSIBUnH5IFPeFGGWhiZfVoKY91xUsgV4PZ2RQ3w3oiaOKP2WeeyvYh +9FAgqelFGg5HkGZnzu+v3ugLXqe5ABNy6VouC3zwOQPOXnJZpK/f4NkVJJnjPLZHdwVBVw0b3iRt +hud714lk15SgRccShqQQ3jWX5gpL3EDzXvvlUKIfwvcO3W+XCQSVabhe4TINJOOF2dzv2zExq0Pa ++dWXoz/v6+BAaipZlBI7lFwEzQM10a/+/wLPwVXNHE9NBpzI+4LQnPbkGyGnggU/02PXszsHEcWt +BD0P3dhFebY73HPKxl+0XWxzTIF3u6mj42ionkXlgdAx2Uaqyf29ONKh59GnozjsDlfgpqaO5xyd +pUK+IbQcc4LmlDI7B/y+AylW1ODHfX/A7TTHvFWj/G76ZAtcyznQXlfp6bVPQ4giaD73nG6WI9Al +aJsj1mxA61WmDASpW+eilhTcMwXtt6fCk5ua5gh6LJrRdTsaNxFSO9NdC+bjyIIAtG1aDtejFaRD +yyw8FzUQSxxN69yiDo+nRntKRww/8PKm9M+u091jp6VAKckjXanTPa1zAz20Vt60le3wA89pbVVV +5a7djJC7/AJkLaPuVIRmK5A5yJw1rgitc4fMZdLDSwuB/uiQJdwvysEiNP901bS352Fj0KFZTrZ5 +niaieUKUMpBOBHNYe07Uf2NoDnDbRYfyZYO7aVG3h0LCiXs3vAWUJphlQNIXWnfus+7MgUZ1rvVG +1/KurORTSbb5ZBf46QZ6PFURne3uSmHKXT0fkiwtlxut8/c3NQHN+nQIdGEXG+gxq5JGU82dh6+k +8+iR0bhgwHd/0+akCOUojCN03G/H6G1a5e5vUpyr5Xx9LHAQG0j5H/lQXC70XN7V+zHBjPRXdwpS +7m+ahb4fIdGFFrmBntIISbxzh6PKrvFNc/vrgduucBDb17fLbZv4StvdAw5igp6XTe3pSlDDZ9KY +q/WqxoQ529Iit77djhtX+pP1ydAxMP5yX3qC4GDU3j7x0DYLKj296yw7c6RRj8BzucAtt6oL5PlQ +ZULt7gRpKuIAUgjQ07uqD+ShmXB3TXdFSKX6m6yijtl5HZIhhRr0ZDmBv8qx1a/KBe4UpKyz7Oic +cVdfPJ1X1renLtGm+es7rXIDqX1asrHbnc5iqonO0zL7jkoJcAk0rPBY4p5XzRdHaE7Qu1JOs4jD +B9/epH9cLyppr3Re0VDH5flQS/b7SFaA5lGSjcEEInCHb2/K8M6lOmzA8Aqsqq3MsW3O0Tt+JPXe +rjKemn+AC66K0Kw4s7fu+5OCFE0IvWgi7yatPl6mfTukfw/t0vjBHzcN4VOX4L7iZZq7dvanhyYB +3/AzKYFwzPw7JlxVaJ+F56bu/m1uOrriGji7aVWRhxk9m/ssPJdjLu8cMmidU9VJs+xVCYPvpiLB +7LqH99GTVrl91p37Ucyb8ItWuf1NwhSNwX3MJ4IbXMOLZ53bDtcUfKF12TVp7ippHw== + + + /Lr7m9bAiYqly+MvN2+iRjf5LUBOZqBdtmmaxHi70lFsoKcOhkoo3iGhKqWNjBKOVu0rrXL7LDuH +Ivmm2B8/+HshcIKG25ViIs0MvyknqS7PC/x0j7erHOPms2sqLUOPi/qMjgASfhaNVp/F+ZiyuUG6 +eKBFPg/79RhXiIzkyxMQ7hqSStBdCfuH3BUWenofb+qw19jliVRokRtom4DwqRBrocPK400ZWRV2 +ddKG33cgieCO1MZOUcrjTfq1ecwPLxC4nR6z7Nxl06caBJ1rB3qoZXbVdF5a5SQ7XNQFfteeAYvq +8+2i3PxEMvscx+A6DTQf6nKIpW90FHu+Xe86qk2INZ8JLsHz7XgGHosclmiVG2iCuUNnP1cBfuDn +2zKb2E3Ks3klWFSfs/DMFjU/CR0MhtjmQHOVy8lGD+Zzlp3boYq4L0/Klg6kYo+mGl53enolIJ9v +P+eUXQV/gqRfu6o2fj3EhgA91ds3EfTz8ATr0EPt9qorzO+Cn0nl0wmspKukGGUgBfsqOu8U8D0u +b6qSXRUR3g/zmQ5pMrfeat8P1SZA6mU+JIZ08hvopoTyHMTnP/vvO4ySCPc5rM6FgMPKGXpX0Cgc +k6HT7dberTPxsQHyC9ChuJQFOv8oAPnP26G4UToUtxxAfvN2KB6DDsUDBZA/mh2Khxygl7WiE7Hk +dCgWL4B8GexQLKgdiqUZIF/kG3TaLjoUGw9AvoV1KDbDDsW2CpBv0B2KrR4gDxo6FOFHhyKQAcgi +os5EaNWhCNIA8nCvQxE4NugUggLkwWyHIizuUATYAHmo3qEI+gHy40OH4iDSIT/RAONHow7FIatD +cVwD6PXY15E4PnYoDqIA+ZG2QafDcYfimA2QH9g7FEd/gDyJ0KFIR3QoEhsAeYqkQ5Fs6ZBnbYDx +9E+HIpHUoUhJAeTJrQ5FmqxBp4QbQJ6661AkATsU6USAPDHZoUhxAuTJ0g5F2rVDkcAFyFPBHYqk +coc8Ow2Mp7k7FAnzDkXqHSBP4jfoVA7oUBQWAPISRYei2AGQVU06E+WXDkUhByAvCXUoiksdijIV +QF7w6pBXzjoTJTiAvJjXoSgLNuhUYATIKpWdiZInQF487VCUYTsUBV2AvDTcoSgydyjK1QB54btD +VkDvSBTiAfKSfodCHNChkBkA5IKFBp2kDwC5iKJDIcfoUAg7AHKJSIdCbNKhkK0A5AKYDoWUpkMh +ygHI5T0dCqFQh0JyBJCLlzoUMiiATE/VmJMwq0Mh8QLIxWIdCtlZh0LABpBL4ToUoroOhTwPIBf6 +dSgkgx0K8SFALmPskOshOxPCSoBcotmgk9gTIJeNdigEqB0KKStALortUMhrOxRCXYBc8tuhEA93 +KGTIALmguUMhje5QiKwBMrV2Z1z1DYzLxwt0FqJ3KCTtALk4vkMhs+9QCPYBMuV/Z7yDoDPWiACI +NzR0KFojOhRNFgB5u0aHovEDIG8h6VA0ozTo1NYCkDfIdChabTrkPTvAePNPh6KNqEPRkASQtzZ1 +KJqkOhTtVgB541aHogUMIG8m61C0pXUoGtwAuqjRe99mqYSy0ba/HSngu6aeQL7pxJR63/nNAPqR +vrxPctfVnJGJmTe5tV41OebH3HU3tb//xP7O+ROzhV2PXNTZFnZbX67Ovp08aGeViv7O+arzefY5 +QOp5l6HLvs8D8VPf7HqcBmZhustCZTZ9deN+QnvnZ/xiP/9jfLHZbFdv75R130t7p6q9D1UM73q0 +teIu7133cypTpLLKU0vQer1ohNrzpmrRiWll4w7NTbvvik2um+o3AGkyx22diPlI3hdIZeP52Ncj +1bRp6QZoPeaEHg557ct9WQrQHXp31VuVSlS9G6Aj0FekL18/YC7zEyjpfnvs/QqoSL3JMv2ifvwb +frmoZHdo04SX2cPnKj3xCsydcpTdnhqvgpAMdSaunBvviZ9ptolZhbaL9ji8llET75Bq1HeNmHrc +8VrKT3JuTSWkLvjl7tf3Q9NTDxAwqkusGoZ3ffCljPI6QBqOoeFzl50v5QTV61Gfk202QjfNvrrK +GkobXIcm6FqO+HRWZrwCUagHaO6RdZYiTQnBV7psGnY3j9NhUUTQoorLfgyGg5/ucRRLNKRO8RJ8 +u1PJHyB50MiOYbZY+EyzEe+bbFjWXe31CC06WCn6uNJ9OfHZnLxkKzVPFV3Mk3gAoLkCu5wf9kOr +0KFZSuYZn9/kesyZA+h+SB4ucqBBRpn2ebFZfemBOqkQALrJqmNZPvJEaRamtkzVL67MrBqNq/TB +vuKPokKQYmvFH/jlQs4A0NxMSrFstwtfynnAZ7lclB154BWYM/NtmV1uuTwX/HnlmKYpQpq0ga8U +ygiA7poBN0uBphsjJFsm1d0eO98EF3kayVh4uT7xM6k6tWkK0L7RxTxpLABSUk/Ow9sxsBIghedH +vupCF3NXivCpwriqM/hK87ipyjF/dkxX7VCoNQA66iCrRlLv+O12GSXPeq9HgRjZOctARcoPfCFV +zGQsLP0Av5LLPjokvdasuvOGclAi6HZX3W2VwzO+kvyvNEtaAQ1+prvyeousv1a+lqEg6dCi33bT +lNRlhZVec541Gn2Oj++efh26zT/rydOcWfxMquI9JevZjto5QK9alI4cnrx3TULZ+FLqBH6Rt5Lu +OoJmBZjI+HqMZYeFYD/KgRoUfn8eNXiAXNXSoE3KTO2aWjHovtS08LtWeo3GesCPMpCOMDJvncUC +PpNG3Ox6oGbzPar5ALk+pkMaKCobxbsGqyKkKUoyDb2vd7hRBtKMV1lEPo/Zoh1SjVJR+FFZQciV +Nh3SCMCLCqy3Q9gD0CGC1PpLm4/sMJ8qv2oU4A0/ktLocxs8rvOCeC1DsgOQQstZMDQ3D7+cBk1q +cPos4nwtJ9Z7THipKX0P/FVUON3l/fW40PHopP4B6HqRYfChPoWFQD56quEdFukUp2zKXMtwTick +vOCzKqmUsM2Wz9cyZEQATVS4P5eHXMvgCswJX976KrssGz11SgNILjmHrLmk/EoXBTLPixzj4Vqe +BEkAHQU1Lb8rHdvXt32iK9kAa8Y3vtKu2qOyK5eFzkfrURVWkUeVQ2JC2QTQRNhPDWmWuzpB888P +qTMnvtzwMq3rewlLGXx+pTmvXTTcVmZpBIVGCqDlcUzpmt0O7sv1TX67chJXFIIvtEhitCrue9Lp +aD3q1Ju0qYofCXKxFTB3jYtb5zPd+FLOWrnKB/Jy2+lwtKpaoLq5Jn7TSVNzEp8Su+9KrOOPErIt +gI7BDZfjseJXmhVwmZtctpRwLe9vh8JTPnLPO50070ft/KE57csTvtxJ/wXQ3P/Hs6nhEQjpT/Tt +J9KG1fmuAoamIM877nRqH+i+TNCvEfM3upapJOvM3G0yON0fs7TCDT6QxmKpNvOkSO6uSsiqqHBd +nvTI3Y9i/lPjyOft8FKGJK1Dd7W7aLufaBZf6a6joV7nutNef1dNZZEL5JxZd3wlyQJ0xpzgEC9l +aNs6NKGA3HVnxdkonB/ornKSQtULPXMDTch4V8b4QevgXfKC7aq9fjlqlAC5Sq5DGlAzR/uLJp3j +pVRp+lAOyKAfoYsSnHMO0y7doeVQKsxSsswqQGf21Nt1Znalm8Qzu2IUhFYpKR9amyicH0i6VY0W +XS6U3NGEZGWTZ63cVzpmnpR7AF3k5zoHuu0QCnZo2w4N5Gxjh1wWoNu7CkOKaLwEEk88NOfh+aD7 +8qQBBOiigFfzjTdavxZ1Y82fzCq/XCicH0j35OWYZM8Xc9Hg3Vl21JQHT12oCQGRuOAw63zypZyf +VfMBH5o3gd/ttqh0LCPoBz10yyHn0BlDKSD8UUKXCNBNZ4d1HvUrX8oJPaVDumnUEt7h7yHF3CV8 +HF8OaYiyEddtpfTHSeEI0E31tcuqnha4mJqc8HiodihNKVyCM3SM+dUae51HEd6tMvGxz8z5+1cm +LmRl4hdpTP60lYl7pDJxszUm79rKxO3fmHyOKmOPYyXiqW5MLg+ViXWmMblgVSZWvsrEEtqYXIsr +E4t6Y3J3qExsM5WJ/aoxufFVJnbQysRW3JjY0isSocGZOccYlYlgpTIR9TQmw6fKRBzWmIjnKhJx +YWUiwGxMRqqV8Yi3IhE5NyZD8MpELN+YPBRUJk4XlYljSmPiuFORODY1Jo5fFYljXGXiPNiYPFhW +Jk6olYmjbmPiyFyROHqfmfMZvjKRDKhMZBUak+mJykSeozGZMKlMZF4q4xmchmQmqDKRUqpM5KYa +EzmuikSurDGZdKtMZO8qE2nAxmQ+sTKRmGxMJDgrEonSykTGtTGZuq1M5IAbk8nkykRWujKR3j4z +5zx5ZSLhXpnI3DcmKgAViUpCY7IkUZmobVQmiiSNyWpLZaJs05is/1QmCkmViYpUY7K0VRkvkVUk +Sm2NyZpdZaL415isIlYmypGVibpmY7JAWpmotDYmS7aVidpvZaKIfGbO1ejKRFm7MlEfb0wW2isT +FfvGeOG/EqEfqEwIERqTiobKhDSiMamxqEyINSoTqo/GpHykMqFDaUwKWioTypjKhMSmMSHVqUhI +fioT2qHGpAipMqFmakzKoioT+qrKhFDrzJwVX5UJ6VhjUoNWmRCzVSZUcY1JeV1lQqdXmRD8NSaV +g5UJCWJjUstYmRBFVsbFlQ1JkWZlQu3ZmJSNVsblpxUJGWtjUg9bmRDWViYUuo1JqW9lQjPcmBQf +VyZUzJUJOfSZOeuqKxMC7cak0rsyIRmvTGjPG5Mi9sqEGr4xKauvTOjzKxNC/8ZEw0BFovGgMt7A +0JBshKhMdFQ0JlszKhM9HpWJZpHGZNdJZaJ9pTHZB1MZ76epSPTlNCYbfCoTnUKViZajE1N6lyoT +TVCNyW6qynhXVkWiu6sxc4fOPfo8OtHodY7h5Mv9yEzSxwmX0k9iziWz8mYdik9doR9rbvukHslF +2858ovsxFvdax3dbj6S2uJ/cI6nhsVf5zyhJrNytDhbe3ad8yTF4+vuK4n7LKdfbfhrffTsmb+s2 +OYw2Nvmaqm/xJ77Z3GyreiSf6j+faOkpe8FP6ZH8fF/s53+ML7ZfVPb4SI/kudX2/lAKdA6bc1yf +J3mtIzBPUOtaBsj7nzsUndQAeU92h6K7u0PRJw6Qd5x3KHrXOxRd8ABZO31noi+/Q9HhD5B7BTTo +5DrQofAvAMidEDoUngoAuTtDh8LnoUPhGAHQq/NER9zAojNuhAGMO2p0KLw5OhQuHwC5X0iHwnmk +QGcPE4DMDKUzbqoCjLuzdOjmPi8dCscYgNx7pkPhYtOh8MMByJ11OhQePR0Ktx+A3DeoQ+FA1KHw +MgLIXZEadPJXAsidmjrklk+dCe8ogNyFqkPhZ9WhcMYCyD22OhRuXR0K3y+A3EGsQ+FF1qFwNQPI +/dE6FE5rDUrLNmDc+61D4SIHkPvRdSic7ToUHnkAudteh8K3r0PhAAiQewl2KFwJOw== + + + FP6GALlTYofCc7FD4d4IkMsNG3RylATIvSk7FErBDoVfJkDuvNkhE/l1JJxAAXJP0Q6FPq9D4XMK +kDumdiikdR0KF1eA3A+2Q66KA8Ydaht08rrtUAjaAHL/3Q65kW9nQosGkHsLdyhcijsUOjKA3Dm5 +Q+HB3CHXgAHjrtAdCn9pgFy+1aGne1436OSeDZBLrzoUjt4dCm9wgEw11ZlwK+9Q+J4D5IqnDoUX +e4fC1R0gFyt1KJzmAXLP+g6F0KhD4aMPkDvyN+ikEepQTAkAyOcNdCj0PR2KGQgA2TCFzoQyp0Mx +3wEgnxTRoVDVdCimVwDkczA6FIIYgHw2R4diykeDTloWgHzySIdihkmHTIYCiM9U6VBMZ+lQKEgA +soExnYnJMx0K7QdAPg2nQzFXByDXbXTo4bN+OhRTgwByyUWDTpOMOhQzkQBytUSHYk5Th3zgEzCu +c+hQzKDqUEyzAsg1Ch2KCVsAqRr1w6yuDoW+oEMxPwwgn0TWoZAGNOg0HQ0gn7PWoajqdyhmvwHk +U+Q6FAX5Dr2OtQPCp+N1KErpAPnEvg7F7L8ORRUcIJ9H2KGYbNihqGAD5NMWC3Se29ihKD4D5LMk +O+RDKTsTNeFPg9TStlzfrVvVGtDerTL5sTsUF6BCeSnPUPlROhQ/b4XyRqlQ3nIdipu3QvkYVCgf +qA7Fo1mhfMg79LpWVCKXnArl4tWhWAYrlAtqhXJp7lAs8gU6bxcVyo2nQ7GFVSg3wwrlttqh2KAr +lFt9hyJoqFCGHxXKQKZDHhFVJkOrCmWQ1qEI9yqUgWOBziFohyKYrVCGxRXKALtDEapXKIP+DsXx +oUJ5EKlQnGg6E0ejCuUhq0J5XOuQHfsqksfHCuVBtENxpC3Q+XBcoTxmdygO7BXKo3+HIolQoUxH +VCgTGx2KFEmFMtlSocjadCbSPxXKRFKFMiXVoUhuVSjTZAU6J9w6FKm7CmUSsEKZTuxQJCYrlCnO +DkWytEKZdq1QJnA7FKngCmVSuUKRne5MpLkrlAnzCmXqvUORxC/QuRxQoSwsdChKFBXKYkeHvGpS +mSy/VCgLOR2KklCFsrhUoSxTdSgKXhWKylllsgTXoSjmVSjLggU6Fxg75JXKymTJs0NRPK1QlmEr +lAXdDkVpuEJZZK5Qlqs7FIXvCnkBvSJZiO9QlPQrlOKACqXMoEMhWCjQWfrQoRBRVCjlGBVKYUeH +QiJSoRSbVChlKx0KAUyFUkpToRTldCjkPRVKoVCFUnLUoRAvVShlUB1yPVVhzsKsCqXEq0MhFqtQ +ys4qlAK2DoUUrkIpqqtQyvM6FEK/CqVksEIpPuxQyBgrFHrIyqSwskMh0SzQWezZoZCNVigFqBVK +KWuHQhRboZTXViiFuh0KyW+FUjxcoZQhdygEzRVKaXSFUmTdIVdrVyZU350J+fgZKkL0CqWkvUMh +jq9QyuwrlIL9DrnyvzLRQVAZb0ToSDQ0VChbIyqUTRYdinaNCmXjR4eihaRC2YxSoHNbS4eiQaZC +2WpToejZ6Uw0/1Qo24gqlA1JHbp5a1OFskmqQtlu1aFo3KpQtoB1KJrJKpRtaRXKBrcO+VTKBuV4 +y09izvW+8mYd+pG+vE9r79zmgDEhhc5pcvX8o4zAlI3VT58UqdqjdUHeH6cRmDdVKBUZq1wzp8ib +/BX/sRMwJwSTT8yiVWX+3ye0d37GL5btnZ/jiyl6t+ZOHTU/OgBzPf7yTZ4W85+3pQ3APDGtaNyh +6P0GyJvIC3TuRgfI29oB8vJzh6LRHiBr2AfGG/87FA4CAHkdu0PhaQCQmyMA5C4LHQq7BoC8It4h +948Axn0oADI/i86ELwZAXlwHyJ06OhSWHwC5d0iHwoQEIC/TA+S2KB0KfxWA3KilQSfHF4C84A+Q +e9B0KMxsAHJXnA6FvQ5ALh0AyA1/OhTOQQCZAxEw7mTUodU1CAC5t1KH3KMJGPd6AshNozoUYgaA +3MaqQ+GHBZAbawHkDl0dCl0EQO4ZBpCbj3UoXMwAcju0Bp0UFgC5QRtA7vTWobCMA8i95zoUWg2A +3A0PIHPV60y48wHkNn8AueijQ2E8CJA7GHYorBABck9FgFw/0qFweQTI7SI7FL6TALmBJUCvSpSO +hJ0mQIv5cnYoDD4BcqdQgFzT0qCTdylAboIKkLupdihsWQFydUyHwigWIHecBcitazsUHrgAuc6m +Q+HKC5C5+wLjLsEdCrthgO4m2AHIDZA7FE7KALklc4fC2xkg1/4A5G7THQrbaoDM/rozYaMNkIuI +AHJj7wat6RAOkFuNA+Se5R0KORJA7qLeobBjB8h93QEyf/jOhK4JoMUM6zsUzvcAuYU+QFfz4u9Q +KKQAsuEAnYkhAwD5tAKAfOxBh1xqBYyPYQDI5zl0KAZDAOQTJjoUoi2AfOYFQD48o0GnKRwA2TSP +zoT6CyAfLwKQzynpUAw8AcgnpwBkOrLOxCQXgGwiTGdisgxAPqIGIBekdSiG5gDk03c6FGN8AFpf +xwEB48q2DsV8IoB80BFANjCpMzF4CSDXyHUoRkEB5DOlAPLhVA06TbkCyNR2nYmpWwD5+C6AfA5Y +h2KgGECu2wPoYiPOOhSz0gDyoWsdiultALkCECCfJ9ehGEwHkE+461CMygPoVUsIiA/u61BMAATI +Rwl2KGYSAuSqRIB8SmKHYtwiQD63ESAfANmgk74RIB9J2aGYbflJ0HZ5O8Qt82NdpfWqbweQf/AG +nS4BQH4xAfKfpUPxAwPktwpAftN1KG5fgPxB6FA8UgC9PpqA+CPeoVgsAPJlp0OxgAHkSyFAvqh2 +KJZngHyh71BsGQD55gOQb2Mdig0RIN9aAfJNukO+2wPjYUODTgEIQB7KAORBUYcivALIA7UOecQH +jIeOAHkQ2qEIZwGyuBgYD7A7FKE6QB70dyiODwD5QQQgP9J0yM9GwPghq0N+WgPGj30A+QGyQ3EU +BcgPtQD58bhDfs4Gxg/sDTod/QHyJAJAno7oUCQ2APIUSYci2QKQp20AsvxPZyKRBJCnpADy5FaH +PEsGjKfbOhSJO4A8BQiQJxM7FGlJgDzB2SHPlALjKVeAPHnboUgDA+QJ5Q5FahogT3ID5OnyBp0S +7wB5Ch8gLwZ0yKsKwHh5okNR6ADISyYAefGlQ1HGAcgLQh2K0hJAdytSAeTlrg5F4Qwgq8AB46W8 +DkVRECAvL3YoCpUAeckTIC+edijKsAB5QbdDURoGyIvMAHm5ukGnwjdAXkIHyIvxHYqyPkAuEOiQ +CQ0AccECQC596FCIKAByOUaHQtgBkEtEAHKxSYdCtgKQC2A6FFIagFyUA5DLezrkOiFgXHAEkEuX +OhQiKIBcTtWhEGYB5BIvgFws1qCT7AwgF7B1KKRwALmoDiCX53UohH4AuWQQIBcfdihkjAC5ILJD +Ia0EyEWaAJnaszMhGwXIBagdCikrQPdXTSwwLq7tUMh0AXLBL0AuHe5QiJABcjlzh0IYDZBLrAFy +sXaDTrJvgFxA3qGQogPkonaAXB7foRDaA+SS/Q6F+B8gbyMAyBsSOuSdDcB4iwRA1mvRmWjaAMjb +PzoUjSQAeUsKQN7c0qFokwHIG246FK07AFkPEDDeTNShaEsCyBucAPJWqQKdm64A8vatDkUjGEDW +UQaMt6Z1KAZhAuQjNTsUHqufBJWa3/ntAPIP3qEf6877tBbPZY616oJWonvC5z/KBM9Z2P8Rgy51 +vLJOyHXZTy2ec4DaPsxh6z4nbyV65u1nG/rpEzwVUUw4f3+7PS7ympg485N6PD/fN8sez8/yzfbD +7MW6PFX7/dgIz6MGPE+6DoLLY65LG+F5glrXNUDev92h6AQHyHvKOxTd6R2KPneAvGO+Q9F736Ho +4gfI7AA6E74CHQqHAoDc66BBJ9eEDoX/AkDu5NCh8IQAyN0lOhQ+FR0KxwuAXp0zOuIGHJ1xIw9g +3BGkQ+Et0qFwKQHI/U46FM4pBTp7sABkZi6dcVMYYNxdpkM396npUDjeAOTeOR0KF54OhZ8PQO4M +1KHwGOpQuBUB5L5HHQoHpQ6FFxNA7urUoJM/FEDuNNUht6zqTHhfAeQuWh0KP64OhbMXQO4R1qFw +G+tQ+JYB5A5oHQovtQ6FKxtA7u/WoXCKa1BazgHj3nUdChc8gNxPr0PhzNeh8PgDyN0COxS+gx0K +B0OA3AuxQ9vdXBU7FP6MALnTY4fCM7JD4T4JkMslG3RyxATIvTU7FCLHDoXfJ0DuHNohkyZ2JJxM +AXJP1A6FoLBD4dMKkDu+dihkgB0KF1qA3M+2Qy7eA8Yddht08urtUEjuAHL/4A65EXFnQigHkHsj +dyhclju0ur4NIHd+7lB4SHfIZWnAuKt1h8IfG6Cnick6FJ7dDTq5fwPkGrAOhSN5h8LbHCBTbnUm +3NY7FL7tALngqkPhJd+hcKUHyGVSHQqnfIDcc79DoW7qUMwBAMgnCjTopEnqUEw5AMjnJXQopEQd +ihkOANkwiM6E/qdDMZ8CoN0mXXQoZDsdiukbAPkcjw6F2AYgny3SoZhS0qCTRAYgn5zSoZjB0iET +tgDiM2E6FNNlOhRyFIBs4E1nYnJOh0JDApBP8+lQzAUCyKUfHYpZRR2KqUcAuWCjQadJTB2KmU4A +PUxm0aGYM9UhH1gFjGsjOhQztDoU07gAcklDh2JCGEA+a6xDoUTo0MPnnwHkk9Q6FPqBBp2muwH0 +sDlxHYqqf4didh1APgWvQ1Gr79DrWD4gfLpfh6LADpBPHOxQzC7sUJTFAfJ5ih2KyYwdimo2QD4t +skDnuZMdiho0QD4Ls0M+VLMzURT+JEi1rcuc4A5ZkQ7D5d06Ex8boCjCVyguZYHOPwpAIVaoUNwo +HYpbDqDQdFQoHoMOxQMFUGhfKhQPOUAva0UnUh5UoVi8APJlsEMpo6pQLM0A+SLfoLPcrEKx8QDk +W1iHUpZXodhWAfINukOpXuyQBw0divCjQyny7JBFRJ2J0KpDqYXtkId7HYrAsUFnzXCHPJjtUITF +HUptdYc8VO9QBP0AhQS9QnEQ6ZCfaIAJpX6F4pDVoTiuAWT9DBWJ42OH4iAKUHR9FOh0OO5QHLMB +iu6YCsXRHyBPInQou4gqFIkNgDxF0qFstqqQZ22A8fRPh7InrUKRkgLIk1sdyta9Ap0SbgB56q5D +2eJYoUgnAuSJyQ5lJ2iHPFnaoUi7dig7ZjvkqeAORVK5Q9FX3BlPc3coEuYdyvbrDnkSv0GnckCH +sku9Q16i6FAUOwCyqklnovzSoSjkABSWBxWK4lKHokwFUDhDVMgrZ52JEhxA4Z9RoSgLNuhUYATI +bUYqEyVPgLx42qF0Y6lQFHQB8tJwh9K1pkJRrgbIC98dcm+fikQhHiAv6XcoHZAqFDIDgFyw0KCz +U1SHXETRoZBjdCiEHQC5RKRDITbpUMhWAHIBTIdCStOhEOUA5PKeDoVQqEMhOQLIxQ== + + + Sx0KGRRApqdqzEmY1aGQeAHkYrEOheysQyFgA8ilcB0KUV2HQp4HkAv9OhSSwQ6F+BAglzF2yPWQ +nQlhJUAu0WzQSewJkMtGOxQC1A6FlBUgF8V2KOS1HQqhLkAu+e1QiIc7FDJkgFzQ3KGQRncoRNYA +mVq7M676Bsbl4wU6C9E7FJJ2gFwc36GQ2XcoBPsAmfK/M95B0BlrRADEGxo6FK0RHYomC4C8XaND +0fgBkLeQdCiaURp0amsByBtkOhStNh3ynh1gvPmnQ9FG1KFoSALIW5s6FE1SHYp2K4C8catD0QIG +kDeTdSja0joUDW4A+VTNBuV4zk9hSr3v/GYA/Uhf3qf1d86eOo/uqg3lpvbF/25GeB6ZEZ90OWtL +9nfe73NDPmZxngXvNlGIzIX+MTM8dXeop3IWoAkaZGh3vf2xZnj2b5b9nZ/lm83fv+ze3zmn349O +8Zw/mSOijpOzNW57neJ5YlrduEPRBg6QN5QX6NyaDpA3uQPkFegOReM9QNbBD4xbAXQoTAUA8lJ2 +h8LoACC3TADIzRc6FDYOAHlRvEPuLAGMW1QAZF4XnQnTDIC8vg6QG3l0KCxBAHJzkQ6FTQlAXqkH +yK1TOhQmLAC5nUuDTsYwAHnNHyA3q+lQ2N4A5AY6HQorHoBcPQCQ2wN1KIyGADLHImDc+qhDIUMA +yO2YOuS+TsC4QRRAbjXVodAzAOT2Vx0KIy2A3JILIDf36lBIIwBywzGA3LqsQ2GCBpDbqTXoJLIA +yC3eAHKzuA6F7RxAbmDXoZBrAOSmegCZO19nwuYPIDcMBMh1Hx0KE0OA3A6xQ2GsCJBbNALkEpIO +hW0kQG5A2aGwsgRoNVNMgF7FKB25ukknQG732aEwDgXILUgBcllLg062qAC5wSpAbtXaoTB9BcgF +Mh0KI1qAVrO0BcjNcTsUNrsAudSmQ2H9C5B5CAPjZsQdCltjgFyzA5BbLXcoTJsBcvvnDoWRNEAu +/wHIza07FDbZAJnfdmfCuBsg1xEB5GbiDTrZkgPkBucAuVV6h0KRBJDbt3cojOABckt5gMybvjMh +bQLI7fI7FMb7ALmFP0A+DKBDIZICyOYTdCYGHQDkIxMA8uELHXK1FTA+DgIgHyzRoRhRAZAPu+hQ +6LYA8gEcAPkojwadhoIAZNNFOhMCMIB84AlAPjqlQzGEBSAf5wKQSck6EwNmALJJNZ2JkTcA+fAc +gFyT1qEY6AOQjwbqUAwZAsimFQHj4rYOxQAlgHwUE0A206kzMRwKIJfJdSgGVgHko68A8iFaDTqN +4wLIBHediQFhAPmoMYB8aFmHYvwZQC7dA+hiI9k6FMPdAPIxcR2KgXMAuQgQIB+C16EYpweQD+br +UIz4A+hVTgiIjxzsUAwvBMjHIHYoBioC5MJEgHzIY4diXCRAPngSIB9h2aCTxBEgH6vZoRjQ+WnQ +hG2XdR7E2fwe0nHVt+tQfPACnS9Bh+Jidih+lgrlD9yhuFU6FDddhfL27VA8CBXKR6pD9mh2JB7x +CuVi0aFYdiqUC1iHYinsUCyqFcrluUOx0Fcot4wOxebTodjGKpQbYodia+1QbNIVit2+MxE2FOgc +gHQoQpkORVBUoQyvOhSBWoUi4utMhI4diiC0QhnOdsjj4s5EgF2hDNU7FEF/hfL40KE4iHQojjQV +irNRZ+KQVaE4rXUmjn0digNkhfIo2qE41HYojscVinN2Z+LAXqDz0b9DkUToUKQjKpSJjQ5FiqRC +mWzpUKRtOuT5n8pkIqlDkZLqUCS3KhRZss5Euq1CmbjrUKQAOxTJxAplWrJDkeCsUGRKOxMp1w5F +8rZCmQbuUCSUK5Sp6Q5FkrtDkS4v0Dnx3qFI4XcoigEViqpCZ6I8UaEsdHQoSiYdiuJLhbKM06Eo +CFUoS0sdiiJVh6LcVaEsnHXIK3CdiVJehbIo2KEoL1YoC5UdipJnh6J4WqEsw3YoCroVytJwh6LI +3KEoVxfoXPjuUJTQOxTF+AplWb9DIRCokAsNOhKChQ6F9KFCKaLoUMgxKpTCjg6FRKRDITapUMpW +OhQCmAqllKZDIcrpUMh7KhQ6oc6E4KhDIV2qUIqgOhRyqgqlMKtDd5d4dSjEYgU6y846FAK2CqUU +rkMhqutQyPMqlEK/DoVksEMhPqxQyhg7FILICqW0skMh0uyQqz0rk7LRDoUAtUIpZe2Qa2I7E+La +CqVMt0Mh+O3Q06XDFUoRcodCzlyhFEZ3KCTWHQqxdoHOsu8OhYC8QilF71CI2jsU8vgKpdC+QyHZ +r1CK/zsUbQQdioaECkVnQ2eiRaJD3mtRmWza6FC0f1QoG0k6FC0pHYrmlgplm0yHouGmQtm60yHv +AepMNBNVKNuSOhQNTh2KVqkz9Dg3XXUo2rcqlI1gHfKOss5Ea1qFYhgmQD5Ws0OL26x+GnSu+ZW3 +61B88Ar9WHfeJ3V53hQ0LLP3PI/j6OOPMsVzHo4YP6mTw4/NutTR2GddPk9NnoePgwZcvqm1eJ7P +m/aOn/pec8PpeZzt8E2ff3koGvmUJs/P98Wyx/OzfDHl5O/W43m7al7oH3o8z5Xj5xwlZvOcVX/O +wM/rh78r9kDJfFl8hioTxd7KhPNRZ9xCqTJWn61EGDp1xp2hKhMl1cqEV1Vn3PSqMlEFrUzYcHXG +/bwq44XLjri/WGFORmWViVpjZ9w6rTJuwVaRKA92xj3hKhPmcpWJkl5n3O6uMuGbVxkvw3VkMx+/ +yoQhYGe8claZsCgszMnrsDNe7apMuC9WJmwcO2MFqoqErWRlwp+yM15Uqkw4ZlYmrDc743WgyoQZ +aGfcVbQyUbupTPicdsYNUwtzKrdUJixcO+NesJWJEkllwp22M+ZyW5EoalQmbHc74/69lYlCRGXC +Ubgzbk1cmagddMbNkisTrsuFOaX7O+M+0JUJQ+nKWIa+E25vXZnwya5MJNU7Y8bdFQkD8MpEGrwz +bklemfA274ynrisTbuuVCdv2zni2uTAnI/nKhCN9ZzxBXJnwyK+Me+13xFO6lQnz/8rEFIHOeBq2 +MjHXoDM+IKEykTqtTIxs6IzPfqhMZDsLc5pG0Rkfa1GZSFBWJgZtdMYndlQmcoqVeR0g0gEfQ1KZ +yAJ2xgejVCYmrFQmEned8ZkvlYnhMZWJZFtnfJzNmXmc5uJUJvJjnfFJPZXxiT8ViWzVJzFzzJ+o +bPbV+aLzfet7VSY/c4fiy1cor+IZKj9Hh+J3rVDeIBXKO61DcctWKO/9CuVD1KF4GiuUj3WHXheH +SuQSU6FcqzoUi16FcvWsUC7DHYr1vEDnjaFCucN0KLaqCuWeV6HcPDsUu3CFcjvvUMQFFcoAo0IZ +qXTII57KZORUoQzBOhSxXIUyKCzQObrsUISpFcp4t0IZOHcoIvAKZSjfoTgTVCgPFxWKQ0pn4rBT +oTw1VSiPXx2yU1xF8jBYoTxVdiiOpwU6n3MrlAfmDsXJu0J5hO9Q5AIqlEmFCmV2okOR5qhQ5ksq +FHmXzkT+pkKZCKpQZpQ6FKmpCmWOq0DnZFmHIutWoUzfVSjzgB2KhGKFMjPZoUhxVihzpRXKpGuH +IntboUwDVyjSyZ2JtHSFMr9doUyUdygy7gU6p+4rlDWADkUxoUJZleiQVzcqk1WSCmW5pUNRt6lQ +FoAqlJWkDkVJqkJR2qpMlsg6FLW2CmXRrkDn6l+HvIpYmaxGdijKmhXK+miFstDaoajYVihLvxXK +GnKHohhdIa9pVyRL4x2KGnuFslhfoaz6dyjkAwU66xA65NOFOhTThToU04UA8ulCHYrpQh2K6UIA ++XShDsV0oQ7FdCGAfLpQh2K6UIdiuhBAPl2oQzFdCCCbLtSY03ShDsV0IYB8ulCHYrpQh2K6EEA+ +XahDMV2oQzFdCCCfLtShmC7UoZguBJBPF+rQ1aYLdSamCwHk04UadJouBJBPF+pQTBfqUEwXAsin +C3Uopgt1KKYLAeTThToU04U6FNOFAPLpQh2K6UIdiulCANl0oc5cbLoQMD5dqEDn6UIdiulCAPl0 +oQ7FdKEOxXQhgGy6UGd8ulBnbLoQID5dqEMxXahDMV0IoMWmC3UopgsB5NOFOhTThRp0mi4EkE8X +6lBMF+qQTxcCxqcLdSimC3UopgsB5NOFOhTThToU04UA8ulCHYrpQgD5dKEOxXShDsWYHoB84E+D +cnLQJzGncl95r8rEh25MfvvG5GWsTPwejckftjJxhzQmb7XG5D1bmbj5G5NPUWPycayMP9YNyeWh +MbnOVCYWrDNzXvkak0toZWItbkwu6pWJ3aExuc00Jveryti214jYPBsSe3BFYi9vTAYFjcnoojIR +pjQm452zOOIcOFXGA7CGRBxXkYgHG5OBZWMyQq1MhLqNyZi5MRl8Vyai+MbkcaAxea6oTBxQGpMn +ncbkkakycfY6M+dDXGXiNNiYOFU2JE+nlYljbmPyvNyYPHhXJk7wjclUQGMyp1CZSE40JrMcjcl0 +SWUi79KYTOCcmVMiqCKRUGpMZqYqEymuxmSurDGZdKtMZO8ak2nAxmQ+sTKRmGxMZjgbk6nSykTO +tTGZvG1MZoEr8/G2tk/rjVzfdtWMJ9ibTW6ewD/GBMz5ExvdeD/C8x+bE3nPFsJt1r1sjtzk8jFP +4kRCF1UQ9XA/fvKbfT8Bc51g8jlbnSrbs2L9eHPkZ/xm2R35Wb7ZQ5583h05f++lO/J6395Un5/T +wyz5Wj6ucw3mBpaS4LqvE5z+3Tt0m08rH8iLlvIT9OUBPeYzztFJcqwrQhoBuqrWe/kIM3vl7arn +Xk81QNv2vMnGaDvUHASpGK5C0E396ACt6nSeWGc9akUATZh0nV9PVdydoatGlc7e+bHPJH3C7PRy +euFrOSesy2WV56AOIwRdH6pfPrePfSYZs8xzvCuAQGgCi8cmB4CrtiuCZknX0e/Br7Sqtn6VG9eE +oA+E5PB5k1PCsrV77jtouc2Ko0onfqZVtfXLRcLEoyJO0EU71vx8K91OMhx8SgF4Wz72QqscF+Yd +t8Myl6Dr5f6uo7vy2+kOWXXDfeQjaXryPFH3x8deaNFiIHeSI4gA6LYuUg5c9o+90lV9/teHLJ0/ +At0mMJYk87bzZZoIVHvlejnshyt0f9NRcU7JElDQsyJ30uushssVH8z7/NncSw95xO0fgWS6MWuq +tM4IKYja1oc2XXrm7m8yQXko6FgvdAvcVVq/ylxq/9grSXJ7k1b2udL9rfnHs+0uipTokbursi7r +ldmQVr4Csm55yGDq+uDLfXvIdUbi9Dv9ugPNEXUOlrOqfuSV5s3ui4y47he+4PNxdCicFeMjryRh +rpJJ9/uVoGVWHS2DygkudJ0WRVUXXYSFP9Myq87cAlKNH4cEgHZtT4qKHhv9dDL93mUhN2eSj7zS +LFyzV8v9b6UrviiEvRxS2cvjI5DEJQPsH/tMd+mcn0o+feSVlofCXGVprnSLDzRX4A== + + + Mb+xVl+EbhJBynLyY690nbPJ3AOS7tG6I6t9iUd0Rr7yb3dRiDL33CysdBfcFN2uE4Mvjx0XlYGW +WTHlCbPS555AXieCiVCUTmBIDj5Syz5xi77p1Hnd5jiwfewjbXofqWWfT/rpBpoTzFMepjf+SHJ/ +vD5miT7yWQBJ5C5/odsNr/dNJ/yr7u5ZyfjtjlOlzucfe6Xbkde4zIZ/p2flpuTF7GLPi845CM1p +edcePo8V3wNS3080s21H9p6gRd40d/mRAzNn+O0pHftNPQYMTQS/SSz7xJj3+vaYRen2OISuyOz7 +doxR2B94C1yVAZN3ozImdL2vs+zs67saHnfo69t6dGgo48sfSQb7c25+LstKl/s6q878rvP9thW3 +6KuyjddN1YcFb4GBbvIkmi143flHmcVkwp3t+njgFn1VIlVljuf9Y5/pqnyksrEfe6XLpnkLeoD5 +Clwmjp1fbe5LvAUubyoa3PfH7XI43QI0V1u9TJcJjukKDHS97IsOm/iRLrPoTMC/yveMLvdljqhX +uUjO74fR3kDzL0qS688RkpR203ntjk/TZRad2TCvs2vuuEEPdJO3oSKwB92WFxU95PJ73/Yr/bqX +WXRWCbO1qPJlmg1nOXI1+4UvwVUnMCllj/4LgrS8yYr+uvHb6bwjk6sdP9PyfHtOpKq02BVfSdDl +Ka3w7Iu01S/ya9Oiez0ePYTm7l+fmsuy0FYvSLMPjoYX2uoH2rRcHGaKdBcMpH1nlR/s4alK0G0e +8eeszTVp8c5oB1s0MGa78hXQEUSjW/YH/XSCZlPdNVfoEGcDdNNhbp6Y2Xs+Ah0OiZoHQwH9QNdl +U3eBNMx8BWa7uMtm/PmxzzSHJ/V6yBOZLvjjTY6y2nfWFS/4/NnckVfdKDe8CebPJvp6XOTeeKMr +/nibBUxNssqTIDPh53Wbh2n52Efa5Ms5F0mDThCanUIq78u7ITBA97m9bxPN414g5vY46tCPj73Q +LLpX7a23w1MWoPktHrpE+8de6bbMAXK5K+jnV7rucpO8Pe+H9y5Bl23W8Mtsdx95JVWpNHNiueMv +t8+6s6sfQGUqunllnDx3k5o3P/ZKD5mzPlSZXWGlH2g/6hqq89JmL2iWeZ0y7hveBPusO+qjlKfc +g674/raqRUUG8Vda6QVN8HG9z/H3Qcm7ge7bnOc0AOBoLwFoeeoemE14od1e0KJawRwyPvZKShbr +Rrl97JVus9dfL8op8hWYSEWnbdUq6TnY3xTGzbl3u3/khWaVuOqpnPuFIHnf65edvWClJOBAcx3n +jTRwgL7/MLMs3daLav10g2tEwH2X2f4EjvTDbW/bBEwyfH5eKGwQdJMCZlOdi9am7W3+bW65uxrk ++DPdn/s8wbPI3ygKF6Sa1ET0mpWA0ASWd+V/1EHFkNquH+rPpozbQHOvrUoQbNtHrtP888Rpd40g +osd3ICUZNgmlnnwTXI4xAzeNM6LrtL49VfBfVXDFVxrouu+qfO1P3O3Xt8e6LO+9q5TgWjToZW6D +OWhsTwqNBWm01vX4X36lbf7rCdXvy4K7vebhyOj3qg45vgSrvLqPDtCdrvg6684s8oclLu72snVV +qXPCtGWnx26ddedIuirlwq+kKrjq93NkodtX05Wem6Y+YUy0zrKzzs0kNdmN3+yiqSyzOM0KRjev +ZlCpUCZbd3yl+9tTn+Y4jOAr3d9kMa+3uuEmpkldi7zjJ+KhvOtAGnDzeOox5xdSpDO7xaqw9xOh +m/q3LpJEzNlbftvl3YDxj03Q6/cHxi9khfInIch+XID8NgHo9XYjxG5bgPwBAMgfJYLsoQTIH2+C +bKEAyJccgHzxIsiWQYB8QQXIl2aCbJGvUG4XAPnGQ5BtYQD5ZgiQb6sE2QYNkG/1BFnQAJCHHwB5 +IEOQhUQAeXAFkIdpBL3Ge8B44FihDEEJeo1lgfGgGCCLromxMB0gD/gJsqMDQH4IAciPMwTZwQgg +P2IB5Ic1guzYB5AfIAHyoyhBdqitUB6PAfKDNkF2ZAfID/8EWRoBIE9IAOSpDYJecyTAeLIFIE/b +EGQJIIAskwSMp6QIsuQWQJ4mq1Am3Aiy1B1AngQEyNOJBFliEiBPcRJkyVKAPO0KkOVvibFEMECe +UgbIk9MEWZobIE+YA+Spd4Isid+gUzkAIC8sEGQlCoC82EGQlU0A8gIMQF7KIciKQgB5eQkgL1QR +ZCUvgKx2BozV4IixYh5AXhasUBYYCXqtVALjJU+CrHgKkJdhAfKCLkFWGgbIi8wAebmaoNe6NzBe +QAfIS/EEWVEfIFMHAOMyA4JMsFChUD4QYxIKgFyMAZDLOggygQhALjUByEUrBJn8BSAX0gBkihxi +TNoDkIuEAHK5EUEmXALIFFDEmJSqQinKAsjlXQSZUAwgl5wB5OI1gkwGB5AL6gByaR5BJvIDyOWC +ALnwkCCTMALkYkiAXFZJkAk0K5RST4JMNAqQy08BciErQSaJBcjFtQC5TJegV70vMC4cBkgZ5B8k +yASZmBkgl0UD5AJrgkyqDdCr5JsQk45XKEXoALmcnSATxgPkEnuAXKxPkMn+AbL+AWC8EYEga2kA +yJsjALIuC2KsXQMgb/wgyFpIAPJmlAplWwtB1iADkLfaAORNOwRZ+w9A3kgEkLckEWTNTQB5mxRA +3nBFkLVuAeRNYAS9dpMB421pAHmDG0HP11a5Cu2z7siFeJnfjjJuJ6hqAX+0M++TOjx1epoDz6aO +QbUkf/7pl5uST9maqMPcuTVxQuEfypjHkG/rg5y989TgOU+u2iDnmKRc5yabzZ/8Vgpijv7OOSTq +WigWnxvvR/o7P+v3OrV3fo7vpeHk3t25eXenCsIqFq2XRWY5H/75ciyJ8+5Kns+57e/ea71X1Qtn +STqc2JP58p25PyY2u9wuh3EHMK81447MY6bpx7O4L/gyz23itrkAR5TfkFXZjrsOXtsxAh2Yu2ZD +3NX2Xr75l6Xu3JmrHtx5HCd6w88zJw49S0pC3ZGZFV+nnPsRRnVmFs2bnsRN+QJArHrdGZn3zIl6 +Prg2BmDkPjPRzzzw8GspEpGt/lOu2/h57rd3D/f75Y6X0EvgnVnnZDuR6GETgsycfeZGlNswfi/p +DObwd8xNIGaevvU+J/frQ4dyYKyODsy7PfJyf9IdL5twBZfLhDz8W+zz3KwKMS/8W2jWi06sz/WJ +r+PFeGDmtrgffhAXfJ3nMj/GRAOzIOI1lKHQ83HTkAu4hrOQXuQTobMMLSxZ0Qfmsc4CqWrPDp9H +ZvPzJof1BP0Wm9JROqQuy0q/xUReE59usgS60tKSsgBg5qvPn2nQMX73RcNU7pumLMNzocV9nTvn ++rweI0eAmV/0epUupi3yXxZtATDzXOmwPw8Pfvf1MgudUiz0mCpQnJBr3e4qvyKjIPguzzL85i5P +AEYTaTRVaadFXiMdNPdgU7YDFudh7prfdL1sT/4ldtkxSC9wp0U+NQ7ArPs2n0X23PiZ53Rze8xm ++27D1pnnrDvKB943/CWec75f5Jh0u8PHSaEEMHNGfm7z9Rf6KTQX5KmyyTL/Fz7yrjTfRQbvN3q2 +dtWpVKWYO4OuYKgtALnPh31IK3PFTzxXWNPKH7rjiVkmiJgTz+N9YgYw6zE1ZSItWlZSstGZ+7JP +QKJ3o2VFg2XW2ZHnIb7TEr8r3Ti71kQtT9puhzlOoHfV8vDzuO6jM5t+zUVWY7SsaPaO5lg9FZDh +6+wTiOn5WnfabndV3ZRmlfSHX8fEI52RAHKOBJq2ga8zAfWcjTTC54m/+zzlE83OpruueDtPZKRY +7K7JOsiYAqUxD8kotQdqUYDX0QSnVev39bnTbzHM3Babis7LDa6PzC1vengkakPEVCydkRRT4430 +dCBznxDiKbuxBXb2YSbMv0yIJDc6Yha5TW237bLRbptSmM5I0TkH4XkSKfIZZrYtSVh0FZF5zOo0 +V+jIp3RkVV5mIllFWciYngYYRYSzKMz+hh9HGd759hPX8U+hmVbKgmhpIWZW08dNvl1XWuNDlAPI +QxMVrlJbIDP3xZyeddPjN1dZQhWqiQ/wRp1V57ktw9EJJnU9wMjH9bLNiYB+iOfbHI6lSpsPTMvK +U0npu6L9y5WW+KcqqxOIXJ6K1YhxcRAwmmS2aF2Fi6xhhHN2Uxxyp812GI0Nuyj1Rwcq+ZC+Dyl7 +HuMKO+MCI2AmHr4o5bfhx5n4fZZTaXBosx3mPiHWLLvz9OBHvj+kSJ4Tyo0W+BApAbJdD8NhbV3E +bMe0pfsszLSoDDNn7blVZ1XhX0KP1KLhKBda31PpBMwqVcoEEEeNBRiFehOHzCfCG+yhjOF+15ET +f9GHvFzn8bo9+KdwuRQwkkCp0+DwlgXmsc3PMR95hQVegqq5LR5SQV0gdhQzP8ZVg6022GtPmitg +5l4/nsFjlBww8mNeNJwT32qipmWR9OUBoaMYad0vxzgu/Oqu2+qMDGgnjL1d7/BUiNlvs0lIKdbv +Hmm2rlcNYZuzPRynxKhQoClNV4h6TtqvzkjCrMLykxYNMTq26VUefJm3+bTX/aaELX6eTcNdlbh/ +8k/hArLOzJY+9+gu31h8r3lq5MJ9SHORmdBRqonLR67hxJXzXGnX5t/LdWidUQZiDttPhenITHC1 +K4WwwLFezFMZxes+Pxhcw6uEAKuGw+qpR+ZVzNYRCbLn347sEjJ3TQPUTDH8NBrvpbSJxBLETHhw +DAXd8QqmIA6YObMtKkMtsEuqoKP14rHN1gQBy1H0mchyTopqpyFGOoqrBupd+JdwVR0wz2OO2vwe +sMZLUzeP8Tzvq3JryOgGfGoUIKzx0t0pvTDX73aMuQTGtHnAPJQEnt3gCUG8lHk3BQlqOuPfYo5a +9105wwv/FnOSuuo4MDEUfncT+AGyK86/a/YfMuqxmgVjDjn8U7wHB/Oddv4pnvMkKznwOBSXjQmV +ICB6HFRjvK/wVre3Q/M011l3/Scyx+M2a8RDZuErvBlA9qEbc/ryAPlVBMh/jg7F7wqQ3R/A+H3W +obhhAfI7v0PxCAHkzyJA/lB3KFYHgHyZ6VCsVwD5wgeQr6AdiqUYIF/TOxSbA0C+ywDk21WHYt8D +yPZPYHwf7pDv58B4XNCgU4ABkEcqAHnI06GInQDyIKxDEc0B5GEhQB5fdigCVYA84gXIQ+cORQwO +kAfzHYpTAUB+vADIzykd8vMOMH5u6lAcwADykxxAfiTskB8tgfEjKkB+1u1QHJoB8tN3gc7HeIA8 +HwCQJxY6FBkKgDzV0aHImQDkyReAPIvToUgHAeR5JYA8QdWhyHQBZBmzzkTmDSBP4QHkucAOeU4R +GM9NdiiSnAB5thQgT7t2yNO3wHgauEORTwbIE9MAeYa7QadUOUCecwfIcvediRoAQFZL6EzUJACy +2gYwXiPpUBRbAPKqTYei/AOQ15EA8oJUh7ywBYwXyADySluHomQHkNf+OhRFRIC8Gg== + + + CZCXNTsU9VGArM7amajXAuSFX4C8gtygUykaIK9pA+TF8Q5FlR0gL9d3KOr+ALmAACBXInQoJA0A +uTaiQyGyAMjVGgC57KNDoR8ByIUoHQpFC0AujQHINTYdCrEOQK76AcjUQ50JFRJApmbqTKiiAHJ5 +FUCu02rQSfAFkAnHOhMCNIBcyQaQS+I6FNo6gFykB5Cr/ToUskGAXH/YIdcxAuN6SIBMV9mZ0GcC +5ELPDoViFCCXngJ0NQ1rh0IMC5CragFyeW6HQucLkAuGOxTKY4BcwgyQa6EbpNS3iaoBcnV2h0Lm +DZDrxQFy4XmHQsEOkEvhOxSaeoBcnA+Qq/w7FO0CAHnfAUDewNCh6IQAyFsqOhS9GQB5kwdA3i3S +oWg7AcjaVzoTbTAAeT8NQN6Y06Ho8AHIW4UA8p6jBmXvEjA364HqkPdSAeM9WQB5c1eHoksMoGWi +mG3W+gv+KOlS+mlQEfOc3q0zH21u+6T+SB3YZ8OZ22g2KBldfvb+SM2JnGXjqmrRpjrBHB2P9m9v +7psNO/sIt+gjnH84NUjuN/URqoY2x5W76oPPn/5e3zdIbleduC/K9M0bfsoAzM/3xbJD8rN8MblL +eYfkbVtz/qV1/sqIY2IeDQVVC+jju/mX3kN8gr48NyMTY13NAHl/NEHWaQ2Q92wD5N3fBFkfOUDe +kQ6Q97YTZF3yAHm/PUDeuU/Q7dUDoELH6vLiJgCQ+xIQZA4HALlXAkGvpgvAuHsDQO4DQZA5SgBk +1hTAuMcFQeaWAZD7bgDkDh4EmRcIQO4qUqH0JyHoxecEEPdLIcicVwByDxeA3A2GIPOVAcgdagAy +qxtizDMHIHffAch9fAgyRyCA3FsIIHcpIsj8jiqUzkkEmQcTQO7mBJD7QhFkDlMAuVcVQO56RZD5 +ZwHkTlwAuacXQeYOBpD7jAHkjmUEmfcZQO6iVqH0YyPo1dgNGHeII8i85gBy1zqA3P+OoFcjPWDc +kQ8g9/YjyFwCAXK/QYBu5lxIkHkgAuRuigC5LyNBryrIyqRTJEHmOQmQaReBcRdMgsxPEyBXHAJk +Fp/EmFcoQC4TBMj9SwkyJ1SAXNwHkLuzEmQ+rwCZJo8Yc56tUHrYAuRKOoJebXWBMXteYFz9RpA5 +BgPk3sMAuWaNIPNDBsidlQFyqRlB5vYMkPtGE2QKMYDcy7pBJ1dsgkzXBZA7dQPknt8EmRoLIPch +B8gdzQl61VAB4x7rALlbO0EmfQLIHeQJMi96gFyxBJD74xNkTvsVSp0RQO7+T5DNEQDI9EHA+GQD +gmxGAkCu6gHIxjYQY/MfAHItDkA+k4Igm24BkCtoCLKJGwD57I4KpfCFIJsnApBPJgHI5SoE2bQU +gHzuCkAuMiHIZsEA5FNlAHJpCEE26QYgn5lD0KugAxif4gOQjQMixmQYFcoJRQDZqCNiTDwBkE9f +AsjnOBFkkgeAVpstBZBPqSLIpAoA+eQsgmwGF0AuMADI54IRZBPGAHJZQIXWmHpGkM1PA8iL+QD5 +TDeCbDocQF6CB8gn1hE0f/TD7DuAvHBOkM3jA8gn+wHk5W6CXmYNAnK1mYUAeY2aIJujWKGcyAiQ +lZaJsRmRANmwSWC81PtpkCS9N+liJ8BXJNXerTPxsQGy79+ZuJANOv0kAPmP26G4TTpktxsgftt2 +KB6ADsWjBJA/lB2KxxsgXyg6FEtOh2LxAsiXwQ7FgtqhWJoB8kW+QaftokOx8QDkW1iHYjPsUGyr +APkG3aHY6gHyoKFDEX50KAIZgDwk6lAEVx2KMA0gi/c6E4Fjg04hKEAWy3YmguIOeXQNjIfpHYqA +HyA/OnQoDiEdiuMMQH4w6lAcsToUhzWA/NjXoThAdiiOogD5obZBp+Nxh+KgDZAf2TsUh3+API3Q +oUhIdChSGwBZjqQzkWzpUKRtAPIEUIc8k9SZSEkB5MmtDkWarEGnhBtAnrrrUCQBOxTpRIA8Mdmh +SHEC5MnSDkXatUOevwXGE8EdipRyhyI5DZCnuTsUCfMOReodIE/iF+hcDuhQFBYA8hJFh6LYAZCX +TToUBZgORSkHIC8KdSjKSx2KQhVAXvLqkNfOOuM1OGC8mNehKAs26FRgBMgqlZ2JkidAXjztUJRh +OxQFXYC8NNyhKDJ3KMrVAFnduzNRQO9QlOIB8qJ+h1wd0JmQGQDkgoUGpfIBGJdQdCjEGB0KWQdA +LhDpUEhNOhSiFYBc/tKhENJ0yBU5wLi0p0MhEupQyI0AcuFSh1wBBYxLqRp0EmV1KORdALlQrEMh +OetQiNcAchlch0JQ16GQ5gHkIr8OhVywQyE8BMgljB0KMWSHQlYJkAs0G3SSegLkotEOhfy0QyFk +BcglsR0KcW2HQqYLkOl9OxPC4Q6FBBkgFzN3KGTRHXq4wBogl2p3yCTfgLh0vEEnEXqHQs4OkAvj +OxQS+w6FWB8gl/13yPsHOhONCAB5S0OHojmiQ95lAYy3a3QoGj8A8haSDkUzSoNObS0AeYNMh6LV +pkPRtAOQt/90KBqJOhQtSQB5c1OHok2qQ9FwBZC3bnUomsAAsm6yzkRbWoeiwQ0gmzVZoZxa+WlQ +0wKe3g6gj3fmfVp/p27dWQVk4nhTIeeP0d8560wMb9SP/6NzIh/RBrnu+6m/c45024fBNy1521PF +g9nPfuqbfd/guW863y6yGdh/fALm5/1m2eD5eb6ZwgDr8FSb88dGYG7Kgyyzlc/R9bHP6abNwDxB +X35xbrgm6LW8DIy3gBP02ktemWxKJ8ja2wmyOjVA3nJPkDXvE2Q2AACZnwAxVvIGyC0OCDKzBILM +dgEgN3AgyIrnALmpBEFmT0GQGV0A5JYZBFkZniCz8QDIDUEI2l+tRQBykxKCrKBPkBmnAOQWLASZ +mUuF0haGIJMGEGRWNQC56Q1BZp8DkBvxEGQiA4LMHAggtxkiyAyLCDLrI4BcrkCQ2TEBZL5OxJhB +FEGvTlPAuOyBIDO/AshttAgyQy6CzNoLIBdQEGR2YwSZcRlA5oBGjFmpVSilGASZvRtBZhQHkDnO +EWPWdQCZqIMYM9MjyGz5AHKDP4LMKpAgk4cAdDf7QoLMCBEgt1QkyMwZCTKhCUBuGEmQWU8C5CaW +BJkdJkEmWQHILToJMrNPgNw2lCAzICXIxC8VSlNUgsxelSAzagXIHF+JMRUNQG5CS5DZ2RJkxrgA +ucUuQabHAchtfwkyA2GCXp2IgXFLY4JM2UOQ2SwD5IbNBJn1M0BuIk3Qq0aIGLO1Bsj8sYkxo22A +zLGbGNMaEWQm4hVKO3KCzNicILNIB8hVSwS9urYD4/bvBJmRPEFmSQ+Qy58IenXJB8bt9gky436C +bAQAQKajIsaGEgDk4w0IskEJBO2vIxcAckUWQTYGgiAbKAGQj6YgyIZcAOTaLoJs8AZBNsKjQadh +IATZWBGAXCVGkI06Ieh1ZgowPnyFIBvjQpDJzQDy0TIEvc6oAcaH3RBkY3MIMt0aQD7KhyAbCgSQ +jxciyAYVEWQKOIB8eBJBNoaJIBvoBJCPhiLI1HQA+bgqgmzwFUE2QqtCOYyLoFddHjA+Hoyg1zlj +xNjAMoBuNvqMIBP4EWTj2ADywW4E2Yg4gHzYHEEmFSTIBuAB5KP0CLKhfABtNt6PIFMdEmQjBwHy +4YUE2RhEgFTa/GGgIkGv+kVibMQjQD4skiAbO0mQDbCsUCghibGRmgD5cM5Pgtb1TefbOQGtd63r +9e0Iev3clckLQJBdSoLsRwHIf16CXu8TYuyGA8hvXYLsIQDIHyeC7MEkyB5xgHyxIMiWHYB8ASPI +lkKCbFEFyJdngmyhB8i3DIJs8yHItjGAfEMk6HVnJca2aIBsryfGgoYKZfhBkAUyBFlIBJAHVwRZ +mAaQB3wEWehIkAWhAHk4S5AFxgRZiA2QB+sEWdgPkB8gCLKjCEF2qAHITkfE2DELID+wEWRHP4Ls +EAmQnUaJsWMtQXZABsiP2gTZob1Bp+M/QZZIIMhSEgB5coMgS5MA5AkXgix1Q5AlgQDydBJBlpgi +yFJcAHmyjKDXrBswnr4jyBKBBFlKESDLTRJjSU6APF1KkCVeCbIULkCWCybGksoAeXqaIEt0E2Qp +8wpl8p0gS+MT9FoPAMYLCwS9ViiA8VIHQa81E2Ks+AKQl3EIsoIQQF5aIsiKVARZuQsgq5sRYwU4 +gqyUB5AXBQmy8iJAXqgkyEqeBFnxFCAvwxL0Ws8FxgvDBFmJmSArVlcoy94EWQGdICvFA+RFfYJM +HgCQCw0IMskCQSZ+AMhlFASZIAMgl3YQZCIRgkxuApALVwgyCQxALqYhyGQ5BJnAByCXChFkoiOC +XtVLwLgMiqBXPRUwLswiyCReBJlYrEIpOyNoedGvAeNCOIJMUkeQifMAcpkfQSYYJMikhwC5iJEg +k0MCZLpKYkygSdCr0hMYl4wSZOJTgFzGSpAJYgkyaS1ALtIlyOS+BJlwGCCXIBNkYmaAXBZNkAms +CTKpdoXWEH0TZPJxgFyITpBJ2gkycTxALrMnyAT7ALn0nyBrIiDI2hEA8sYGgu6vLRIEWbMFQN62 +QZA1gADkrSQEra9NKQRZewtA3ihD0GvHDTDeukOQNQERZO1EAHljEkHW4kSQNUtVKLquiLm9tm8B +ZH1gxFhDGUHWmgaQN7kRZDM1AXIz1k+Cqgoo346gj3fnfVqT5zLx9eV+eSphrnLAH6PJc75yzJ9U +8PWjsy5PrZBz72WT51MHlcdFbYyyHVFP4xwlfuqbfd/kqQ/9kGPUPp/8U6Z4fsZvlk2en+ebnZs8 +JxL76BjP7fEmF6vHdW4kFQDrGM8T9OW58ZoY6+AGyHvBCbKucoC8Px0g73Qn6PraMw+Qd98D5H38 +BF1fHQEAcm8BgNylgCDzO6jQGs4JALkHA0Hm5gCQ+0IQ9GowAYw7VQDknhcEmXsGQGbDAYz7eRBk +ziAAuccIQO5WQpD5ngDkDioVSi8Wgl48XQBxbxiCzGUGIPerAcidbwgyDx2A3I0HILP1Icb8gQBy +pyGA3LOIIHM/Ash9lAByRyaCzNupQukSRZD5TQHkzlUAuQcWQeamBZD7cgHkDl8EmVcYQO46BpD7 +lxFkTmgAuacaQO7ORpD5vAHkjnEVSu85gl5N7IBxNzyCzFcPIHfoA8i9/gh6NQ0Ext0HAXIfQ4LM +EREg91YEyF0aCTK/R4DcORIg96AkyCScjUlXTILMXxMgF7p2xh0/CTLvUIBCD9whszMlxnxRAbq7 +bLpD7tVKkLm+AhTy8g65Ey1B5mkLkIvwgTGX3QqlXy9A0asA0KuFMDBmRQxMdHQAZO7IALnPMkDR ++QKQeT8D5C7SAEWDEEDmbA2Qe2QT5H1UHXLf7gadHMAJ8n6zDrkrOUDub06Q9+V1yD3XAXL3doKs +fbEz7icPkDvTE+RNnh1yt3yCzHcfoOiF7ZDPAiDIpgpU6NQz3KGHTTogyGYmAOSN1Q== + + + nfEpDgTZPAiAov+8QzaighibdQFQdOl3yOdvEGSTPAAKNwOAbLoIQD6npEIn0weAbHYKQD6FBaAw +xwDIJsMA5DNmAAoTEYBs7g1APkEHoDBbAcim+gDk84EIurx60nTGJxYBZKOPiHHjngblNCaAbKwT +MW5v1CGfNAWQz6wiyG2gOuRztAC620Qugtwsq0M+JYwgmzcGUJiKdehqM9AIsmlqAIX5WoPWmPBG +kM2KAyhM6jrk8+sIskl4AIWZX4d8Oh9BNucPoDA9BMhmDwLkUwwBCnNIgF7mKgLi8xkBCgdNgGxm +ZIVy+iRA7jMKjM3DBMgGawIT9d5PgfblTcebufmkXZjdv7wbMP6xCXr9/sD4haxQ/iQE2Y8LkN8m +AL3eboTYbQuQPwAA+aNEkD2UAPnjTZAtFAD5kgOQL14E2TIIkC+oAPnSTJAt8hXK7QIg33gIsi0M +IN8MAfJtlSDboAHyrZ4gCxoA8vADIA9kCLKQCCAPrgDyMI2g13gPGA8cK5QhKEGvsSwwHhQDZNE1 +MRamA+QBP0F2dADIDyEA+XGGIDsYAeRHLID8sEaQHfsA8gMkQH4UJcgOtRXK4zFAftAmyI7sAPnh +nyBLIwDkCQmAPLVB0GuOBBhPtgDkaRuCLAEEkGWSgPGUFEGW3ALI02QVyoQbQZa6A8iTgAB5OpEg +S0wC5ClOgixZCpCnXQGy/C0xlggGyFPKAHlymiBLcwPkCXOAPPVOkCXxG3QqBwDkhQWCrEQBkBc7 +CLKyCUBegAHISzkEWVEIIC8vAeSFKoKs5AWQ1c6AsRocMVbMA8jLghXKAiNBr5VKYLzkSZAVTwHy +MixAXtAlyErDAHmRGSAvVxP0WvcGxgvoAHkpniAr6gNk6gBgXGZAkAkWKhTKB2JMQgGQizEAclkH +QSYQAcilJgC5aIUgk78A5EIagEyRQ4xJewBykRBALjciyIRLAJkCihiTUlVoCVEWQC7vIsiEYgC5 +5AwgF68RZDI4gFxQB5BL8wgykR9ALhcEyIWHBJmEESAXQwLkskqCTKBZoZR6EmSiUYBcfgqQC1kJ +MkksQC6uBchlugS96n2BceEwQC5BJsjEzAC5LBogF1gTZFJtgF4l34SYdLxCKUIHyOXsBJkwHiCX +2APkYn2CHq+yf4D0R3/oHwDGGxEIspYGgLw5AiDrsiDG2jUA8sYPgqyFBCBvRqlQtrUQZA0yAHmr +DUDetEOQtf8A5I1EAHlLEkHW3ASQt0kB5A1XBFnrFkDeBEbQazcZMN6WBpA3uBFkczUrlBM6Pwmq +WsB8O4I+3pn3aR2ec8ic6FIOhE/Zlf53NMbzeZp1ec8Gz+WqXNvj8pgj58Ta82ztc6f+Y6d4znP3 +9pwYc5mF4/ZJDZ6f74v9/I/yxeTQGUM85wz1sSmeD5U2dS6/XrYj0mxTPE/Ql1+cm64Jeq0uA+Nt +4AS99pNXJhvTCbIWd4KsTA2Qt90TZA38BJkVAEDmKUCMVbwBcpsDgswwgSCzXgDITRwIsto5QG4s +QZBZVBBkZhcAuW0GQVaFJ8isPAByUxCCzF4EIDcqIcjq+QSZeQpAbsNCkBm6VCitYQgyZQBBZlcD +kBvfEGQWOgC5GQ9BpjEgyAyCAHKrIYLMtIggsz8CyNUKBJklE0Dm7USMmUQR9Oo2BYyrHggyAyyA +3EqLIDPlIsjsvQBy/QRBZjlGkJmXAWQuaMSYnVqFUolBkFm8EWRmcQCZ6xwxZl8HkGk6iDFDPYLM +mg8gN/kjyOwCCTJ1CEBuYUiQmSEC5LaKBJlBI0GmMwHITSMJMvtJgNzIkqD7qyUmQaZYAchtOgky +w0+A3DqUIDMhJci0LxVKY1SCzGKVIDNrBchcX4kxEQ1AbkRLkFnaEmTmuAC5zS5BJscByK1/CTIT +YYJe3YiBcVtjgkzYQ5BZLQPkps0Emf0zQG4kTdCrRIgYs7YGyDyyiTGzbYDMtZsYkxoRZEbiFUpL +coLM3Jwgs0kHyEVLBL06twPjFvAEmZk8QWZLD5Crnwh6dcoHxi33CTLzfoJsDABAJqMixgYTAOQj +DgiyYQkE2dgFgFyQRZCNgiDIhkoA5OMpCLJBFwC5tIsgG75BkI3xaNBpIAhBNloEIBeJEWTjTgh6 +nZsCjA9gIchGuRBkajOAfLwMQa9zaoDxgTcE2egcgky2BpCP8yHIBgMB5COGCLJhRQSZAA4gH6BE +kI1iIsiGOgHk46EIMjEdQD6yiiAbfkWQjdGqUA7kIuhVlgfM1UaEEXR/mTVGjA0tA8jHnxFk+j6C +bCQbQD7cjSAbEweQD5wjyJSCBNkQPIB8nB5BNpgPIB/xR5CJDgmysYMA+QBDgmwUIkA+VJGgV/ki +MTbmESAfGEmQjZ4kyIZYViiEkMTYWE2AfEDnp0GzFE/4+1TEpaexvx1A9rkbc7oAAPmlBMh/lA7F +zwuQ3SfA+A3Xobh1AfKHoEPxOAHkDyZA/oh3KBYLgHzZ6VAsYAD5UgiQL6odiuUZIF/oOxRbBkC+ ++QDk21iHYkMEyHZWYHyL7pDv9cB40NCgU/gBkAcyAHlI1KEIrgDyMK1DEfAB5KEjQB6EdijCWYA8 +MAbIQ+wORbAOkIf9HYoDBEB+FAHIDzUd8tMRMH7M6lAc2ADyox9AfojskJ9GgfFjLUB+QO5QHLUB +8kN7gc7Hf4A8kQCQpyQ6FMkNgDxN0qFIuADkqRuAPAnUoUgnAeSJKYA8xdWhSJYBZFm3zkT6DiBP +BALkKcUOeW4SGE9ydijSpQB54hUgT+F2yHPBwHhSuUORngbIE90Aecq8QafkO0CexgfI6gGdicIC +QFah6EyUOgCymgkwXnzpUJRxAPKCUIeitASQF6kA8nJXh7xuBowX4ADyUl6HoigIkJcXOxSFSoC8 +5AmQF087FGVYgKye25koDAPkJWaAvFjdoFPZGyAvoAPkpfgORVEfIJcHdCiEBgC5ZAEgFz90KGQU +ALkgo0Mh7QDIRSIAudykQyFcAcglMB0KMQ1ALssByAU+HQqpEEAuOgLI1EudCRkUQKan6kwIswBy +iRdALhZr0El2BpDp1zoTQjiAXFIHkIvzOhQyP4BcMAiQSw87tLmIESCXQ3bIdZXAuEATIFN6diYk +owC5+LRDIWMFyAWxALm0tkMh0gXI5b4AuXC4QyFBBsjFzB0KWTRALrAGyKXaDTqJvgFy+XiHQogO +kEvaAXJxfIdCZg+QC/Y7FNJ/gLyJACBvR+hQNDYA5C0SAHmzRYeibQMgbwDpULSSAORNKQB5e0uH +olEGIOu46Uy07gDkTUAAeTtRh6IxCSBvcQLIm6UalF1XwHj7Voe8DwwYbygDyFvTOhRNbgDZWE2A +3Iv106CmAjq9HUAf7877pB7P2xwhl0V5rdvcArPw/jF6PFVB8PGTqhb82KxLZXW8F3Ie9mzyPJxB +Zve9zpZ2nWhLRhk//c2+b/K8Xt4es+vdJn5SXvHHmzw/4zfLLs/P883uyjG9dnnedEd9bIrnc3lT +QvS6LbNez51Up3ieoC/PfdfEWAM3QN4KTpA1lQPk7ekAeaM7QdYyD5A33wPkbfwEmSEAQG4tAJCb +FBBkdgcVSuMEgNyCgSAzcwDIbSEIevWXAMaNKgByywuCzDwDIHPhAMbtPAgyYxCA3GIEIDcrIchs +TwByA5UKpRULQS+WLoC4NQxBZjIDkNvVALSZ8Q1BZqEDkJvxAGSuPsSYPRBAbjQEkFsWEWTmRwC5 +jRJAbshEkFk7VShNoggyuymA3LgKILfAIsjMtAByWy6A3OCLILMKA8hNxwBy+zKCzAgNILdUA8jN +2QgymzeA3DCuQmk9R9Crhx0wboZHkNnqAeQGfQC51R9Br56BwLj5IEBuY0iQGSIC5NaKALlJI0Fm +9wiQG0cC5BaUBL1KISuTppgEmb0mQCZgBMYNPwky61CAXHYIkLmZEmO2qAC5VhAgt2olyExfAXKF +H0BuREuQWdoCZMI8Ysxkt0Jp1wuQy+kIenUQBsaciIFxCRxBZo4MkNssA+TCNYLM+hkgN5EGyPVm +BJmxNUBukU2QycQActvuBp0MwAkycRdAbkoOkNubE2SSLIDcch0gN28n6FVIBYzbyQPkxvQEmf4J +IDfLJ8hs9wFy2RJAPgqAIBsqUKEUGwHkgw4Iur6OTADIRELA+BAHgmwcBEAu7QHIJlQQY6MuAHJB +DkA+foMgG+QBkMtoCLLhIgD5mJIKpfqFIBudApAPYQHINSsE2WAYgHzEDECuNCHIxt4A5AN0AHJ9 +CEE21AcgHw9E0KuqAxgfWASQTT4ixrQYFcphTADZVCdiTEEBkA+aAshHVhFkugeAfIwWQD6QiyDT +KwDkQ8IIsnFjALnKACAfgUaQDVMDyLUBFcoBbwTZqDiAvKIPkI+vI8gG4QHkdXiAfDgfQTbmD6C7 +Vc8JuryOHgTIhxgC5DVvgl7GKgLi4xkB8kI1QTYyskI5fBIgqy8TY+MwAbK5msB4vffToNn5Nu2g +94tu+vpmFYkP3Rn78hWJi1iY06/RGf9ZKxP3R2XsNuuE362Vidu+MvH8dMYfxMrEE90ZXxoqE2tM +ZWKx6oyvepWJ5bMysQ53xhf0wpx2hsrEFtMZ36sqE5teZWL37Ixvw5WJ/bwzHhhUJiKMykSo0hmP +eSoTwVNlIgrrjEVzFYmosDCn8LIzFqZWJMLdynjY3BEPvysTcXxn/EBQmThZVCaOKJ3xs05l4tBU +mTh9dcaPcZWJ82Bl4mDZGT+hFuZ01K1MnJk744fvysQpvjOeDqhM5BUqEwmKzliioyKRMKlMZF46 +4ymcyngqqCKRUuqM56YqE0muwpyyZZ3xtFtlIn9XmUgEdsYzipWJ1GRnPMdZmUiWVsaTrh3x5G1l +IgtcmUgnd8bz0pWJBHdlIlPeGU+5n5lz7r4yUQTojFcTKhNlic54faMyUSipTFRcOuOlm8pEDagy +UUzqjFelKuPVrYp4kawjXmyrTFTtCnMq/3XGyogViXJkZ7yuWZkokFYmKq2d8ZJtZaL2W5koInfG +itEViaJ2ZaI63hkvs1fGy/UVibJ/Z1w/UJjUIXTE9QyVCWFEZUJh0RmXalQmNB+VCfFIZ1yFUpmQ +s1TGZTEdcXlNZUKnU5kQ/HTGlUOVcQVSR1zJVJglJVGVCW1VZ1ykVZlQe1UmZGOdcf1ZZULIVplQ +xHXGpXWVCY1eZULs1xlXDVYm5IeVCR1jZ1wQWZiTsrIzLtGsTGg9KxOi0c64+rQyIWOtTOhhO2O6 +2oqEPrcyIfTtjCuGKxPS48qEhrkzLoaujGmqO+HS7MKcNN6VCbF4Z1x1XpmQr1cmdPCdcUF9ZVyY +X5EQ+HfGOwUqEy0HlfHWhY54C0RlopeiM96UUZno7ijMqU2kM95vUploXKlMdMB0xltpKhM9OZWJ +5p7O7NYlVJloN6pM9C11xhugKhOdVJ2xjqyKRGdXZaJFrDM2l7IxOeDyk5gmpTu9GQ== + + + QB9vbPu0BkkVWNY5U9zWy6JT4GdvkNyUJspZkfups6/Misw2wjn/nBokZ+++fZjT8Dze62yvT6UQ +bz/5zb5vkJyrsd3nSZlAef/xBsnP+82yQfLzfLNTg+R81dcxmJcPP/v6i3/2n+b//u0X86XfZsub +M4BiEG2fcynUQv5YZMl3O3olh1FT+XPXmq08RzIi1L59f8wp4Ig6z4Tu3eMBWI7CzTswO9NVi/z+ +4Vdf3JX03GbLe6rqKcemOSbNbXmTH4UOIM8POlzOSVf/PHf7XIgjATwxxEO5OaX5dJZTsWWOMzLp +fe+jVgSvRtL5j0F+9cVcKh2J9l2Bw/FxbzoIrXInu8kNavlwf074Owu5TGMmNrl9uE2MqjrP8zj3 +zwfWd55f9dh5L8+tEL86rpxOBnPxjj7y/ioPZdLltajPW4jH22VfZHQlx43vXkO5qcfcIhNi6X3m +177on2+HBcpVzKac7n3T5Zo7bZZmNbPfVGmZDzOr0CAyebjpMj1mcTqQTU3zOju9GxVeZ0GWj9p6 +XbR8ffjFF58AfXlA8rNURX4Cipt+J2Vjr8usiXKve849PWHSfB2dLBV59Hvq43fmL+aGvn748y/e +f4nbbCz327zW3CYXzQaeaG9+dtV65h5e51PKI/Ymr5U5Zp2ZTdX0+9wQE9BvhyDhppb8uxwu5xbU +47opt7HLd0xWDd+bfqrycNOyvd50c2lxVcLvdpd5gML1o/qpY9ThBzv30ipT2wnbZjG/XDYFXNfH +XLG5Hle5Lcyp/f15mVVjl2/i4RcnZFOA8ZhnXYWD99tLNYRlooXtcMU4oLlGOnRoQz6u4vwSi85p +l8NSriKr6kerThfbvSC6w+a8PAHZ3CkTdynoOEHza85NN8+LfGaOCPqoAE50P8HyUbI9EPlFzN+V +a+Tt/e65ytll1VK266GZwOfttutMoLVXX10blnyAdpl/HHOB56B3uUk/8XwM8uGq7UvGmVqi5JBy +PDTrfT6K0vJ6fPVzz0OkiHrRxvx+9R6yJ7lv23EUPN0Sx+M72/nE8/uqp6oBH7/zfvEpG/KsUHd5 +Jcl5eXvKtPPyQefviZb27wzQF619koOowDJHkLlpLseW/dC3vqkqs3zQtrAeMoSJVVWhe98p/I/O +f015vSPvLi+Xp540RVnKT83J43akA48df1acOV/PzajVV255s5K/aeHatCvJHvG63d7us4+tcx/N +M6Qbcr/KLWguiJzTlRu6LnMn3Z86JzzfbXiOiO0yL7IMojrDbPgTLk0k9ZTv4mwr8/V1hY463mWR +9dAnvdXcqte3y5Gd3w+X8XWbx+p+k7Pe7TqPpTbF/2bf6uef51tdH1qWVLq4Hn4JH+Y+e5s9VJbk +E3Uut5ed/p/91Rf/5G/+9Ge/+/2ff/Or33/z22+/+t0/fPgz/dHrv3/403/929//xde/+u3vfv31 +rz/8D/Nf/7e8s/70L77+6jf/6qvf/+6b/zrv/OFPfvGzX37/nPzb//O3v/u79//qnx6f6198+JOf +/fq3//7rv/nZL59/M9/qL3//D7/5+m9++C7fUfO/XyhI/etf6+G7/VEevnM4rOu9ffiTf/rhr//d +F3DZj0/2/I758udf/JOf/XL9m3/57a+//Oofvv7dP//n7//+86//9ptvjz85vsT1uzfRP89B9cOE +f/P/L7OHzH98+e+/+JN//dV//uZvv9LbfPjlt1/N+/3nr//phy+/VZT3L+HX/+t/9eVf/fLP55d/ ++ct/88Nf1mX+5fWiKzyYXdSfzVr21/9l/uH4jwkj/9MXfzrs9d9+/V9/P699+fCn/+Pvvv76r779 +9W/nbx3/9tXfff3Lb3/99X+df58f+y9//9vf/cP3/3778Kf6ez/79vfffPWbb776+2++/dv503/x +xReXP3znv/6H+Zf/ef7h/5o/+i+z3n74Vx/+9//j8uHX+gh/8cWB/PoPl/27T3T98LP/OP/85/O/ +/8v8y+Xt/sOrHZvU/LKH5+n31tZzLtXB/Lsq3t8V6JDfzF2tcuhDsbwe1Lk7ZtNUiuH+3X74mE1J +6r/lub6HvLKFXVWq3RW2n5CJFubTbXPQnxPGPNTLrUDzdEv+8th0GOmf5oycvtXE1ydoAhzVfye4 +WuXO/OH0YWY7kw5Baevnfrnfzt/pRChUiEtzYs7XNz/JJ/xMv/puZ/2rb7+de+zXH/72+wf8eZ+n +WgXBOWYpejzsSPXE3CVHWuRmrMkaOk0sUj0qupzz+bOccWfbmGju+/+ZV5nzwKy13//PNtH57DDK +HF3vsslS8uPdtHBi/ouSPMfh4nJ/U6HvdgQSiiwnCn+b4G7Wzsf9oVrt7Hj3WRLf9llzJtSc1X79 +IFut2VN2mUtPxHr7pPe6z64xMeGcA2brWZRAmiBUGdIJJuXKOlHMbA96pVWzPhS56SA14aM8eS7S +Sq4ylP2U97rOEeLdAm6+1nI9vqkGGsx7S2Y1J5Off6avpU83EdrsNvNeRyS+S7u4a0GezeTxuuf9 ++IY3//4nX33zZ3/2L3/zm2/+49/Pgvenf/XtN7/67a+//svZamYNOv7LL2cp/Mv/8NV//PrP/ux/ ++urbX//m69/967nN3hfDfLUJjOcrrqqGTyw4t++xqX14fZN5la+/+dv/8Pv3F5iV8Oe//W0Sv/jN +b3/1f/+Xb/7+6z9Av5zb2ZlffvuNVsv/9T999evfffXtdy93qW/4b76ZL/TV72Z9/dvffP0j4GxC +P4r9xW9/f+wUL+BDkfgPj+VS/94v5qH8+nf/2/d/43l5WUEeH/kbf/3+Nz7p4v67b379+//whyAh +fr9/89XsQn/f/1vf3b5Lixzbh21BmSjZ9h+Oo1fdlvfjlBmZkluBIlWyVuQ1V3L/w9n4quPhriTF +KVtyff6QLZloa9/k9GvZkv1943hPl0wcqvk8D0yXzD/epHle9kyX3HVc/S5dsihzoYE5mC6R8uwq +WV2kS9bnmTilS+BVXtIl10ZYuuT6fbpkvvZjjpn7dkqXTMT3Xbpk02QYncs5XXKZ48Sm/8V0iQTM +8jZ7PD6SLnmBMl3yntZ6T5cMMXf8vma6hG6sH7lBIWGyfX9snT1j7iTdOpkwWe9n5jVhsr6f04+E +iXLfT13N1RMm6/eWujqnzD25Snn/0YTJHJ5U631GwmTdv0+YaEe7zlbz2DJh8od8yfJcFtX8tnO+ +5IdkyFUZvPlJtsiX3J6AvORLbgU55Uv2AnG+ZFPEsn4kXXJsjPN/P5ItuWmy1PN5JEM8XXL/Pl0y +W/YcNZVPsWyJloX3bMlx5aScPWdLnuf7wbMll3JX/fh99//hdMk1Ewv3OO0fa7if9q+nxMLjh8TC +ROrrojECni55HIvcS2JhAnkVCD7hvV7yJRM6SyX+h4TJLj3EtSVM/njf6+ef6XtFxuT2h4zJnK5u +Csz//4zJ/+sZE6tJLdp8l9k1Z1lY1Diyz9p+1b5/2xYZGyvUWiTQfXfj1+GsQLP1vWldWfXTH7Ni +dkn4J1CZz3VVT05BZoU9lIdSoU08s2rpO0FPjeyScnMW8okF5ha7Sbo2L3m7qjFCtWvNA/l/2nu3 +HruS7FrvF/A/7Bc9MhH3y6NI+TzR6APbAuyngzZPQ2pA1W109zmG/73HN2PtzNwrIis3WUmKVRUt +SBDZk2uvS8SMeRljzKYt4ZTGgPFQfvMARDUbZtHK7I5RevKySMlrcfJTHrSdUhyYHHZqsLcUUFX5 +XK/tpsvoCEjyzaG1pPgFk2jw6kR7IREsLEyygiJauUknYcHPLoxMY1s3x7hMTptPS6PCKBCjbOqg +4H4j0EHFoclZzw7GCvG9Pj4lDJlEEFf6JgUGSxkmcCSUixdf7V7SA+u7WK8qHf0ihQh6Lx4Ev/Js +rwAIeArCx6P1B4IdxI7CQCYryYSoITL9DWn2NK5CWTRDOyMc/ziwLtwaVAbDbBuPkiZ3sR/Tmigs +JMas8Uxm4t3A2djhRzN8Mlktm8loXn4lG/GLk7jwPheLuID19IwF4vRebYaP9+yYT+bhFPt56IwK +7XpiwIhffPefVkZaQcE4Kzb81IANAQwOTSWS8ORXi3W6rx5sNKZeEiw14rbJZHqVH9/NL2Ey+rQw +Iq5h3lZANFtxxsUwuorFzbmWbpG2brlQF9OC0G1c7ng/dwUpnkIIDSmCemJNeT07J3XDJBby5hcC +tayTijlNnRxu8pHvC7spdaSsDaB1iRGnwSQx9rL2iiyiAulI1SXxZbSZIMF1wj+jRPOM8FfpJ/MM +BOo2pFUxLGrjyicVQrxXmCiX2gnCdRktGR2f6UFLtZB56CL3/FStFMgUy+t/x0iHwDKh5lg8ZSHO +2u/1VB/e6KkUyysEV+pB9MtslNYVx8L+gzjrzgHE9SzzVoKmdAAnRbclj6bcrS08/0/vFHmRTzfY +h35gus8nSAMbxoIPUG396hyaTRaOaTaaHFOjPglbh8yEWunsUBrlBWYyRMrFhHQLx5TJ0hg766Be +QCFaOKakdMSGX+qPIAcXRkkLRqllNZgsnbzpjieLxYNPNpNjL2NSoQ47pU6xL04HfRUFbzXS33Vh +RLLTKdOVvlf49Iwes8mB82lFqZRUjzXmUlqdefiLDlFAsWzvfTo5ycqA/ejCjUfKZXX+KjzwcOnB +IbvS5jN8YTB5vIXR4kQgEiFlqPKitaYRm1DyhrerNJZUk/J0sipVt1lEPCWl9FgUWzGL8o7t8vE4 +zPSeQU7rdJWXL7kvD7MaCBQZCKIN3lteOP15mU5Hx2yyOKfmPbE4p2YjHYrQoPQnZyk3/kXPm/iz +UgZDx5yP1sWjnz/Ix3vez12IQf9AHVG5UgV90sPqMEtEigHsmQlS+NcPs3J2+/6SGdqnXKiiN0Bd +3xvnyBmIt1Euq0xBkS/WPi5GVw1ZoXeDY0b1S4nGOMsCJG0YomzJKq8feMlKLylshjt+iBST8UTa +KFHL2VxpRZbDBvVoP65Osm/0SB/e5pEoTlfKaFWBEFutMkYwU8RDCaL0V86xYDzOBgI8G4F+Wt0/ +LYxqsqlplRIkczsXmZDeIozfaOF/I5+yStHjf/LC5PPiXJ2MegJuDrITUgzct+luZpPFybEwMrK8 +4kzeHgCt+W56VHysTxoIPa6Qttunmkw+v5vfznyd+UNMd/P6t/p8zQimu2pwnuXkO5SUGu2zym+3 +qLUCQrnYBJez0exsGkB+YJclgrmLK5PFu56MKgojiTyjMMcwXOa7qcT+iQ+q49bV1QqaTEa6jY6D +dxSeCfbn60z5wHw3k8kqG5yNzm9nvpvpHd/xrT7f49CRxqH07KkKtLbMTpS3M+CMqZcOZv9rDl3r +7tb7MfuPPzP5qkdF2PJmdA0oeMm7FU/DXys1QdTn1bQxszvAFdRRqzWftesePXp5gMvoeakdFIxu +kC5y6ZQWwj0/VbMzDGVjpLdNx5JjZ0QZtENO1tmnf7un+vBGT6Un0CdsOptdRUHmIg== + + + Z8AATvqLcnHM4Xnu1ecl5OlnoDlkNJBukG86MKEaRy7luDLyBURGYZ5tY7jo5f0Q1Sn2VwQ4MmkP +tDI644wTc5gLjEoFkR4CsIIQIsuqw44mQ5DTHKfB2YjcPj94Q93Kv3sKYxFOnDZppB2XgM4N8Q36 +fjoEowXUika7qSmM9Ts/+cni8zttbsi5ToEXndXFVZStMBGboZxAmePiVqyIS4SuKKywjxePDYmn +GcEACSYk0haPnRO9TOgCxHXQZqZ3rCNcJw68Wwg6sPHmL/X6F7/LacBLVjpci43IDGld0ogUPLjn +YLza16LAGs4hk/5NkFMjhrQavmJtbRLIZ42sjBF4PDXCOcEq4s1Z1yvAl2vaNpz++eo0KD5qzaA0 +18uFuE3BlqOJTmvrjp9SHKjPSfWT8vZo4dIcjYDCM12QRSD4zZ7qw1s9lQF10BFh0Hi0dVRp+Ct7 +Y0b5gi7yVM44L6dAlbgGhSuZFDjJgdCoVILTQXQFwqzZSPEq0lDE1mC29WJt1rjzjI6FqTn6vsqY +uwcJYSouYMvgs3SAbwNvBmpNL8hHAE40QEvSHla0hhoZsze5TCVn7mxHY1fJnRQLjBlKCJ1YX1S7 +yentZDru2tXF2GgwLhKzr9fVjEJTlK8OYxY/qcidCyvhzHRUV7FtNqVBOmy6rNG4JhNlku1BH5iJ +2yCDAQJPRsoku2XOFRZ3tpGQcwDM+De5TaUNMV9jbUfOEIkNFTJeuh49Gz4t6t/h6wuSZcXTZkZc +iH52z4g1wvzUa+0cnfTddAleGEjAZr4geYPgA2yTSe5sHGWOERUCbZR56UwmREoR9QxHm57Ky+o6 +vivX4RMorbE67nw3gNOUB0W0D031YvFUnNIeViLT5tPy7VDlVloLbUtRm199CIWgD2mMCu3IMiw/ +qOchUD+oNgvULz+obs9k1cBGKU5cfVCq3EYvTsVF63dOaxDsgdUvyfCNZDutZboTkNwrwo+81rrY +E5iAwYPp7Yy0Ne0sgxY0gDb67B1a/mKDEmN5OHbNBleuNvroBhNxa3/Z+MvJXdzhdh4zmvmDnG+c +RFX/XJFLsUGR5GtySF15ODJzWnZ1JKrIigE788bgyzbQtiPlY6y7eT3fGowkFSBXiTbesE8myu6o +2vAqDl3I6T4WzuD8PHJOs1s5G316V2jLKmliBY3uss42YCysJe1/qrr6TB26vXyqoVdBlWlPcsBH +11cPPZl8to6UPLuREz0rbnGdzFJR+pEIwGkunm9msWfm577jY9/Hin2gsBOglqHZ90J0Q6tGLyZW +6omvN2zSOQ4w50Wgx+1SltFjylNR0vEwyCIRfSucVz0iIwPxkZeHRJSnHxANFvAY3bA3QVux8dEG +ATvOYOaEvMzrP4UooDwMyF+rCFp0g0gNKi1UJNsiuvlmT/XhrZ6qoVBB0IQOivZ2QzksgD90QB/9 +KSWqehjFzzkzTbSsEvifFkY0nHlNiE56w1WhuSM33UFQeryhaVxwB3i55FabZzL5TMVa6xZurLYP +4cpkg/JKsmRUNxCtwXC+mdlk1RGZjdA00+FSyOkQ6sGE/iTkTjmkMXTYadloTwTUm72ZICUnv0Lj +gi4P+EX+mAdXUvsUIT1lPKjtAF5bGX0yo8BHJui19vz4MVMSgapbLkAjO4JYFSGTcL3jXJhJLD/Q +Fxbzg082XmuGP8t5Bh1Y7VJp2KD/JlecK10yHQEPzuB4EaR6WX7Mk8nnIVACota6RiGtrlORaUbn +A5E4I1ee72Y2WdWYZqPzu8FEX5LWu6dPu3jBZqK0vRlilhB28TVtN3jUhZtJ0yy/phnZ9GbO9rZY +OYudd15/d2zOu7JXbkXvRql8UI4dl/5dwQxrVPGeXhB+5BX33s71ftoeqK0ZDDWi+yvv1Jl/zhxj +JFrzpaCTrffvTMTZsMWc3Z13zhOVfnh303U1ZLMOQWWHcnd653IsSunA3b36S9bCUEiBsGIfNUeF +fA/oGcfKZVbO/Vs904e3eab3IDggJzkOYiRJatFGNSKLMt3mnysd/Osj2+5fvyXv7p+/nnX3z1/G +uTuobX94x8EJiVX7CiSCXoP2jaEvybjRA0z2Nw65WoDBHfi1Q4sLAWQwBWhKXDkOf4RK9xD6fbQ7 +MMeOGjhiwjE8sbP0XSOBbDQS3dnoSluL2bHHqiUqCDcFi6ryM4acHKNusw9yuqcIXT2ilnlhYhUA +TgyyTvK7sDDKAJqN1IbnNXDQ+W5mk+mpAKufjQ7qGgu6Znr9090c/LcckHYpLc8PNVkMAPnNu5ls +5hc83codH4q98p9Pmfr9MaaOL3AXY8o/rZb8xYSp9U+8DWHqGUdq+4Tfkk94gVpbs8G/UePtvqaI +rpzORmfBMklc7LClYFQ9OMqJ9GJA7i/6AKbCnGl9dopO8aIM5KGiFKK3RFZ4QS6pOyYDKAY2cLFi +TL2hTNUm0C8ydDwwS52EjckarIWiCCKjsMAzd5OPIlmE2lwpmlFqUGDpEEgLtVFbDnf9FjSIh96R +LArQeECheaVqoPmVeFGYUejRUPVHOBKMKRplNP4QalDiaT28t3quD2/0XCZ6nBUAekJf+ofQElql +ilRbivWHItfuk+JXeVLcUGu37NiWHduyY1t2bMuObdmxLTu2Zcc2ifZtSLT3S3HF+6W4ZoUtC+T+ +sKm6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrup +upuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6or3/7FtNx8peUGYyA98nL/67// +9S9/+opRmPbvvnoK5iMx9zRv8jUabayBuiP7078wi/JstJhFCaY+wKNi2mF6oro9m0VZH/Li7z+D +UA+6vvINet1j2NjJyNqQAcoEKWyOi1uYTRbzGmejaQDl+WZuR0fGeDzI9NcDKX7zEiab+U3OUydf +/SA/wtTJcufUycg/YqJZaVSjX5o6qV2rF6V9rBy8j/GMDWZBUj6e4r1TJ4n7lMyQ+dIHKjqgiA8S +sBAwn284dTIo+VWGBbFCn3aaOhmOsZO//Ll0e/KUyjKsNqfT/3bsZE4/FDPO//6ocV8ydlJr74sZ +cesrvwUj7n6odvrKqcmrycgnHt4fVly81WzBMxmvLGxuyXjFL01uBls+jij8mcGWhim6HWzpT4Mt ++zNC3hhsmW/5eKmU1+da9tRfnWtZlvMmb/h49Y65lvHVuZbt1bmW5TTX0s7yEx8vnOZaJn/m49XX +51rm88jKOtPxFjYTG88/sfFemmqZXlhVryzOF/h47TRdsOaJj9fCbHMz1dLms/78VMtjbT0bapn7 +mY5XjUh3M9QynOh4sMfOQy3TmY53pdE9TbW8rq5ndLx5ZGU+0/HiCybP6HjzwMqrAMEzOl5eGN3S +8Vp8ouO9MNUynada+vD6WEtTTHiBjneMtSQTf4GO9/JcSz8viNNYy7q2+PmF9xum46Uzca2e2WR+ +YpPFibg2jX+MZzreXeMf17/16ljLuiDkfbvn+oqxlsvfOjHyyh5r+eMx8qzFRXkyayE5JEHwrJHF +B2Dnerj/ZI03QoTO0jAjaGr6imAYtQRk9OkdH1jnp7w/R6IZEdWAZ6mhjDABNQ95N6BT2Q83TqsX +OlZrdh26MGD3dTjnx6voxKPW+xSyAHDzwHwejViQ+nS1RBA2iWZ0LnLgvti/5aRUEOY5ZwICLjKp +8YFuWo6UhcyEzw7xOjUYG/ZT9JayuWPGIpfR1NZZ70iTxy0ngk+9f0Mrm0mrD4F4rl0fXBf2wHDL +493QztM+UdAQ7beILZPBM93T/YD1y9l2UDEjhZ+KaMAxPJrQtdI21HEFjqtTpXCKQrjDWg6TZkPt +2/HkcviUI7T6tS0ejfRpdPrqpNQJqtukx5cfOBhJksPVKCpGCi5cb5quskLaNhZPOboQmcb+8Q4v +VF0dMnD+8dHPJp/f6VPQs5R/y/Wl6+g5FR2ksQSXdwOEKVjjIFzfzvmpPgJAiLQFn70fD+8iOk7n +49F7JfSDBnn9pB51HQUoBAIsQ/gb2mgAaZ9MKInrURUq2P2sTALleBO4Y50CiJiNFF00wmb6KXYd +rTjInOHpuXSoczY8fnU9VUgu3iwwHhTC4PFTH9/hkkMKz1ZPJ1PVMq3XtfwJwE32dMMf3zO4Dp0c +ekHHXq/KeOLN/fRgTkTfuY4FL5PqKKc8vkBMqi7zuCc+vqv69Ug6oAyg0gU1AkMlAPY0n9ulUp+i +gxCvu68T22uXPPqU/8nikWOswE9LLsaDiA8MmXcEnvrQ7aJgTM939Rfj9QSQH+A1xvf8v95pY+uC +6fkiHHRX8HH07lkZWoY16FeejLoibuWCFX0WvhhGWityCNqESQdNGjYoIACv0C92+oj2vgA70Gkz +E11AR4616mO46EMQgZfy9LWqcQGfPI9Ws/yeDuDmn333BvhXPmC4ZlYzWKLI0fx8icUM57mMB+tp +Xqo6KLMnSR27a2Uyr+aFUSLdlTscX+yyuBsgzQmsMg0nfmp+Km0/PU4wTzNWs5YYbbfnvjAamSs+ +XucTa0PpUHi+kRNtIId8ydilhSbazUlhJuGZQ1DmqrSW2OXRZ+inCl1o3NG4n0wLVCfvs+sAVVCY +zaPaRv7EcQKTSw79yYFDeOlKAuK4aUoM54fPtw+v5MwryXl2chkLDGxhPVbqqJ0TL7bHkws8L222 +wyZdDLN8s+J5GejRpH7dyDq5tCif3XDqhCIEI4+HJGsOVCPEATfOdSUdka17vY5euU7bDlPwOPrB +HrZbE71BJZbVPUYZOoEoaHKz9lMweHHNsdqaG/GKcrEMC+warwB/Mhkxf+zSaogQ1CWu5wBT4Dsd +rWivfZjkB6pH7qmoUUZe6tM1oElUhJWcl/Dow+CBRxPPiMejg4eiRVrj8X4+mRH5OZt3XElGiVYA +KypdjeTHtFj7OG8PIBXRXRvLeeAC4tORXA2QZSzCx08KP7A8nbcrE0A11I51jfB409N1IlFNzGks +n+XdKFLUQr16qOtTUYt6clDsgYqiQb0+Olhk2qKPB8Eng8+B58mcH+BO32foE4VizPHlgeFRTs1d +5wM+HsgHASltV3O7WMBCjabdVOxrUYJi8zUWgvHbozwLYL7rQo04Qpgt4fEENEWIpgPocTUbiB0M +4TMjQ305ioPykTQqWQj6ONTw0QSoJnugRQYV9zFORTWAOEf/Ig9yBOcQiLdsnWxMdHg4SHKmVajb +bjgo6r6PQVahZ06T4rp6PnO2P9sWZpQtcrUKl71nsCtaqM92Oxzr7suTiQ6uAqvkydEZP/Z5KPuR +CIF4Mz4dyg2O0PN6oMIIuEaFAuDVi8kVN2PnX0P0ho9o1xVWBjcr0qB/DCM6N0jR9Omp4oNlGI9n +IN5Hn6IA6rkueYO7Px3baTDF9Ocnr8HysWbvOP6TQUFJaJ4SITk66DDPj1szInd8XA== + + + GkB5cYf+mp1AmNItX0OfcTedluHT3VDJ1eJxj+5AjrhB7o9Pb9ly9acYvVriIYde7S+uPiMq7rOS +0fWm5daonz45cDZys4Lr1fFW96rPmEw+m3u69YaL62RER1x9civUycKNB9Pd6KWzsQ/3JD/DQZuu +nvmjue9GJe9xl3KW5aQU/bowPi0SVzKfrG/MW72+H2PpZfeUTer38SJPP7cwcZbUPK3CO3Lke2po +V8HuWWw0KLjJkRWr5CU3+2+MXAwZnCMbETy93E4bEW2Tkq3cmk+H7P8JXl7rpkPjAOro8/pa2rEK +BnQtkIo0GRcXoyf6Vjf24d4bMxIPNd5wPQlW9/WWAuo/j9T4UvH0gdP4Qt30M0pjy6dvqeQtn/4r +7vz/JkRxt3z6b9QnbPn0LZ++5dP3SbHl07d8+pZP3/LpWz59y6f/IHitLZ++5dM3WOsXyqfnr5ZP +/5dBEtuQsA0J25CwDQnbkLANCduQsA0J25CwDQnbkLANCduQsA0J25CwDQn7oSFhy+KU1W++GiKG +Dm57/N9nGLH/TV/1r1+h5mP/7rur+ZyAAai20IBLWeeaafOvEBw0ihAxpcm2BnAodlfYqY1YTPR1 +BeA4mawBHCejFYDj9mYW+I3zMy3xGzpvlYNZCUDRVl/iNzgDlLPor0KJS/zGrcUav3Frs8BvnG/l +js/0Q2r8HMOAnvRp0Gl2DOPzaLVG2m1I/BAPKeVOxejOjxI/KOUqeGhoPpgUTnHNPEJDGvP1nzKF +n86v6CQyNaGSGE7FaA5FBjrpvkrhZ/VTHNQdJQWHfLpJa1PbV7io1F3B/RAoe4un0s1lCsQ6FuV2 +aiLl1PkSU1XU4JCr+5GgG78rfZ/8tCd/zciN+1sK5fvK/JT+1JkPipqZdzaDRtrC6GXUyDOTG52f +R5iAN2XYiLzhGTiS8xNwJDnFfgzOutX5ce0JOVL0r6i1vYgc0Z0VAHsm2fYicoQsVzu9hxeRI2Rl +Jmr8InLkyWJCjrxwlWfIkbiyWCNHdMKAQo8/hxwxYUfUZ19GjjB5hAL/y8iR1plWUNHdfBk58szo +jBwZCJ+BHAkMXnT1DBwJL6yrV9bnC9CRRwxA4NDVjU7IEVOduTW50fkZeIUBHHEIr+d4wo0A/7/i +RpgJ06v38YQbYQE+4UboprGifgY34gLy3bWdcSNPsBHLAZDqm2Aj5QnLweyp4I4gag0buTF5BhsJ +C5Ofg408Gr0MG9FGU2oc88uwkWCpKCndBBvJj7ARR5OzjtE0a9wICsdIVIYTbiS1K26EAoseI0yw +Ee+n9XCS+SlLg59ddL9n0AjDDU6YBz/BK/ITvKLaxgvpLPJT9YluxHCq7/6u33ou8sPyfgYbaQHG +Tvoa2MhXP9eHN3quF0V+KIMEVzdu5D8fN/IYdY2R3fIv9I37ERzRV652IackyrQU0WFlYgNNYFMZ +dwjCJ4TNqGKbHjfYCvkz6tjoI15sPmtl9BkJsLPJQdVU+lFFz4DV6WbqdZsYOOMRwsKEpKkBaHRd +WZIv1iw4GyXyos6VAgdftPs5GzEYBFF0Oi5UYi8IoeugtA6rQ5QxugeEy5USBwapHeDQTMhHxw5I +8mTy+Z0eIsmh64pFp7BLC6OmYw4ACyN7qVAvbmY2mR7q47vZaHo9nxZGvGZtbiW46N4pbaQ9nhmE +qFtM12+l1RXABrRIVceAJxb/EFaX45tnRjwlhlm3MQJWZw85L8cUyra2eBLTYZgWE+MYJMQ/6qga +9zGv2IETioj1g0INF+o8uTPAro5hK8ynBpWQydl1XreFyWJhzEaLhTEbUabVSU0pheCh0sNWXE1b +XqvXFBUVITGlphCZ6ScXC2My+WzjSpmrR9nYjSh+uk6EjMFUaI/I4upmZpPFwpiNFgtjNuI1wxwp +kS4EU2kUzDAGyaM16Uy90jHfh2E+LJhcLnd4jLsCC+Iz0DPMANfKpNJL+9XgPYVNQXmD5it5iXw2 +U35mvxZJvBmxTQoVFCbJkYBD8VbtcqHTvUaeW/EX63TMwnNMbgcFo9gvGnSl2qz1wlBwgsf+kOy4 +1bqm1sWh3wiLaysWJPtwUXSnjUYelxgIH+/5IbAUiihx5GBTOPOjNmeLnbF7cujRzvzv8kwf3uaZ +tEvIrvU3gYlwYfR7tbwK44Br6DeV+JfS/z8c2b4rAzJgOPxgnUhFRfISyi2Y/KbYO3Cil8HZWxhV +cCSsxObJ0usBddE/CoxiV7C8MDEkkBKkxqR2IPgf3zG+ODkEW40+WBZGnxZGbBfPqArtModEe6cn +VRADTswJt/kbLOsu508d8CBnnB79bIIz4TRN+qQ9tVEen67D7HVteDoxpEyLu5lNFo9ujb7kaNh7 +y+VWjz4bTe/ZmvrVaBRuzAOZvtYdX/0uZ8KQHsT0lUOSx7aVM2EkIA1p3TlTmBYTOG43nmLX08ZL +jH9J1htPpdLykjNOD0F7R1lbz1zdWpVJXyUGm5xpksWeMm7MYBDoWA5/Uqn2NnIxepbae5T+lZ3K +02bGXNzzW0g/A35R2sisXwaNKduj2etovetjzA7lGz7Xhzd6rsDBlOkFKoevZBWk5hSxOhcO/m6n +0pl5p4AeEJ0BshL+qzF+WcFztApitiRf5zhgr7gw+rQyCowGgWpZKGCYzfnH7jCZf+qeoxOCKQCW +2K1kuTw6DbmgA9qDGKmLCcs3qyKeThklgRcgpzTXGZrE+SQ/8MC8CqY9MmqLeXLgf7T0qHmCaK1j +8Fah1kb7QwfQsdgV7xLtdTjDSYtCsYjWIgloVPBx128hVf2gQKTGykgdTk/9C65L2UleKE+L/Rs+ +1oc3eqwI4pzSm2I+AgGOp06mBaQlQmK7b60rGIcJFm2GZvID/5Mo9VHcIqbjAGXGRVMAT8ttjOw8 +G31aGOXKsAwrGWYmGIAWnX7uLqPFz90zX0lxM4MxKO5Rj10t+Ajij9KevhKltldjxX5ygxGiFdDn +yEgoo96xh5kHxZzZAtz5mGlVQFEH/UiFeBdcUEBeGcIVGG85VjxTP4rFWoYyyVQk8WXyIEoN7/st +ndQBUL4nrI7MR9PZlhgbY2k+1fc5Xvx2z/XhjZ5LLpRiN01phYiW9ius1MfT8lcs4MJXL3nY8Azs +dD5RsarLJT8ZrZZ8somCZKBWYW3L1XyX0eLn7lny9UGRXqV+rTfbX1/xRHc/v+LL+eC3Csfzr2Wo +nJuvhepB4/zuTmcUuFuCXEoekdqTVgLTlGzBewWJMDRdD4yMQOPBMm1muOIL7/kp8lrCSiWtCjdJ +LsEV8SbcaHsvEqRv91gf3uixAphKJvJl18dy79oyCgMaaN9Wv3q5V5ouSYGJiW60tlzuk9FquTM5 +KDE6lbJ0HXyA2XnfY7T4uXuWe1YiCnS2j0nh38fDrxdGhVMk/9r069TI8ISN9mtCjZ+Eayz4SBMR +uohjYusFigM9WVumRNl3LXg5PAClTdkPCA6rCPQH8O3KiVbh+zd8qg9v9FQBIAsgaLm7SGWVVJUE +VEmCK/cG7/PSstId8HwbOljicrlPRqvlXilKGmGOslKK65V8j9Hi5+5b7sk8nHIk3/2y+PW9AhrI +HKRwDBnTRahlMpsaCYEYUkpHukqzhAERiTli+EG9CwaYZu4g3BvPGF1IC64XG/jwnjn2gHarwcjK +G8Yzrz/Whzd6rEAJz1HA4CPpHxSDcUeQGuXeTDWQFSu1dcouI0yvRfRO6ZWile9G72zLcHo2WgTm +88/dZfSV0buyIKbtJJgtenVvsNiJPG9XhY93ecGisCrB4mIKNFxCnTYPBLzyTQ3w3RHLwIqgzOZN +MonauJ4hKJFuKQAPuSuWkW9w0IDQhanm2eGVQJkAsVSmtf4Nn+rDGz0VlZnG7XXKQH6M+YqAQgq4 +pnBv6L5YgHPovljKcyw9Gy2i8vnn7jL6ytAd+nXpCHNCaLojlnk9dk/nLkDOp89lAKTnn6v0EY0Z +DIVZ5SkZXMX7B5hWQFh0KB7NDZp7HdCxRz70AuniARSATa0v9/2WlUPgKMnjomJmwbvehYIbBcrV +zeWZb/lYH97osYI2LUFDMwYbuBpYQsgm5QEh/+oVv4je58W8CKcXx8AcmC+c9z1GXxm9661S5Wxo +3r1JNPP1rhBAtw5+YDU1MKwtBFD4+uLFN3LIozxDTJjBYHqnr5wNt6KQ1zVaGPdlkLCVodwCsZID +NBKX3GGIVEuAPtQ3dPGvP9eHN3qu6OBZau0DLNNaMPahZyBjo0v8C3z8IoCfF/Miol5sizk2Xyzm +e4y+MoDXiduMKhwVDd1Tn/l2Sz4b8DPSQOstMHotBFJIQmz9TW2Hj4/ZBgzD9kQKGhcGqtPQGS3d +G9TQ0DQVMsWAhMN6wEBvJhv5KrxhVHPHc314o+eKQBhCcgUkZ6zhghRDKPRN9aeQvsTJF2CgBU60 +CSul8KA9BGQmdsBTPxnZWbm0/pvCBlvYfFrYQNCsTmFI4b16q5lqR9LvA7KehwnUVV5ZMYQycgiA +tBQDApFfmHxExIT+EB8n92Cyi2cj5b309GycaEB1bGEz6MextAZFOS9ueLY4P/ZHMvXIwqHKhpb5 +8t0sjCIiPZ2Gl1xdNvUItBGArMPlWZosnvtkApN3foMnoyvJ2wOS6TX11ZUW6+IOk/n93OGZEjuk +JPwOo+6Xh7GPDzVSYVLk35k2/JpnOodp4JGROIEwLKec6oDGIebrEXwYOKVgpVydO5lqv82vT/Ci +gpZM0WY96mgIljR9x2bF14tCM60U7TlkFpB1fP2XcoeNK5+e8ePmO1IfZVolLIWO0eyVvtUzfXiT +Z4qBJVyTli/BqjeV3kqpGgp7+nmP9JVTEPwziqt/jeL6pWMQBsH1rjEIewLCVjvfExB+O9zI35Cu +9Z6A8Bv1CXsCwp6AsCcg7JNiT0DYExD2BIQ9AWFPQNgTEH4tZPY9AWFPQPh9MtnvlyuqXz0B4ZEr +bw2ezZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998 ++c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X/yH48t9gRLSS +P4vOg/3pkT3/v/6P//jHn3/603//8x+/Ykr00z/+zqOi2wNMg2oooBZeGBV9NppHRYcHcJ50JnPy +qznQIHAyQEojEdjssuWoaBg4nay6HCyok5HWmHxC01kEobAsRkXPFou5yrPRalT07c0sRkWfnmk5 +Kvr0ahajos+vdzEq+tXP9J8wKrqdR0Xne0dFKxCUI4eLY1Di9aho+l9AlscEVhuqrDMi6GRo94+K +VnwDWKby0MlGRecxNDRBB7hrVHS9b1R0JBeWB+0eMP+Lo6J/8VMpcdeiUILprFrV96joH4bk+qWj +ot1z7/HFHNf4A8yKbt9jVrTS01pB29GXeGlWtI9ZOZcOiR7qwmiwAal1ddicL5koQA== + + + ol9HLvH4U+dZ0dVAy0qIZLWaFQ23vcHeyUxSbvWJY/tsVrRX3qj/VsdPZybw7azo6o1im7qrDcap +zg8D3y9GRctjMmW0MpV5PePZwvpEjhcXM54/H3jjXpJCfD1FXl+lkjw4OqQMtV3Oku4V7wPDP6wn +RWt7KNIO4AUg3S4nRet9KTDkb3x9YVI0eepgq5A7vTAp+hWjwbD1GckGjtTinxi2x6ToaAxbBxRH +r7zzr9ajol9Zns85ttGQoM70CdajoqHNGem30R+aR0X74sEm9UI2lOdR0QT2Be0kRRi1PfFrj0nR +FmRxUOlO9KYh54Uneu0xKNo0Pvg94o0E8/WJXnszKFrX5Owi/rjSWc+TokFZw+702apw6zHQZO16 +ZrKTl0ZJQzKljxhXI6AHuVYviaaaZ1UujCyGaglucIX8/USuvZkTXSlm6aAlvX9xTrTBcMhxWn4i +1x5zoiHT6m60AMC2krOc5kTD0R2kdTksvSgI/LdzoinIH9R3rRaa9b3M62VQZ/locAbrPAb61RX3 +u6bW+okZGkcxgsdwcFOC+7k50VT5Y6imvgMH1ejXege6/l0/Nai1jV3IEeAPbm3UbzXdsjsgAN/r +sT68zWNRZS8FDIGSioqf2FOifzRuLZRXfUnnUBBolE3dkUabDFJUHAMvSgsi6+yAHqMz2IEBmY0U +gnS9rIJqQNVixURnUPGQ54Kt2CQHX/TPE3QpWHEycYgYyKtBAUwWVyWt/Gp/EQCBH6SBUKBdogjU ++FxUqfXQgScvg/hj8hKe/yiMyiOCK6RPRCZwcaCLO09RqiPj8fkdDSQKr54PX5yxg7KRDzLIdKSH +5L6L/hNSrK7acyv07igKOTJEFy5VQRNvICIb0duwaBGCkcfHw/2r1YhBIAIiTMdxN7y7phdkEdyn +d/otxxtGSoUi3TDSUWEMVV6sksQH3krR8ab0wt4NgLWg2DB12865UTCgl6lVbwbAizj29Us62ziL +9aW8vgfIIx1lfbw93bBCBxeNeZtgXBpPSU8REvcLlxndjULzRlkNNZHGvwfl0MyRAOHUe4HTpfVk ++h0Q4RQryJ156zaNNeFYNhzPup0ip0B3Lhbq0mNNFHj9Cm1g2elvanrQ+3esc/mnUWpXblw5Y/Wx +Ea36/E7RTUO6ploANG5Zbw/ZKOq+cAZp+xGpU8lRlpwHs0pREucxQO2MCfJWFdEScCG8GzlMrefo +iyx6pSKPH8sgzrsjWMZI8aqu0pGjCkYGm41MMSsrWOM7eOsheJapnrPwKkcU1yCwKazC8SC2MYya +nohauuIKoyY7sOE90JAsqbxgBEu15diADnM45vjATqT1hhrKsWsqpfRMGUIm0I4UXrFQ9d1s71HX +4UGa/m6EcjpCPOTprNDSAjXdNAhVSLPN5O70WoNiZjqlbnwwbWH9l+xraMTGmEWGJ7GMTU4C5rmS +jsL2DEMYTi8VbD+YFF/T+BQK/TknUcghdiKaCmwGJUJxbD3dJq5d8WdE1jTB5mxD1Ij922Hzyjdm +Xq8CPOMR9ocIllrJk/ygvkIH5a+NpkON96mjNWKiFL1SW8zGJdXXrgOO3lB+wRebYFBDYSmZiX5B +h4hWtWJe4yTLSP91pzNoLbT3PT2Q5iFe2pBMMk5yN+0XjlItwmRG3LEepiCGA2dR8ZsObHlOPQbo +pl7MM3RCzzBoy6B5tL0hV1XccdcLpiTfEi7lkY4dE7p5XnGr+T+PVE5Gj60A9fMUXYF+OzdgJkZp +1EFPhBqdYT8abXjtRr2xeqVqJvlC7VYnJzx+KPBDify11+RHmUz/VBdJbGJecSSabvD3jLj0no+n +T0wP1eFbL6P7A6iqaa3bIvfsF4XXLHxFsvyUPBM1xWYgomiHg67DLVJK1bPaTqD97RCXLXY38vus +Dz4nClhmQnSs74n6Xx6bTt9PQbZ2utYpn5PraElEO4cINqD/y7fiBamLWnt9MuJBrSxAgqcjAm/R +aMHL347XSsWSElLBVcI9HrIBkxFbRO7XU6WoKDGZUXbkG7bNrfNm20bRj9Yzrm5tFAgdrDRgTRrU +BRRryCsVMgt714ETnj1N9UTXqYWkGNyAAocUD5pgomTZKtBRPgdafslyWOh8/eiCotdLcqolXylb +ynXSvGSt+iO2AHsQ5ZMVkl3uiFHuzGDQiNLZqPtVwmoxVHXG1E8QHFyUQ1AsHvEq2kodJuEUQul0 +1C+ydAOno63cjCiTsr3s2J6OEjBSSFbYp7Cdda5kAgb5JS2zi16UFWpBS6DdOc40T0fVxCXknpF4 +1Fp84Mzr/KBPCjaCRSRZQbazqsOrv/Re/yeaOkKhbgPFkqwXuUwtJo4eAvHv9Ewf3uaZOOy1pBXV +ewSAaFhoyVW033Sa5PgsteBqOHxPtt05h/ngQHfM59bUrWwYdPhQa9EZb8FDIWEGHwEUHcU06N0B +7EygaZxKHwBh8M86BKjCWt/bIvIKUSEDlTCQUjB5kDrE+j7dc0d34W0goKeko1l7uECUXaxlKjwK +eBSKttyMZ/PKYq7nL6/P2h50GmRidt6whV8PnE5OB408t96/QlfavZQtUe82/IayP2qN2vkK3Mdi +ztT5Ct0U6z8jlvBgeixoMsgz3vFL7xUqOvs0ERkMnA6mDyQ8vhlffl7N3+qhPrzRQynAfyisMmNe +jSNUhyM1X1D3csE3ne2vEn7/2sa1rbdf1L3+b+MKd7awtxj8Fn7eYvC/7u7nb0jid4vB/0Z9whaD +32LwWwx+nxRbDH6LwW8x+C0Gv8Xgtxj8rwaxssXgtxj87xSwYgDh+2HJ/as14YcY/EbHbHTMRsds +dMxGx2x0zEbHbHTMRsdsdMxGx2x0zEbH/KjomG8g82AoEp/taHwOl/n417/85U9gXP78j//vK5Qe +nv/z76z1gPIGg5rQsC3pLCKQ0rWTfWM0az2YdqNOg1LimHV1q9EwqvD6igShFCPjwsQa2You5BeZ +m1baLAhBl5ppMcrZXM5WE51uZraYnokS8tnoRmAhKXuebmah9XB6pqXWw+nVLLQezq93upU7PtN3 +13qIZ6WHSRPhmqM+ChWAcEDqQe9ED4M0AgWHW6mH+Kj0oPSOdoq1EkwTgREXCrIys4Tu+SkCZqvw +K61rRFQMTEOfK0SLceOs9DAJPUzqC8tfIiqU83L0/1Mt8az0UP2j0sMvfapCN05xV7Tku/iT1EMt +P1QHe61H8BttYX+p1IN/7jx+lVIPOk7eWOvhZyQfPNuFCA3YzplTny06LYpvKup3dAzDwsiKPXqJ +SuUr3fQXTBRLJOeRqWwvSj7IWTG/qBLi+KdG+jPJB2qLFZE9yn/lqZN+SD5kSt5MkqPCwtykeJJ8 +oAdIJ10+utFnIXSj8Her+dCsk550YxH8kU14uBVjSO3KqNd/qsJyTqGzxWjWRaR8tbgy4iPLqwCe +KeSc1b3wO5VxVcgzGIf9VvTh0HxQ+CYPR0+1h1vNB5pB1gBHtDCQ6tRJ80HxurW/HXktZUzqYrdy +Dv7aSH/FiEY6DRSdeCFaveCpkX5oPlgrlBWlrKMPrfTFmnl1eT7vpHtll0zuDAxEvSXgez866cg3 +KJgBydbPJH1kHDlHTCeeyQOoCZ9EH7pMwG90r/fOtLh8ln0IB5xP77PRMdCL9c866c91HwoAap0t +FQWJp076je5DoRzMwM3kX9Z9qLpF/VQavYhZ1aFQhGS8Q7Eq8wvKEKwNPdsxVHUl/EAFucOjd2gs +LozoklOpBlOu670k/FBQZyApR33hJPyQmzXSdaIzME+hJOf8WfghWmisf0/5Vt6+nXQffAiHlIp+ +VJsggmW/0X3Qlr8Ksmgtadm2UFOeV8RQHUG7PHW6+muLn195v+FOejr3nCflghd7zhRaFZvW6NOz +nvMhklAeO+moK2rVynGn0XOmCFfQ+2739betla5Dh8l+yeS2rZfurfxP5b4teunf7rk+vNFz0UzX +kUHPk07RVn/4AZvpT/yhKQj7F3PcgKYUDjXHqEbm3NINRspeN9GCKVXrzOKMjoXzeTahkzUqj3Jx +Vr0uWluKkJR8Nuv1zhZKNxkChdBSq8rOrNk1GTFAI2ZveRbTL8+3It+f6eQ54FAFPb3pgSYTPK6j +4QpICjWevjDqOikJtwohRVjey8JkfqbZaHo1083M7/f1r/T5Dvd+lLkWEPZO71LOyPXcy2CLvR8y +rKTujt55Wzwvdd2bu5C/RHv4mV184WIKWFpdXMGy9je6mw93381iAS9u7MmRXaty9l0UxSboaNFE +IGk4apXI83Swij+Be0jUapn166tFvGcjOU3wIbrNRF8v22BY65sm4g0FTAsTW2wWWvvK5IIBNTgZ +dYrANKHBS2BUOjM3Ez1nMppjmrLCYh0whC0hXTqq4bSdeiDur6MEAoyeODpka/stjPTddGxYsz8M +zXmOi0IrgCG5tDmsD0exy5Z+yAp2kZlGX08ZAGEXfd5MP4OcJ6PjfzZYPffZhsahDgO2K0soXmp/ +0HMST3c6EyPtaAyDrvaNw9Vz3HzMs8no+4PlYEZqdH15nQw0l+peNfDk4m5mk8VDzUadyjsDxxsl +U07bxDGHxFkohvix9+uZCE2aCb4B7EKkGscUomCtR30nxv8B7EP3nR7ubMQXz/KGgT5vTUfrRzF3 +pGHtRjqhlQM2VksuGYBBqe6DcXr0hhoTTVh/Ub66MloTveeFyfLRz0bTfqDLSisscnybnO95U92x +OX+Z03RJT58sm5QrKcO10ERXcKHfhIOig2Tek0zJubkN85oKT57swgsXO7zmdAW85pvdzoe7b2f+ +Tqs7O9ymnAG9qW7Da0xjcPryPy2McnzgPJULrkrUUNOvcioBCD1zahDBjxRsFAsFB24pL7782eKz +jRlwCJDTNtS5u7iK8boqsn4BYOriVmaT1WKejCgfIJLIHYLUjxAq0DpPAE6qoVQcQxsYeEIQu9rF +Tqkn+aDWP5nhehcrK3TU/4F35TaANYmpVUD5qbaEAXfRcZuUa/D83lA8mSp19bDauGHdDxG+blDP +jjDcZLJ88LNRpmYjl0KGrP89ADpKcJSodAoQ1ubmEbqJfyvnWX3Ms8lnBiPkqvwdwe1W7WuejQoY +waQlXOygX9zMZLF4psmGV0Pyn5jTqjQfKGSjEBd13ld/vF/9//JUSr+ANC6OTooj0ekBdAhrnazP +VyABqFjrhNOaMrQkerC6G91jdRZa0AV2qLtCV0jhMu8nuiT4UWpkCkEXFovH/gVusiZqpS0a2kX7 +ZriSmqmCaW03m4yZ5pcf4+kDmpfUmfho1l641OEkpwvIFb3ZzXy492bmTbC6r0ecxj3Z2Ov5wutJ +x1fmLnM+9nomdV9G9mped09u+FU55pyqvpbt7mzsB8rGwL96m1UEncMgsgaxR6k4gl2xWVuzUayU +bg30qQPIsE2zEcjZAFxehwvDm9ZG8JlTKSCl6EQsjbwjReEq1MxfuBLHtelP68CGjQ== + + + uTLq2XpPJAYu9zG+cTJqHRZdUmieegC4OBBXOp8A2iuJCfcaLX/ubGQ3nqFqR8f0tbURrwBsOpq0 +HFZLI14m8Qs8C99eMtJn0UJgIIycalobrT7wZHReKksjRQpMFDWl3HJVqIby1wPy05zxmVpu41Ap +dPMvgFJBcoOUcwYqPlt8XLiiyejT0sjx6w3Se3TH5Nvp1xY2TjFShgLbvF/ZrHYSHRAgYzrKCgnn +65vtnj7Dy64vPCQYmvBGMkTucai6hwExh6EwuK3TWq6ntWy+r7tnZvGFix2+b7oCvu/NbufD3bcz +f/DVnS1UoqZJSG8gIHUXJO6ffwkg7p+/DA63daO2RszWjfp1Q6l+Q2ogWzfqN+oTtm7U1o3aulH7 +pNi6UVs3autGbd2orRu1daN+ELTr1o3aulEb6rqEun6xbpSSrK8VjlrTmoac1EbVblTt7uNuVO1G +1W5U7UbVblTtRtVuVO1G1W5U7UbVblTtRtVuVO2Pn41tVO1G1W5U7UbVblTtGVX7uvDktxGnHBjc +PP78CMT9lz/+/d//77/+8W///SuEKR//7XdXpezOlEFbc0cnOzX9MZJzpVYOnNytEY6Hcwod5Z55 +GyVRhCugfA5x6oZYqUwQDO8WUjQ6x9pG5qzCwuSzdajtACF1890vjAhMZEFjeegAz3czm0xPpTRn +MlK6HBDdp4KlvX+ZbobGJhVEJVStrB7pbEDL+PRizibzyz3fxh3f6LtLUqJvfRKlvE8pEpAPbhwg +QDA/giilU2zaFZx2IA5DlbIrOKaxVhNDDxDgfyDddMl0ve8WpVTKbBLNJtdvqpT66GhIBRAikyrl +LEvZ7paldDYVADl5+4pKiRUpgCVQJKi/+fA2j1W6/DUADsWSSIehSkk/H1Fo3X4KPxQ+Lv2eAHL5 +2a78ObzbE0AuPHcfX4yQW7/c76xLGd5al3IWpCwPURugNiYW+GcgKRBiaL8dgpSeGANt9+z8wmhU +dhlPkSklxRdMUH2jdyQ/+Qyg12gwRRPyUzDIqAeK0ASj+RGhJwcGgrhx/CJn7FFn5LdoxRwYvQYu +NoHrU7anXEn+Vvm1Nrh/xOihC8YMHtPXQ4pOTkHHT8QjHBi9AoyvMgshXNDH1FoA0MOAFH9g5wIy +wUy3GMWJKM9DV0i/VmeLIRlIKQKRMpdeuoruW25TrjKEtUHX2k+M1SHKGxC9BOoQMUx/nIZU4QIy ++c2lA6IH6AQZvgIaWYcK40JgDUXQjQdET/fFAAsUBXHrjqEXnkE1/hF9l3n7BdHBj+/uMBqKlMwd +0l26gcS6QvS6byl0w6IkOXY9Q6YE5vJy1by6QJ9AenyKzuQDtPWvYCoGDfRMkAFIz5nyun6tga5f +2GQlUPoKWpLMFsqPGD1STpqX/aI/9wHc70yIOTB6XkccMD2anCxkJspA2tJHk1m/YvRo9AGydDZB +q+UITIexBukZRg/4ow9jyyiCUI5VYTFcFSCD3rkNkUkDZJaZ01GLFnwrpT/h5gqosZ6PfoZ+Um9R +26zWF0zABQJI6cGtrjIUKRntpCVUGam0MApA/bwBlNjB+QrR84bsK8r7zITJTTnYnIQnRUokUQHL +1kOR0g8l0qAjuT9C9LR2KU6XyyGPmduYppQPiF6SA49oax5CnB7MjbKh3g9EZkTZNNREp+KQ89Sf +FJ2kGnTZaUHY7o2JdgqBRV5b/PzC+w1j9M5gtnhCmJnS6i3CzEa+0EVSZEjLCKHxA8vGOLLomAs2 +EHooIQdftBVRWKR78aALawPprAGYdsdPGUSPHrJ2tOvWhtMetcEORe9RP7rA6H2rp/rwRk9l8wS0 +pIMp2qb+CNEDfq19XjdE78eA6D1C5RRrVacLGuC6M2bgfSHB1TdDDNcBD/7JbPRf6tzExbbDyEYL +OlYIbWWtBU/vteL1Gcgmk5DooHfTVy3DhGUsd4izNJOIdG8qnSIzOHuMqoImG0HTrAVLjMS0RD02 +yRVFv2JoVsUiWrU2V5GxhTaLkZmHaVRhFZzz+fXjNgjKjGLFMcszM3jQwPhaH2Tl4LB1jFcd/awQ +LYKMYx361DKButQMlC0TZuVlKuc21PGjxTgFNLXOE2ge1jCDj8BkLx1EfQQVNhEuKi2146UqL9XL +iJ2BA+PoYBxd5YzvkTE572vV6ddgQgWkqG3YF9MiK3dLh7/bKSUH4hL/QUXaIC2JmNaGEHV9ABkp +A1cMpCTfZLfzZZgofA2Fo6xZxzcxfKzb6A4+Fyb6B9reDHtMNpAuhmzQJ+JOa86bkT6zjnBT75YN +UH6FCwqOtS6vt3Njkx4IZRUTJyZgXfBHBABWsVBoaOX5HqLVKJ3NWqJk65jkpshzfMzJhJtpDEdj +4Cax0MoIk6iQVutY14l9mCBMrRBJd4PKukwUEzP1zHg/ZtLAIyiQYj6lffD+YDUGvfJmfSE9tw3M +9B6mibFBMEJ3WmEIS2HY6P8JTouc/t4Fi+IoixdEf8frQ1qbgT5AnYYJSP3stbAAjmECDJq5fIpD +Wjtu59YIwFQFRtJRpc/9uJ2TERMSFfFApyEFsTlxChICj8TcMzs97jICMuWZu2i8v/iCkbJlLSWv +l6JVxccgNrIheQoDLT3z2kgK+5krST3ETAjstClMlnyYMEIpa4U5SBHjuzO30OTDez/mZRb8RwSy +QNku0VY1HIIe4jpSU3l41ZPRAWGuH5wGBiQRs5a8MOGnKs9gMuXNxk6uLhMZSilX6L0hJcwkMVuU +8TLDxJiPWj/K6q9DJfGMnfjTWxslGl6hIbKufOZ4OXJtjXL5MVfSaaXGCI22HSA4OSflBYwNIES3 +cqW+BLMnuZuFxcd3LG99OuWbpoteF0byHziXnsfwB7+4GXaEN3l5BkrFuHyoAtWNbxeN0lIXLweQ +QmVWm7e8YfUZMHHUXZj6E174UpxQSmK0sRjqE5fX0bd0Nt4laKfn1bqh0sasBQZJ8CGW609GERCP +tmxI7fodbtZxoRABTY2JR7GtdsPK5LSr9FOz0bw/GZwbbO4Xk4AssbrLaPYZs9HwPkr6cWpKs4dR +oYqrM1FpT3v0YgWEZDPudbLYUkuJ4UCx+Ksv1DFHyZaZGeyJyGgEaGWR5v1wqTrsErXzgN8t5GhN +2bqyxpDN7+KbGfCpZ0tg9T5hBIlcP8WQ03B18Yq4DWwVDAjDzDOqsIziLIuDguilEXczmKQ4vzxw +IJ3L7bhkhZ/cF0aVmoRSdhudyoit6fRbWJzP0I/vhlGEY+aZRXscxuT+QfkpiabhkrMNoaX4nQbA +TU8MEgzIozfcVGZsaeiUXyDgWWTA0GbwPvrQjELWRwFLp2CfBvMRYYBl6FqomRUPkU9v2FJ3MFtT +pPLpGLORwfWGZoixKeCRiZKQzJBcTwizCJvsKoTxciyNQa+r8EtGWno2uk6btqzCuGxSNIr7qk76 +aDjzczBI4aPy7XROINKwCCo/MhecxpSjYJSp+yyi05TRJ6gw9LRlQG5ZnNtISWA7PRpVmJCKPzng +jnhZ8Z+Cb3qk5ZKYH8J2oHtgjzWi7jSmICl8wySRs3lmGoSQj+idKcL6XIpIuWcSO8ZiNWaxRb7W +ZPQJjD2SPHobjbnQ3Z6MSNVYs/oUaRgx/rLogT01w2FUWF76I/dKl0lnBFMGFXYz6dtMqJTrpAj5 +akIxm1Gw3nwYEyOd5Yw9h2ZAfAC9KTCJGeUgnIrWrlyeXH4giNHqYQQ6I2wSEPQwvhdDpBmcLhfF +V9fXsp/wVKvCWD22zAHp2998ZKq8DnNKlJ0tV8cqpNxlvSD5Iua4B4YCF06dir+ozCZHo4D0JzG8 +AcKzgsR6rdjMJh8B9EOxBWmbxojF+Tr6NHrqwPRh7YSxbYg8GTzaLdYEnWz1JPI1K+JhAkiUKbwp +Wx5VqU8zRDsRsFN/Y+PoC7BUmRhULuZB4JpSPi9xmLCY9Mo41d1j+FCP4kFcmADQjUyWsdmn1bvl +dRK1J20te8MlLu4G0DXeJXfzK2H5VIbMZu5xY77M6uVgof3JyEJlo6UvXjEmcAwZqMn5s/xUelyK +CFASGNWZVtcpymf1X4OW6bjOsXB0ajvHEqzRTLRPI/M8aH8eC5Dp0Sx4P2gKRR+iR8YgApUNx0Ju +AME9VVpvtReqQnpwyrTX3VDGBGEtyXE3iRHlhf5S78euiuwZFnOz94cRsMaS6ZGmY3dCk040ChgD +iolOETuYnTFTbI/3ZpVDuUgziQz1jvj8J19hDGkT/7JPpeyH6DZGGPx16XVeLz58evdfrIw+2kLt +geFFpNGgmw0X7Og16JVDejZSH0TTaNOusi3Gsw3g7E7IGiBWsxY7xVZ9Vbl1GyN5oTicmU9eOU5h +dHemTOt+mFeJ97AAXQcGzH54tiUcoUihVu0NWniBbaDlbImiM1B6h8yg7NRpzWQbdR+gazO6clCx +mdeuEFUBjQ5/ZtVYzsEIeoaAMbgc79O6ghMFGEyxz+QYB41F8Q3j5Ak6B4RbqwOgKTicNAaXM4M7 +kdTzYw2YerJGkW1eu2MaLwFeTzNQa+bjc8Ixr7pbtqnNXBiVrKxjxHst0b9IxEKFaoFNqqdzA367 +25DwRmeo61dB/pPI8Y71CTj5AbiHhYm8WCPJsPNeIZ21dM5Gn2CiKUiTp9YnjublJyNtTMr+hI6N +ps31lgEqM2NOcRoQau3CaKx8ts94cqqGlNk8n7wyIpqR4sqDGDV/fYNGOYmNmeAy4bKRCIU08vod +GAbUCN0iJpyZGexuD+S09j0r7xRJioRTwIUyW1phxjGf2VYGfTdGhenyPHl6sBVZaSsqjBkLLDV2 +sjeqNOPRkedTSK+P7qkFWTTcCMQI1Wq+6CUjPdJYT9mg8rbaOSD1UuFcDeA+khmGDjQVJ9s1wMIo +VnHSXHrXc+lHtCgV6NfV1nt1A3/Udr9udc984gxNgPCIwk0iM0D+yNvoXFhYge6q3oDOkrgwsvFI +2fQ5QKJxHShzzuJ1a/RcRuFSwQdbN1CfIlgkT0k2E9a1I3FFDENnczTm0HsT1MJDEqwhqqS0oypQ +oQ4Hi8cbFYOvTFWCL41FMPIDm6lwcMuC7xloNleWj8UIxB2gY/TdCWtQDHFkfHLtVE5H9HiO+xZG +JKqZYWp6QS2vroTTyNaUpjVlI8cJdZRuBoM1JCyYca1MrlLrHUPJZVzpSqBzgq+X19BG7pQi5Onw +lyQanSi40UdIdjuclqOv2nQGBcOxE2zbe1eaaEJQGaYl6iCJogImVgjTB9PBodgVh6kbgsSnxQnq +RibM+s3Kn5j6a1G6Dvhu65kp2XZA5Qdi7Ug7D5z2eIfMDQbslYnUDXqvVSE3UKE0dcL0Ik/Cmtb3 +pGXdzXHIlzsT0tH+wQEVa5QkQqSczUllphIHviD0n0g2iUwmaZk8jE1NbrAOM3paA8c7myzSwKVR +R3/BMjjdvY2wlXePTGUnLXzflcVA76KAaYWkRWp7NrFfCpRAaSCiJfLCdchiG7Gqsw== + + + 400mjdHKlT5+GSbBPI+ig8yHMBN5OtZ8ou3yEXSFNY/1F2Qa3LLTUslKHAsBWPfH19Ji07mod8Jj +yWcCJ6eJryWmhaDlrnApsSVYCuMEhNHXLe3QmUzvREejvI8dZeacqcTRSE807zNPPhutCiOzUXD8 +lZa2Yj+qaGsjwjaSOd9AJnDTWgboYCguqMXqOXpDpaN9E4v+L7UT/Rl3zmPUhcWoQAF2BjneR7f9 +bGR1Eb0LRAArv10WRqOyZo7nyG+nO16ZnJ7cVs/ZaK4QNy1dY8FAyPVj4LwVRhmgCEnaXzqzur1S +CzorY+isTCybZCakFseqwnmyIENRmJmVJyiGk4foq8vEaBUMNANbHeWw080cBeLAGEkkgZYFuoXR +vDBWRqfX7G0Irk4Y5Q29mrLY+WNZ+VwxhE2n9XX1PT9ahB0i0aKjGbRaYJ+s6UalBu0eEoHVj1Xj +yhPPJXBOq1temEwrY2G0aFVMRtM+HTct14M+IPlyX+x3Ht4kIO3I8GXhNby5VOJq70faOTmf0WBA +ikzxpY65vHJjn4ZRDiQIhRxm4Q7NxDqECcWtuHCqi0bX7JxZP4Rs0JVTsfxkvg5eVf+Tke5qfnFS +LE3OJ85sNJ1ctpqpUHnYw8YePZ9/cE0UKwKtoZ+9OkbHUiVxSzq7EZ1cHsgeL+Zs2ixkz7Q82j3R +c9HZHxCoq20RJAyjitKY96PdM8UaWhXEiom6Z7Ih0xaxhDKgbDC9uAgSo7pF8pRF4MNzUanS2Ya4 +gnWEphDqkxnpgPTg/BSqjkAMfEI2hYo6dqCeHjE8Zc/k7lM4xxts0WrdseRl7DgSc7mOkC3uot68 +iB3xLXxkeczaTIZtClXHiidr9eDOHNGjRbzUAGjpkdpYN0w7r9M+iOScU9zsRylUmzpGSkHL+NtH +j1ChFn2UNzT1iXMcjwBEZ9YuWCqw6XM2cEdW8fGe1OOTgVhGUWJR+ItA0El7E/q24PvKg+HcG5V2 +K7SdTDDQS9LST7bHKkcjnXcYm+RFZAUFkGizTugInhn3nKkxa0NbdNiVLeu9d/AUhcJWJnYwhMPA +s5IzOvkXCrsUfAwlmYEdFP0dL1dpKFq6hcoq1DDWmpk4xnp3CopUq1F9lc+skXY2joz6cdACVjCj +12/4R3IvuaQMkDXbgs3jjNXujWgpGKM3UIehgoartBXEeHQ07eBwxfl8nyzG+Q4DEW0BYH+ry7CA +aOUl1BEIVqebAadgLkIJKWTn5UOxWuWQQpUXpQexeDcGZ2B0d2FaOH2Y6Q0bAotUkNHpIay+1LFR +qd6Qq1+1cW6/+SczQlKwEqZbm31aO2ZCOumQXiB1Py+/RUX0ZDFKr9qioeHRbQeurqLXC2EuuQHd +wYJqFgLC9GAxQSkVnqzC1FHqzJyzlMQqzYmjviRrCq/d2uN4PteMV15AIF2gSuJ4AiyeYnIrsCgQ +K6Cv5YjW5tL12eTjO2oq+gB0nDLLeWFE6SjiA60RGcPibrQ5qfZSuHZAbpZPRe1fzlJvTt8u9rR4 +O2jkITiCk/DLz/C6s/l4h0PCfS1KMToz4Vkm6tWAsX561wGwQDqxfkRaGRFQWVgGyNoImJ0iWaBw +an3ZQH2JVi8iwrGPBqdRo5tBYsvwuhWFB5JsbcBs0qkyoklrO6TTna+UT2jeRDkUmxlvHQwgZ7Eg +A54voxRInOvDABLBsI4A/Yzoa50RYO8R5AJC1tR/iWjoMco/AM0imKOvwMuCY++bQajQBvfs80Lg +YYoYSKyAq6rJwDuNTU3525lYib8sypdnE462qRB6NkLfRLEtIDWFYUzbWBhRc+104AugAlOK55ZD +o5SnTwi0SSYETQosemyHBMrto4+6NpgOD3OspdVL/GRGOqHlLCh6xLb4FtwyXYxEtzmX8dnh3ikj +bCihFqsB06wwIGEOfbkyqNcjrwxP2/ujXCEL7RRPcdYj1KcnbXJuCA5baWlap3es94/3bIpP92Gm +PQIs1qCzltHAbUKZo7+bM8s5rCQS8N10yw2Iq5SqmciKPqirhsHTp0gE4oD4UrDmRQU0SBGV8EiB +NAUyE/HSjnTmY5FqIcxWnuiNBgGKuStcohOTLTksF74ZYA8tVOrL+Z6feq+rmNAzMwAUMxuKOdsE +A7L6fsyf/16P9eGNHkuRhFX9EJUuSB9U7QhjUbD7CUJuYMxvM+jnNXrxlw75eSIXf+GEnzO1eA/6 +2UM99qCfXyU79Tc0vmEP+vmN+oQ96GcP+tmDfvZJsQf97EE/e9DPHvSzB/3sQT8/iIjAHvSzB/1s +FYGlisAXqEXFXzLh59lMny1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyx +gi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVb +rGCLFWyxgi1WsMUKfo9iBd9iNnq+BDZRjrfqBf/7n/7xjz//5d/+/hWz0a//9DuPRqeOIY/JQU0h +YT0a/Wy0GI0OGgjgDF8gGZdkGo1OR0L5ObNTq1V5FqPRgcxBmWvFSL8LI4C6yioaw0HT+m5mk8Uw +8dloGo1+vpl5NPrpkVaj0U8vZh6Nfn6582j0V7/Rdx+NDor6NBp9miGeL+fB3jycYyJroStv+ck0 +Gj0eo9Hl6oHCVZrciRnitM7ABBPLhbt+S+mTFQQCoVXkvKDP/kDvlL5qxCedZ6NPo9H7XT9FQQ5Q +uDLmSEPpxdHov/yxuD0F1+SiAPLSaTZ69j8UpXjPRv9ZTrF75j++fDZ6+BFmo6dvPxv9JdbozWz0 +54Tm1XjqE6H5pSHXS0bz88noN5TmR0Lz01z054RmC7HmsegvMpqfj0V/gdF8MxZ9zWi+mVf+nNGc +83os+g2juayvsmA031jcMJr9ei76c0Zzrqu56DeM5ryci/4CWfl2LvqrRmdG82CeT3PRbxjN4YVV +9criXHOa63ou+prT/MzmOacZ0sViMPoNpzkanGYejH7DaS7GGTgPRr/lNMf+xGl+Gox+Q2m+8ozP +g9FfojQ/m3p+Q2l+yWRNab4ZjH5DaV4NWL+lNBsLex6M/gKl+XYw+nNKc22rweg3lOa0Goy+pDSf +BqMvKc03Y89XlOaTwc8vvN81pdlPjNw4kX/LI/n3OkO83VKalT1HXfoZ+TfJVfe7fusZp1kPQ0nn +SmoOvNMyMtrv9lwf3ui5Tqzmsmej/3is5udx1yAem7Og4c4JYs1078lJwFDC4CtWeYYqrGWnBRqT +H2yykxEVYxwjx3m2jKgrcQHDrxzHNWgWs0njM1Qa1xRkO352Nir42R6hNHjD0s53Y/0l2hzR9WQ8 +zempJpOPi0fPphRFHxNWoYEfegRM5/kUCTzqwoi8uDqQUDqUrSkG54kyPB1dOBALk8Wjz0YgP7VJ +k6XoqV7mm7FnUD5hHDQAE4vveTbRIRO8Ha7UemFVrK4Tic2Uyup4CiaUcr6Z2WJ6JsrXxcigAIsM +3DbZfJptppVDug24g/5RjRapn9ffHev4rlOPxrbiuwYmlGomm87qMYnOKpgUeUc9AhSkVJ1D72VR +PHHWTSpKPhQnNWJs5OVAbkCnoLsEhQCVUUOOGFqWniP0Uflr0DVyW4qgYrPup5c347Ezf+mMqNea +ogMOpajDw2cDllMWuOgdKrBtZDDaJqHc81vvqeg/QJVozlD4BfQCJCAABfzSh8/f76k+vNFTUX3S +NnVE59DNkGODVEuDOYByfXYk/euLOeof3gFm0JbXs4OLMthWMgEBOroeLDlOEracwrZO6tWNR3w2 +MneSKbIboNbO/smoU0c3haACFtGuA56I5FLvGCzzyoQvAWlEiWnvo5l6tglGpXc1wQa1fnXrpAWZ +mgTSIwZnpHmjw4Ww1JcLXasAyFr7Smmv1b6KIc2U/mX62Beg+bUCngHPyOKRn0b2jm6QlktMo8/X +kdLV8Qo3z8q4hAdw/+ETFm6nZthCFVYw6P8ykpQo3+8quNfUL/TTA+0gBfn6/TBMLAPR99FxGUFD +RJBw4AsUP/XxU3p5dMNYBmkw2qiEQtDxnbUsfyG3U+09eCouMOygY4KpV0DQwwEx5HWCFjDSjCxg +eALE12u17N/DdjSgEr3SQu1VUZWDf64Pks0kGO2o49L6oNJGud8KrEr5qKGtlKDQiER6UB+XriMh +GIdeAj5AJkjLheYusCQdacoEFSEGvi0Xd4b57w/oPATbyZESJAKVo2/j0aGyhgtoTP5Av9wPxDY0 +SvB8mVLtwuhgIyOIVQBxHvSBW6ME77oYO7ixUoztQOMZPDt53cJCEQ6inU0HhJKpMlietzYg0wLg +NoXFfnSIJxvKpnrnPER2FPPn2zVwfaH1iUBYbpf5sScTfSmnKDda2taNkDvZ6Etp70FQSjp6dBe4 +08hGC1pNLPWWLyVYVJM46Cgm4XEfoE+gMK0PBksd0iXkV4/TcaaG9MBmVdgNP82ONIUaVHI8UTjU +Ql3H6cdNlRrq5cDNlwcjdwcwnFya+6EVrX+JtkU1vrs5/wIyAMERnouKOMewnLOSAt2PZ41SDEh2 +RjT438pEadi1dKxjq4knJNBMLwDEa6C9nZu+qr2e+T2vjQoqL3pDvteyWBnGB4AH72CUFHMGNKNp +c4B8BASIUdK1E7jlaM1fFmFA+cbB4IKY+gkivxwDRKt08Bg68qTJaF058Gx8Zi/PgJJhNsy7d7zp +0MDPBQB3fAu5QGcuroGGZBMD1iSRauz9AeVvkSpaAVZpRonjryPWmqJt9UwGr3de4CkfAhn5IZLP +67fAIA2+kaeZHyguZHx3VHCVAA/oUiRpcvDAoXD6AD+j6wMojNIUYZsOcoN+U8HKtaJ9QKg0jABM +gTRB/QEjlCCATcAsNV4SUZnCK/kVVCXkZ+msENcVuHHeDpP0gO6NUhQUVeKl68/wi+T3dEpejwrF +Us4EaUo8FDAA1/ENFSekYZNp9qILOzzzbHM6AD8tD22cHzhv1FmNyICRNt2gvlrtzH5METi8/NoG +sjK4B2q7mT9bgcjumlNe/5LGuhmhygEBA4BTHg8fUBAFMQ4SloPTDc1Z1A7yeIO+VM861N+gIaJV +H1Kt+tLVjWen64ZkYqNPZDF1QIe20tNHcCAf3xSRTWclWQODOjCMQNohkVm5j0q1HBIeWs7C0GrI +pwAqBwMVDhkMbWYPIMxEQriSjjyPC5JzrSYLo/VKbxH9s9YOtHWVE1RQT2vLWbHd8Whah0leb+xo +A9EXyGhG3axjBxnqgJPbYNJUuBUlaLHKd40jBW5ohaELFulCrKh/UqhyU1Mbu5moVWvKxJSGLJO1 +4vQvmymSLNyCqVZ56nlkMAdAfGUUTe+3OZNeWZ099nMsnwQmIi29md22xWP6ii7lw3niu7SfSqnp +gPkChYdKli2CxAeD7+W8Qa/YAOkVdBK0NzccedQ/94heMI/gwPjCmNdWNMp1MeZxTg== + + + w52M1NdUQoDm02XEU2WrhXMvDcrsdXmwusmyqTcY9Nbw2XrxqF+060JjqWr30Au7vI8A8iq9ax2/ ++vyW4Q1pDq3EDPf1PUw39PMcQo4j0Wbp66WToieg0GbEKi9UV6M5KnYQCpt+YGYBA7MzIxD+6k1k +yrYhVSc5/AyY+z1VfqIjWLc68bIJ9RTQ8DoC5C3oSQOid7wJ0K/JQKyTY5CRVm5XrJwK4Myl92BD +a2nbXdc+HNUpK8BERy6wTPlKu87kzfgtvHEzKk7j2c11euNSEAIMo0JVF+WwsVdB0+ipgbWyRMN4 +eI8sJ8ra6H6MjjQZiEJz4wLzCpNJXZhOSb7oONBLANvXQI+28SU4dXQ+cXSVASfWQgF5W8nIh1El +V4ss3aFQwQkFWZlyfDXVEZyQP+SCYjGutMXHWjENT2SiwciMsCoTOT/9J4vET3E2dBttTKD/Cejp +ZQrWIUJQKdH+HCUfi/kTETcND5MGzzwFdU1Ux42dZNkDqQU6SYXSYOhG5+JYiRzkPFgAC5zBb6J7 +ilF7MN0GT5JTIbJGU+DTUuVQoLUvE0efq+j166SKF2MVwynS49uvYwLdIUPXItSgICb/VnEkEZUP +GiFmBJqtGzjTWMWBjrIngczHzQRncGfeSLpY9uU5dyH/k4PooQJdryTnD+mTT2q0bEAZldBVSwMs +pOJF63tAPP6EInvupsGkF5rNpiBVotDboNsdCGqhXNIhgACyjNYGRGENMtyAl50y00hsAwWITk4a +DOfJaN5as4nO90xIZirtMlqk2wQFxQ39MrKoRdp+Nvm4iiXORp+sqoYykoNzEQ0UdTaykEkxG6RR +dGQWt7wwuX3wIfFxa8ILRDqJ4o0/XKX+ypvok8KG4ztA25PzTHj9cCHVj/bhtBx7HCYIG3SisQgq +0tvatyoMZZZsS6KDQlK8JycUhzYaPCrUvRQeVVvGtrjguCkAqjkfkNk60tR89DFZpFr8ugg4pzTw +sHLAFNmgdy9WOqeNNgPHaOsmVjOZfLYjCfUBBZge0P3C6D/eoa1ApR/lHpg0yx8LeAe8Iv24Nm65 +gHpMkNQQKU4olDEZyEG+bQtnMcRL0K0wv0wf39wOSiEexEwa34vEHPECRfvFMliO6AzG0aHjEg8t +EJYT+V5iE8MGawj7wJMkkVqYgKEl4iUjV+hnXdPJSC8eiWc5DcDYxa6jzIwmKZxiIwEhjOhwFtSq +LtwvmE5wa8m0q8xr00dNsNWGVgb6mDi37AzXbLFIgFcTUNxRbGphBnUNxLijKfDJKFhIR8vGm6Qu +5BAwGiZrQ6ZDTkf3WB6GEHiYdORt0LShD71K3eeQb5G7Q0FkqhPNBlbmwsiocSFajkfut6g2zCZT +4HhQ7G6MFjnuwuhcRJlvearELKLduexjLxGylcPHGdZ8LvtgpOVtcPTCc1BjqhSZIPmjRT/4hZCJ +fY3jIDFwMFhu/TwR7oWVkexsyhaTWb5ApbnAha/pum9QH4CzHUepzwpnWrJyYQor7GtRsAcpB1Kl +HbqMzi6CxkQf+jhyeABpjOZyreJFw49CqbuMHcqCjM6kXkctMCIcN1jx80YfNUU4gkBl+iH6Qk0j +svNNeUChLZ145GCdQu12GV6nG42yZlOslAlHJ1dK7CtzXpS4s45dSxLNAv0uRiT4q4MDcBEQ3BpQ +llub/3g3nKlerd4dvMHFL5lHptOkMySn43blsqFYUAuKl+HZeW5nmKOjaKu96sh6S7qmo3g6BSjo +uxwpdIfmEMBPDE5zQFCQxUX0Wq9lZDgmCDrJPVz4V4EuQOD4sfomtWjk6iIpgUlsng8+q2mjdeih +kw3C0mw01wYWNqca++I0P1fq72gL3Im0kNtLBhAG6hKXTacAbh79LmoThNevNJ1qOLVnwqU3GmLK ++hCbylfBnGDSQBElnWCgM1hj4BNjSWMRO+oY2QQFlUiOnlOgC6qMKxqt6KJ7hSTuafd3ZHXu+a0c +QdcBpqKW6kfXKTxQowVtBqhg6jp9u8f68EaPBZ2C0CgOIRxQUzDoBqyN+OLnmk6Lv3iL2Yuv0Re+ +dPbiI3nhC0cv7pmLe77anrn460a9/4Ymae2Zi79Rn7BnLu6Zi3vm4j4p9szFPXNxz1zcMxf3zMU9 +c/FXQ1DaMxf3zMXfMzvpC8jo+ZeMXvwfCzqUof03JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVq +U6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2Jeo7UKJen/Dy +tVNg/um//vHf/vR//O2Pf/6PP/3t3b/9/Y//80+XP/7lL6Bb//T/6L+5/Nvf/vT3f/z1b3+6/P3f +//r/8jf6J1fzf/qn/+UP/+Xd/w8Un1kg + + + diff --git a/sample/radio/package/package.pro b/sample/radio/package/package.pro new file mode 100644 index 0000000..b9b85a1 --- /dev/null +++ b/sample/radio/package/package.pro @@ -0,0 +1,19 @@ + +DISTFILES = icon.svg config.xml + +copy_icon.target = $$OUT_PWD/root/icon.svg +copy_icon.depends = $$_PRO_FILE_PWD_/icon.svg +copy_icon.commands = $(COPY_FILE) \"$$replace(copy_icon.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_icon.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_icon +PRE_TARGETDEPS += $$copy_icon.target + +copy_config.target = $$OUT_PWD/root/config.xml +copy_config.depends = $$_PRO_FILE_PWD_/config.xml +copy_config.commands = $(COPY_FILE) \"$$replace(copy_config.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_config.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_config +PRE_TARGETDEPS += $$copy_config.target + +wgt.target = package +wgt.commands = wgtpkg-pack -f -o radio.wgt root + +QMAKE_EXTRA_TARGETS += wgt diff --git a/sample/radio/radio.pro b/sample/radio/radio.pro new file mode 100644 index 0000000..80f6d6c --- /dev/null +++ b/sample/radio/radio.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS = app binding package +package.depends += app binding diff --git a/sample/radio_qml/COPYING b/sample/radio_qml/COPYING new file mode 100644 index 0000000..d511905 --- /dev/null +++ b/sample/radio_qml/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/sample/radio_qml/LICENSE b/sample/radio_qml/LICENSE new file mode 100644 index 0000000..31c692a --- /dev/null +++ b/sample/radio_qml/LICENSE @@ -0,0 +1,54 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. + +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: + + You must give any other recipients of the Work or Derivative Works a copy of this License; and + You must cause any modified files to carry prominent notices stating that You changed the files; and + You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and + If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. + + You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS diff --git a/sample/radio_qml/app/PresetDataObject.cpp b/sample/radio_qml/app/PresetDataObject.cpp new file mode 100644 index 0000000..6e69626 --- /dev/null +++ b/sample/radio_qml/app/PresetDataObject.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2016 by Scott Murray + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "PresetDataObject.h" + +PresetDataObject::PresetDataObject(QObject *parent) : QObject(parent) +{ +} + +PresetDataObject::PresetDataObject(const QString &title, const quint32 &frequency, const quint32 &band, QObject *parent) + : QObject(parent), m_title(title), m_frequency(frequency), m_band(band) +{ +} + +QString PresetDataObject::title() const +{ + return m_title; +} + +void PresetDataObject::setTitle(const QString &title) +{ + if (title != m_title) { + m_title = title; + emit titleChanged(); + } +} + +quint32 PresetDataObject::frequency() const +{ + return m_frequency; +} + +void PresetDataObject::setFrequency(const quint32 &frequency) { + if (frequency != m_frequency) { + m_frequency = frequency; + emit frequencyChanged(); + } +} + +quint32 PresetDataObject::band() const +{ + return m_band; +} + +void PresetDataObject::setBand(const quint32 &band) { + if (band != m_band) { + m_band = band; + emit bandChanged(); + } +} diff --git a/sample/radio_qml/app/PresetDataObject.h b/sample/radio_qml/app/PresetDataObject.h new file mode 100644 index 0000000..a43b853 --- /dev/null +++ b/sample/radio_qml/app/PresetDataObject.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2016 by Scott Murray + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRESETDATAOBJECT_H +#define PRESETDATAOBJECT_H + +#include + +class PresetDataObject : public QObject +{ + Q_OBJECT + + Q_PROPERTY(QString title READ title WRITE setTitle NOTIFY titleChanged) + Q_PROPERTY(quint32 frequency READ frequency WRITE setFrequency NOTIFY frequencyChanged) + Q_PROPERTY(quint32 band READ band WRITE setBand NOTIFY bandChanged) + +public: + PresetDataObject(QObject *parent = Q_NULLPTR); + PresetDataObject(const QString &title, const quint32 &frequency, const quint32 &band, QObject *parent = Q_NULLPTR); + + QString title() const; + + void setTitle(const QString &title); + + quint32 frequency() const; + + void setFrequency(const quint32 &frequency); + + quint32 band() const; + + void setBand(const quint32 &band); + +signals: + void titleChanged(); + void frequencyChanged(); + void bandChanged(); + +private: + QString m_title; + quint32 m_frequency; + quint32 m_band; +}; + +#endif // PRESETDATAOBJECT_H diff --git a/sample/radio_qml/app/Radio.qml b/sample/radio_qml/app/Radio.qml new file mode 100644 index 0000000..1b68b94 --- /dev/null +++ b/sample/radio_qml/app/Radio.qml @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtQuick.Layouts 1.1 +import QtQuick.Controls 2.0 +import AGL.Demo.Controls 1.0 +import 'api' as API + +ApplicationWindow { + id: root + + API.Binding { + id: radio + + property string title + + onBandChanged: frequency = minimumFrequency + onStationFound: title = stationId + onFrequencyChanged: { + title = '' + slider.value = frequency + } + } + + API.BindingSoundManager { + id: soundmgr + onConnected: { + radio.start() + } + onDisconnected: { + radio.stop() + } + onPaused: { + radio.stop() + } + } + + ColumnLayout { + anchors.fill: parent + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 3 + clip: true + Image { + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + fillMode: Image.PreserveAspectFit + source: './images/HMI_Radio_Equalizer.svg' + } + Item { + anchors.left: parent.left + anchors.right: parent.right + anchors.bottom: parent.bottom + height :307 + Rectangle { + anchors.fill: parent + color: 'black' + opacity: 0.75 + } + + ColumnLayout { + anchors.fill: parent + anchors.margins: root.width * 0.02 + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Row { + spacing: 20 + Image { + source: './images/FM_Icons_FM.svg' + } +// ToggleButton { +// offImage: './images/FM_Icons_FM.svg' +// onImage: './images/FM_Icons_AM.svg' +// onCheckedChanged: { +// radio.band = checked ? radio.amBand : radio.fmBand +// radio.frequency = radio.minimumFrequency +// } +// } + } + ColumnLayout { + anchors.fill: parent + Label { + id: label + Layout.alignment: Layout.Center + text: radio.freq2str(radio.frequency) + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + } + Label { + id: artist + Layout.alignment: Layout.Center + text: radio.title + horizontalAlignment: Label.AlignHCenter + verticalAlignment: Label.AlignVCenter + font.pixelSize: label.font.pixelSize * 0.6 + } + } + } + Slider { + id: slider + Layout.fillWidth: true + from: radio.minimumFrequency + to: radio.maximumFrequency + stepSize: radio.frequencyStep + snapMode: Slider.SnapOnRelease + onValueChanged: radio.frequency = value + Label { + anchors.left: parent.left + anchors.bottom: parent.top + font.pixelSize: 32 + text: radio.freq2str(radio.minimumFrequency) + } + Label { + anchors.right: parent.right + anchors.bottom: parent.top + font.pixelSize: 32 + text: radio.freq2str(radio.maximumFrequency) + } + } + RowLayout { + Layout.fillHeight: true + + Label { + text: 'TUNE' + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_BackArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.tuneDown() + } + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_ForwardArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.tuneUp() + } + } + + Item { Layout.fillWidth: true } + + ImageButton { + id: play + offImage: './images/AGL_MediaPlayer_Player_Play.svg' + onClicked: { + console.log("connect") + soundmgr.connect() + //radio.start() + } + states: [ + State { + when: radio.state === radio.activeState + PropertyChanges { + target: play + offImage: './images/AGL_MediaPlayer_Player_Pause.svg' + onClicked: soundmgr.disconnect()//radio.stop() + } + } + ] + } + + Item { Layout.fillWidth: true } + + Label { + //Layout.fillWidth: true + text: 'SCAN' + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_BackArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.scanDown() + } + } + + ImageButton { + offImage: './images/AGL_MediaPlayer_ForwardArrow.svg' + Timer { + running: parent.pressed + triggeredOnStart: true + interval: 100 + repeat: true + onTriggered: radio.scanUp() + } + } + + } + } + } + } + Item { + Layout.fillWidth: true + Layout.fillHeight: true + Layout.preferredHeight: 2 + ListView { + anchors.fill: parent + anchors.leftMargin: 50 + anchors.rightMargin: 50 + clip: true + header: Label { text: 'PRESETS'; opacity: 0.5 } + model: presetModel + + delegate: MouseArea { + width: ListView.view.width + height: ListView.view.height / 4 + + onClicked: { + radio.band = model.modelData.band + radio.frequency = model.modelData.frequency + radio.title = model.modelData.title + } + + RowLayout { + anchors.fill: parent + Image { + source: './images/Radio_Active_Icon.svg' + } + ColumnLayout { + Layout.fillWidth: true + Label { + Layout.fillWidth: true + text: model.title + } + Label { + Layout.fillWidth: true + text: radio.freq2str(model.frequency) + color: '#59FF7F' + font.pixelSize: 32 + } + } + Image { + source: { + switch (model.modelData.band) { + case radio.fmBand: + return './images/FM_Icons_FM.svg' + case radio.amBand: + return './images/FM_Icons_AM.svg' + } + return null + } + } + } + } + } + } + } +} diff --git a/sample/radio_qml/app/api/Binding.qml b/sample/radio_qml/app/api/Binding.qml new file mode 100644 index 0000000..d739052 --- /dev/null +++ b/sample/radio_qml/app/api/Binding.qml @@ -0,0 +1,230 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2017 Konsulko Group + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import QtQuick 2.6 +import QtWebSockets 1.0 + +WebSocket { + id: root + active: true + url: bindingAddress + + property string apiString: "radio" + property string smApiString: "soundmanager" + property var verbs: [] + property string payloadLength: "9999" + + readonly property var msgid: { + "call": 2, + "retok": 3, + "reterr": 4, + "event": 5 + } + + readonly property int amBand: 0 + readonly property int fmBand: 1 + + readonly property int stoppedState: 0 + readonly property int activeState: 1 + + property int band: fmBand + property int frequency + property int frequencyStep + property int minimumFrequency + property int maximumFrequency + property int state: stoppedState + property int scanningState: stoppedState + property bool scanningFreqUpdate: false + property string stationId: "" + + signal stationFound + + property Connections c : Connections { + target: root + + onFrequencyChanged: { + if(scanningState != activeState) { + // Not scanning, push update + sendSocketMessage("frequency", { value: frequency }) + } else if(!scanningFreqUpdate) { + // External change, stop scanning + sendSocketMessage("scan_stop", 'None') + scanningState = stoppedState + sendSocketMessage("frequency", { value: frequency }) + } else { + // This update was from scanning, clear state + scanningFreqUpdate = false + } + } + + onBandChanged: { + sendSocketMessage("band", { value: band }) + updateFrequencyRange(band) + updateFrequencyStep(band) + frequency = minimumFrequency + } + } + + onTextMessageReceived: { + var json = JSON.parse(message) + //console.debug("Raw response: " + message) + var request = json[2].request + var response = json[2].response + + switch (json[0]) { + case msgid.call: + break + case msgid.retok: + var verb = verbs.shift() + if (verb == "frequency_range") { + minimumFrequency = response.min + maximumFrequency = response.max + } else if (verb == "frequency_step") { + frequencyStep = response.step + } + break + case msgid.event: + var event = JSON.parse(JSON.stringify(json[2])) + if (event.event === "radio/frequency") { + if(scanningState == activeState) { + scanningFreqUpdate = true + frequency = event.data.value + } + } else if (event.event === "radio/station_found") { + if(scanningState == activeState) { + scanningState = stoppedState + stationId = freq2str(event.data.value) + root.stationFound() + } + } + break + case msg.reterr: + console.debug("Bad return value, binding probably not installed") + break + case MessageId.event: + break + } + } + + onStatusChanged: { + switch (status) { + case WebSocket.Open: + // Initialize band values now that we're connected to the + // binding + updateFrequencyRange(band) + updateFrequencyStep(band) + frequency = minimumFrequency + sendSocketMessage("subscribe", { value: "frequency" }) + sendSocketMessage("subscribe", { value: "station_found" }) + break + case WebSocket.Error: + console.debug("WebSocket error: " + root.errorString) + break + } + } + + function freq2str(freq) { + if (freq > 5000000) { + return '%1 MHz'.arg((freq / 1000000).toFixed(1)) + } else { + return '%1 kHz'.arg((freq / 1000).toFixed(0)) + } + } + + function sendSocketMessage(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, apiString + '/' + + verb, parameter ] + //console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + verbs.push(verb) + sendTextMessage(JSON.stringify(requestJson)) + } + + function start() { + sendSocketMessage("start", 'None') + state = activeState + } + + function stop() { + sendSocketMessage("stop", 'None') + state = stoppedState + } + + function tuneUp() { + frequency += frequencyStep + if(frequency > maximumFrequency) { + frequency = minimumFrequency + } + } + + function tuneDown() { + frequency -= frequencyStep + if(frequency < minimumFrequency) { + frequency = maximumFrequency + } + } + + function scanUp() { + scanningState = activeState + sendSocketMessage("scan_start", { direction: "forward" }) + } + + function scanDown() { + scanningState = activeState + sendSocketMessage("scan_start", { direction: "backward" }) + } + + function updateFrequencyRange(band) { + sendSocketMessage("frequency_range", { band: band }) + } + + function updateFrequencyStep(band) { + sendSocketMessage("frequency_step", { band: band }) + } + + // Add function for communicating sound manager + // This is temporary. It is not better to create function + // for soundmanager in this scope + + function sendSocketMessageToSoundManager(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, smApiString + '/' + + verb, parameter ] + //console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + verbs.push(verb) + sendTextMessage(JSON.stringify(requestJson)) + } + function connect(sourceID, sinkID) { + var str = "{sourceID:" + sourceID + ", sinkID:" + sinkID + "}" + var JsonArg = JSON.stringify(str) + console.log(str) + console.log(JsonArg) + sendSocketMessageToSoundManager("connect", JsonArg) + } + function subscribe(event) { + var str = "{event:" + event + "}" + var JsonArg = JSON.stringify(str) + sendSocketMessageToSoundManager("subscribe", JsonArg) + } + function unsubscribe(event) { + var str = "{event:" + event + "}" + var JsonArg = JSON.stringify(str) + sendSocketMessageToSoundManager("unsubscribe", JsonArg) + } + function registerSource() { + // Nothing for now + } +} diff --git a/sample/radio_qml/app/api/BindingSoundManager.qml b/sample/radio_qml/app/api/BindingSoundManager.qml new file mode 100644 index 0000000..0430762 --- /dev/null +++ b/sample/radio_qml/app/api/BindingSoundManager.qml @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import QtQuick 2.6 +import QtWebSockets 1.0 + +WebSocket { + id: root + active: true + url: bindingAddressSM + property int sourceID + property int connectionID + + property string apiString: "soundmanager" + property var verbs: [] + property string payloadLength: "9999" + + signal connected() + signal disconnected() + signal paused() + + readonly property var msgid: { + "call": 2, + "retok": 3, + "reterr": 4, + "event": 5 + } + + onTextMessageReceived: { + var json = JSON.parse(message); + console.log("Raw response: " + message) + var request = json[2].request + var response = json[2].response + + switch (json[0]) { + case msgid.call: + break + case msgid.retok: + console.log("response:" + response) + var verb = response.verb + var err = response.error + switch(verb){ + case "connect": + console.log("radio: replied by connect") + if(err == 0){ + connectionID = response.mainConnectionID + console.log("radio: mainConnectionID is " + connectionID) + } + break; + case "registerSource": + console.log("radio: replied by registerSource") + if(err == 0){ + sourceID = response.sourceID + } + default: + break; + } + break + case msgid.event: + var content = JSON.parse(JSON.stringify(json[2])); + var eventName = content.event + switch(eventName){ + case "soundmanager\/asyncSetSourceState": + console.log("radio: soundmanager\/asyncSetSourceState") + console.log("radio: my soundID:" + sourceID + "handle:" + content.data.handle + ",sourceID:" + content.data.sourceID + ",sourceState:" + content.data.sourceState) + if(sourceID == content.data.sourceID){ + console.log("radio: call ackSetSourceState") + sendSocketMessage("ackSetSourceState", {handle:content.data.handle, error:0}) + switch(content.data.sourceState){ + case "on": + connected() + break; + case "off": + disconnected() + break; + case "paused": + paused() + break; + } + } + break; + case "soundmanager\/asyncConnect": + // In reality, device shall be opened in this timing + if(connectionID == content.data.connectionID){ + //radio.open_device() + } + break; + case "soundmanager\/asyncDisconnect": + // In reality, device shall be closed in this timing + if(connectionID == content.data.connectionID){ + // radio.close_device() + } + break; + default: + break; + } + break + case msgid.reterr: + console.debug("Bad return value, binding probably not installed") + break + } + } + + onStatusChanged: { + switch (status) { + case WebSocket.Open: + // Initialize band values now that we're connected to the + // binding + sendSocketMessage("subscribe", { event: "asyncSetSourceState" }) + sendSocketMessage("subscribe", { event: "asyncConnect" }) + sendSocketMessage("subscribe", { event: "asyncDisconnect" }) + sendSocketMessage("registerSource", { appname: "radio" }) + break + case WebSocket.Error: + console.debug("WebSocket error: " + root.errorString) + break + } + } + + function sendSocketMessage(verb, parameter) { + var requestJson = [ msgid.call, payloadLength, apiString + '/' + + verb, parameter ] + console.debug("sendSocketMessage: " + JSON.stringify(requestJson)) + sendTextMessage(JSON.stringify(requestJson)) + } + + function connect() { + sendSocketMessage("connect", {sourceID:sourceID,sinkID:1}) + } + + function disconnect() { + sendSocketMessage("disconnect", {mainConnectionID:connectionID}) + } +} diff --git a/sample/radio_qml/app/app.pri b/sample/radio_qml/app/app.pri new file mode 100644 index 0000000..014646f --- /dev/null +++ b/sample/radio_qml/app/app.pri @@ -0,0 +1,12 @@ +TEMPLATE = app + +load(configure) +qtCompileTest(libhomescreen) + +config_libhomescreen { + CONFIG += link_pkgconfig + PKGCONFIG += homescreen + DEFINES += HAVE_LIBHOMESCREEN +} + +DESTDIR = $${OUT_PWD}/../package/root/bin diff --git a/sample/radio_qml/app/app.pro b/sample/radio_qml/app/app.pro new file mode 100644 index 0000000..e0a927e --- /dev/null +++ b/sample/radio_qml/app/app.pro @@ -0,0 +1,11 @@ +TARGET = radio +QT = quickcontrols2 + +HEADERS = PresetDataObject.h +SOURCES = main.cpp PresetDataObject.cpp + +RESOURCES += \ + radio.qrc \ + images/images.qrc + +include(app.pri) diff --git a/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.cpp b/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.cpp new file mode 100644 index 0000000..d698b05 --- /dev/null +++ b/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.cpp @@ -0,0 +1,8 @@ +#include + +int main(int argc,char **argv) +{ + LibHomeScreen libHomeScreen; + return 0; +} + diff --git a/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.pro b/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.pro new file mode 100644 index 0000000..eb4e8f3 --- /dev/null +++ b/sample/radio_qml/app/config.tests/libhomescreen/libhomescreen.pro @@ -0,0 +1,5 @@ +SOURCES = libhomescreen.cpp + +CONFIG -= qt +CONFIG += link_pkgconfig +PKGCONFIG += homescreen diff --git a/sample/radio_qml/app/images/AGL_MediaPlayer_BackArrow.svg b/sample/radio_qml/app/images/AGL_MediaPlayer_BackArrow.svg new file mode 100644 index 0000000..c49b519 --- /dev/null +++ b/sample/radio_qml/app/images/AGL_MediaPlayer_BackArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/AGL_MediaPlayer_ForwardArrow.svg b/sample/radio_qml/app/images/AGL_MediaPlayer_ForwardArrow.svg new file mode 100644 index 0000000..56576ac --- /dev/null +++ b/sample/radio_qml/app/images/AGL_MediaPlayer_ForwardArrow.svg @@ -0,0 +1,56 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Pause.svg b/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Pause.svg new file mode 100644 index 0000000..ee55213 --- /dev/null +++ b/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Pause.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Play.svg b/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Play.svg new file mode 100644 index 0000000..c296f8a --- /dev/null +++ b/sample/radio_qml/app/images/AGL_MediaPlayer_Player_Play.svg @@ -0,0 +1,67 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/FM_Icons_AM.svg b/sample/radio_qml/app/images/FM_Icons_AM.svg new file mode 100644 index 0000000..ea6e5e1 --- /dev/null +++ b/sample/radio_qml/app/images/FM_Icons_AM.svg @@ -0,0 +1,71 @@ + + + +image/svg+xmlFM +AM | + \ No newline at end of file diff --git a/sample/radio_qml/app/images/FM_Icons_FM.svg b/sample/radio_qml/app/images/FM_Icons_FM.svg new file mode 100644 index 0000000..0f3ae59 --- /dev/null +++ b/sample/radio_qml/app/images/FM_Icons_FM.svg @@ -0,0 +1,65 @@ + + + +image/svg+xmlFM +AM | + \ No newline at end of file diff --git a/sample/radio_qml/app/images/HMI_Radio_Equalizer.svg b/sample/radio_qml/app/images/HMI_Radio_Equalizer.svg new file mode 100644 index 0000000..6959144 --- /dev/null +++ b/sample/radio_qml/app/images/HMI_Radio_Equalizer.svg @@ -0,0 +1,335 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/Radio_Active_Icon.svg b/sample/radio_qml/app/images/Radio_Active_Icon.svg new file mode 100644 index 0000000..383f2cd --- /dev/null +++ b/sample/radio_qml/app/images/Radio_Active_Icon.svg @@ -0,0 +1,299 @@ + + + +image/svg+xml \ No newline at end of file diff --git a/sample/radio_qml/app/images/images.qrc b/sample/radio_qml/app/images/images.qrc new file mode 100644 index 0000000..9161221 --- /dev/null +++ b/sample/radio_qml/app/images/images.qrc @@ -0,0 +1,12 @@ + + + AGL_MediaPlayer_BackArrow.svg + AGL_MediaPlayer_ForwardArrow.svg + AGL_MediaPlayer_Player_Pause.svg + AGL_MediaPlayer_Player_Play.svg + FM_Icons_AM.svg + FM_Icons_FM.svg + HMI_Radio_Equalizer.svg + Radio_Active_Icon.svg + + diff --git a/sample/radio_qml/app/main.cpp b/sample/radio_qml/app/main.cpp new file mode 100644 index 0000000..6242d1f --- /dev/null +++ b/sample/radio_qml/app/main.cpp @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2016 The Qt Company Ltd. + * Copyright (C) 2016, 2017 Konsulko Group + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "PresetDataObject.h" + + +#ifdef HAVE_LIBHOMESCREEN +#include +#endif + +int main(int argc, char *argv[]) +{ +#ifdef HAVE_LIBHOMESCREEN + LibHomeScreen libHomeScreen; + + if (!libHomeScreen.renderAppToAreaAllowed(0, 1)) { + qWarning() << "renderAppToAreaAllowed is denied"; + return -1; + } +#endif + + QGuiApplication app(argc, argv); + + QQuickStyle::setStyle("AGL"); + + QCommandLineParser parser; + parser.addPositionalArgument("port", app.translate("main", "port for binding")); + parser.addPositionalArgument("secret", app.translate("main", "secret for binding")); + parser.addHelpOption(); + parser.addVersionOption(); + parser.process(app); + QStringList positionalArguments = parser.positionalArguments(); + + // Read presets from configuration file + // + // If HOME is set, use $HOME/app-data/radio/presets.conf, else fall back + // to the QSettings default locations with organization "AGL" and a + // file name of radio-presets.conf. See: + // + // http://doc.qt.io/qt-5/qsettings.html#platform-specific-notes + // + // for details on the locations and their order of priority. + // + QSettings *pSettings = NULL; + char *p = getenv("HOME"); + if(p) { + QString confPath = p; + confPath.append("/app-data/radio/presets.conf"); + pSettings = new QSettings(confPath, QSettings::NativeFormat); + } else { + pSettings = new QSettings("AGL", "radio-presets"); + } + QList presetDataList; + int size = pSettings->beginReadArray("fmPresets"); + for (int i = 0; i < size; ++i) { + pSettings->setArrayIndex(i); + presetDataList.append(new PresetDataObject(pSettings->value("title").toString(), + pSettings->value("frequency").toInt(), + 1)); + } + pSettings->endArray(); + + QQmlApplicationEngine engine; + QQmlContext *context = engine.rootContext(); + context->setContextProperty("presetModel", QVariant::fromValue(presetDataList)); + if (positionalArguments.length() == 2) { + int port = positionalArguments.takeFirst().toInt(); + QString secret = positionalArguments.takeFirst(); + QUrl bindingAddress; + bindingAddress.setScheme(QStringLiteral("ws")); + bindingAddress.setHost(QStringLiteral("localhost")); + bindingAddress.setPort(port); + bindingAddress.setPath(QStringLiteral("/api")); + QUrlQuery query; + query.addQueryItem(QStringLiteral("token"), secret); + bindingAddress.setQuery(query); + + QUrl bindingAddressSM; + bindingAddressSM.setScheme(QStringLiteral("ws")); + bindingAddressSM.setHost(QStringLiteral("localhost")); + bindingAddressSM.setPort(port); + bindingAddressSM.setPath(QStringLiteral("/api")); + bindingAddressSM.setQuery(query); + + context->setContextProperty(QStringLiteral("bindingAddress"), bindingAddress); + context->setContextProperty(QStringLiteral("bindingAddressSM"), bindingAddressSM); + } + engine.load(QUrl(QStringLiteral("qrc:/Radio.qml"))); + + return app.exec(); +} diff --git a/sample/radio_qml/app/radio.qrc b/sample/radio_qml/app/radio.qrc new file mode 100644 index 0000000..ceea58e --- /dev/null +++ b/sample/radio_qml/app/radio.qrc @@ -0,0 +1,7 @@ + + + Radio.qml + api/Binding.qml + api/BindingSoundManager.qml + + diff --git a/sample/radio_qml/binding/binding.pri b/sample/radio_qml/binding/binding.pri new file mode 100644 index 0000000..3448a56 --- /dev/null +++ b/sample/radio_qml/binding/binding.pri @@ -0,0 +1,6 @@ +TEMPLATE = lib +CONFIG += plugin use_c_linker +CONFIG -= qt +QMAKE_CFLAGS += -Wextra -Wconversion -Wno-unused-parameter -Werror=maybe-uninitialized -Werror=implicit-function-declaration -ffunction-sections -fdata-sections -Wl,--as-needed -Wl,--gc-sections + +DESTDIR = $${OUT_PWD}/../package/root/lib diff --git a/sample/radio_qml/binding/binding.pro b/sample/radio_qml/binding/binding.pro new file mode 100644 index 0000000..d8c5a93 --- /dev/null +++ b/sample/radio_qml/binding/binding.pro @@ -0,0 +1,11 @@ +TARGET = radio-binding + +HEADERS = radio_impl.h radio_output.h rtl_fm.h convenience/convenience.h +SOURCES = radio-binding.c radio_output.c radio_impl_rtlsdr.c rtl_fm.c convenience/convenience.c + +LIBS += -Wl,--version-script=$$PWD/export.map + +CONFIG += link_pkgconfig +PKGCONFIG += json-c afb-daemon librtlsdr glib-2.0 libpulse-simple + +include(binding.pri) diff --git a/sample/radio_qml/binding/convenience/convenience.c b/sample/radio_qml/binding/convenience/convenience.c new file mode 100644 index 0000000..517dc4e --- /dev/null +++ b/sample/radio_qml/binding/convenience/convenience.c @@ -0,0 +1,304 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* a collection of user friendly tools + * todo: use strtol for more flexible int parsing + * */ + +#include +#include +#include + +#ifndef _WIN32 +#include +#else +#include +#include +#include +#define _USE_MATH_DEFINES +#endif + +#include + +#include "rtl-sdr.h" + +double atofs(char *s) +/* standard suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'g': + case 'G': + suff *= 1e3; + case 'm': + case 'M': + suff *= 1e3; + case 'k': + case 'K': + suff *= 1e3; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atoft(char *s) +/* time suffixes, returns seconds */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case 'h': + case 'H': + suff *= 60; + case 'm': + case 'M': + suff *= 60; + case 's': + case 'S': + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +double atofp(char *s) +/* percent suffixes */ +{ + char last; + int len; + double suff = 1.0; + len = strlen(s); + last = s[len-1]; + s[len-1] = '\0'; + switch (last) { + case '%': + suff *= 0.01; + suff *= atof(s); + s[len-1] = last; + return suff; + } + s[len-1] = last; + return atof(s); +} + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain) +{ + int i, r, err1, err2, count, nearest; + int* gains; + r = rtlsdr_set_tuner_gain_mode(dev, 1); + if (r < 0) { + fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); + return r; + } + count = rtlsdr_get_tuner_gains(dev, NULL); + if (count <= 0) { + return 0; + } + gains = malloc(sizeof(int) * count); + count = rtlsdr_get_tuner_gains(dev, gains); + nearest = gains[0]; + for (i=0; i= 0 && device < device_count) { + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string exact match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strcmp(s, serial) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string prefix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + if (strncmp(s, serial, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + /* does string suffix match a serial */ + for (i = 0; i < device_count; i++) { + rtlsdr_get_device_usb_strings(i, vendor, product, serial); + offset = strlen(serial) - strlen(s); + if (offset < 0) { + continue;} + if (strncmp(s, serial+offset, strlen(s)) != 0) { + continue;} + device = i; + fprintf(stderr, "Using device %d: %s\n", + device, rtlsdr_get_device_name((uint32_t)device)); + return device; + } + fprintf(stderr, "No matching devices found.\n"); + return -1; +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/sample/radio_qml/binding/convenience/convenience.h b/sample/radio_qml/binding/convenience/convenience.h new file mode 100644 index 0000000..1faa2af --- /dev/null +++ b/sample/radio_qml/binding/convenience/convenience.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2014 by Kyle Keen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* a collection of user friendly tools */ + +/*! + * Convert standard suffixes (k, M, G) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofs(char *s); + +/*! + * Convert time suffixes (s, m, h) to double + * + * \param s a string to be parsed + * \return seconds as double + */ + +double atoft(char *s); + +/*! + * Convert percent suffixe (%) to double + * + * \param s a string to be parsed + * \return double + */ + +double atofp(char *s); + +/*! + * Find nearest supported gain + * + * \param dev the device handle given by rtlsdr_open() + * \param target_gain in tenths of a dB + * \return 0 on success + */ + +int nearest_gain(rtlsdr_dev_t *dev, int target_gain); + +/*! + * Set device frequency and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param frequency in Hz + * \return 0 on success + */ + +int verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency); + +/*! + * Set device sample rate and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param samp_rate in samples/second + * \return 0 on success + */ + +int verbose_set_sample_rate(rtlsdr_dev_t *dev, uint32_t samp_rate); + +/*! + * Enable or disable the direct sampling mode and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param on 0 means disabled, 1 I-ADC input enabled, 2 Q-ADC input enabled + * \return 0 on success + */ + +int verbose_direct_sampling(rtlsdr_dev_t *dev, int on); + +/*! + * Enable offset tuning and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_offset_tuning(rtlsdr_dev_t *dev); + +/*! + * Enable auto gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_auto_gain(rtlsdr_dev_t *dev); + +/*! + * Set tuner gain and report status on stderr + * + * \param dev the device handle given by rtlsdr_open() + * \param gain in tenths of a dB + * \return 0 on success + */ + +int verbose_gain_set(rtlsdr_dev_t *dev, int gain); + +/*! + * Set the frequency correction value for the device and report status on stderr. + * + * \param dev the device handle given by rtlsdr_open() + * \param ppm_error correction value in parts per million (ppm) + * \return 0 on success + */ + +int verbose_ppm_set(rtlsdr_dev_t *dev, int ppm_error); + +/*! + * Reset buffer + * + * \param dev the device handle given by rtlsdr_open() + * \return 0 on success + */ + +int verbose_reset_buffer(rtlsdr_dev_t *dev); + +/*! + * Find the closest matching device. + * + * \param s a string to be parsed + * \return dev_index int, -1 on error + */ + +int verbose_device_search(char *s); + diff --git a/sample/radio_qml/binding/export.map b/sample/radio_qml/binding/export.map new file mode 100644 index 0000000..52c1b4a --- /dev/null +++ b/sample/radio_qml/binding/export.map @@ -0,0 +1 @@ +{ global: afbBindingV1*; local: *; }; diff --git a/sample/radio_qml/binding/radio-binding.c b/sample/radio_qml/binding/radio-binding.c new file mode 100644 index 0000000..12ed966 --- /dev/null +++ b/sample/radio_qml/binding/radio-binding.c @@ -0,0 +1,493 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "radio_impl.h" + +static const struct afb_binding_interface *interface; + +static struct afb_event freq_event; +static struct afb_event scan_event; + +static void freq_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(freq_event, json_object_get(jresp)); +} + +static void scan_callback(uint32_t frequency, void *data) +{ + json_object *jresp = json_object_new_object(); + json_object *value = json_object_new_int((int) frequency); + + json_object_object_add(jresp, "value", value); + afb_event_push(scan_event, json_object_get(jresp)); +} + +/* + * Binding verb handlers + */ + +/* + * @brief Get (and optionally set) frequency + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + uint32_t frequency; + + if(value) { + char *p; + frequency = strtoul(value, &p, 10); + if(frequency && *p == '\0') { + radio_impl_set_frequency(frequency); + } else { + afb_req_fail(request, "failed", "Invalid scan direction"); + return; + } + } + ret_json = json_object_new_object(); + frequency = radio_impl_get_frequency(); + json_object_object_add(ret_json, "frequency", json_object_new_int((int32_t) frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get (and optionally set) frequency band + * + * @param struct afb_req : an afb request structure + * + */ +static void band(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_band_t band; + char band_name[4]; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_band(band); + } else { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + } + ret_json = json_object_new_object(); + band = radio_impl_get_band(); + sprintf(band_name, "%s", band == BAND_AM ? "AM" : "FM"); + json_object_object_add(ret_json, "band", json_object_new_string(band_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Check if band is supported + * + * @param struct afb_req : an afb request structure + * + */ +static void band_supported(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + json_object_object_add(ret_json, + "supported", + json_object_new_int(radio_impl_band_supported(band))); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency range for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_range(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t min_frequency; + uint32_t max_frequency; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + min_frequency = radio_impl_get_min_frequency(band); + max_frequency = radio_impl_get_max_frequency(band); + json_object_object_add(ret_json, "min", json_object_new_int((int32_t) min_frequency)); + json_object_object_add(ret_json, "max", json_object_new_int((int32_t) max_frequency)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Get frequency step size (Hz) for a band + * + * @param struct afb_req : an afb request structure + * + */ +static void frequency_step(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "band"); + int valid = 0; + radio_band_t band; + uint32_t step; + + if(value) { + if(!strcasecmp(value, "AM")) { + band = BAND_AM; + valid = 1; + } else if(!strcasecmp(value, "FM")) { + band = BAND_FM; + valid = 1; + } else { + char *p; + band = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(band) { + case BAND_AM: + case BAND_FM: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid band"); + return; + } + ret_json = json_object_new_object(); + step = radio_impl_get_frequency_step(band); + json_object_object_add(ret_json, "step", json_object_new_int((int32_t) step)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Start radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void start(struct afb_req request) +{ + radio_impl_start(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Stop radio playback + * + * @param struct afb_req : an afb request structure + * + */ +static void stop(struct afb_req request) +{ + radio_impl_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Scan for a station in the specified direction + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_start(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "direction"); + int valid = 0; + radio_scan_direction_t direction; + + if(value) { + if(!strcasecmp(value, "forward")) { + direction = SCAN_FORWARD; + valid = 1; + } else if(!strcasecmp(value, "backward")) { + direction = SCAN_BACKWARD; + valid = 1; + } else { + char *p; + direction = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(direction) { + case SCAN_FORWARD: + case SCAN_BACKWARD: + valid = 1; + break; + default: + break; + } + } + } + } + if(!valid) { + afb_req_fail(request, "failed", "Invalid direction"); + return; + } + radio_impl_scan_start(direction, scan_callback, NULL); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Stop station scan + * + * @param struct afb_req : an afb request structure + * + */ +static void scan_stop(struct afb_req request) +{ + radio_impl_scan_stop(); + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Get (and optionally set) stereo mode + * + * @param struct afb_req : an afb request structure + * + */ +static void stereo_mode(struct afb_req request) +{ + json_object *ret_json; + const char *value = afb_req_value(request, "value"); + int valid = 0; + radio_stereo_mode_t mode; + char mode_name[4]; + + if(value) { + if(!strcasecmp(value, "mono")) { + mode = MONO; + valid = 1; + } else if(!strcasecmp(value, "stereo")) { + mode = STEREO; + valid = 1; + } else { + char *p; + mode = strtoul(value, &p, 10); + if(p != value && *p == '\0') { + switch(mode) { + case MONO: + case STEREO: + valid = 1; + break; + default: + break; + } + } + } + if(valid) { + radio_impl_set_stereo_mode(mode); + } else { + afb_req_fail(request, "failed", "Invalid mode"); + return; + } + } + ret_json = json_object_new_object(); + mode = radio_impl_get_stereo_mode(); + sprintf(mode_name, "%s", mode == MONO ? "mono" : "stereo"); + json_object_object_add(ret_json, "mode", json_object_new_string(mode_name)); + afb_req_success(request, ret_json, NULL); +} + +/* + * @brief Subscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void subscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_subscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_subscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +/* + * @brief Unsubscribe for an event + * + * @param struct afb_req : an afb request structure + * + */ +static void unsubscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "value"); + if(value) { + if(!strcasecmp(value, "frequency")) { + afb_req_unsubscribe(request, freq_event); + } else if(!strcasecmp(value, "station_found")) { + afb_req_unsubscribe(request, scan_event); + } else { + afb_req_fail(request, "failed", "Invalid event"); + return; + } + } + afb_req_success(request, NULL, NULL); +} + +static const struct afb_verb_desc_v1 verbs[]= { + { "frequency", AFB_SESSION_CHECK, frequency, "Get/Set frequency" }, + { "band", AFB_SESSION_CHECK, band, "Get/Set band" }, + { "band_supported", AFB_SESSION_CHECK, band_supported, "Check band support" }, + { "frequency_range", AFB_SESSION_CHECK, frequency_range, "Get frequency range" }, + { "frequency_step", AFB_SESSION_CHECK, frequency_step, "Get frequency step" }, + { "start", AFB_SESSION_CHECK, start, "Start radio playback" }, + { "stop", AFB_SESSION_CHECK, stop, "Stop radio playback" }, + { "scan_start", AFB_SESSION_CHECK, scan_start, "Start station scan" }, + { "scan_stop", AFB_SESSION_CHECK, scan_stop, "Stop station scan" }, + { "stereo_mode", AFB_SESSION_CHECK, stereo_mode, "Get/Set stereo_mode" }, + { "subscribe", AFB_SESSION_CHECK, subscribe, "Subscribe for an event" }, + { "unsubscribe", AFB_SESSION_CHECK, unsubscribe, "Unsubscribe for an event" }, + { NULL } +}; + +static const struct afb_binding binding_desc = { + .type = AFB_BINDING_VERSION_1, + .v1 = { + .info = "radio service", + .prefix = "radio", + .verbs = verbs + } +}; + +const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) +{ + interface = itf; + + return &binding_desc; +} + +int afbBindingV1ServiceInit(struct afb_service service) +{ + int rc; + + freq_event = afb_daemon_make_event(interface->daemon, "frequency"); + scan_event = afb_daemon_make_event(interface->daemon, "station_found"); + + rc = radio_impl_init(); + if(rc == 0) { + radio_impl_set_frequency_callback(freq_callback, NULL); + } + + return rc; +} diff --git a/sample/radio_qml/binding/radio_impl.h b/sample/radio_qml/binding/radio_impl.h new file mode 100644 index 0000000..79e91a4 --- /dev/null +++ b/sample/radio_qml/binding/radio_impl.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_IMPL_H +#define _RADIO_IMPL_H + +#include + +typedef enum { + BAND_AM = 0, + BAND_FM +} radio_band_t; + +typedef enum { + SCAN_FORWARD = 0, + SCAN_BACKWARD +} radio_scan_direction_t; + +typedef void (*radio_scan_callback_t)(uint32_t frequency, void *data); + +typedef void (*radio_freq_callback_t)(uint32_t frequency, void *data); + +typedef enum { + MONO = 0, + STEREO +} radio_stereo_mode_t; + +int radio_impl_init(void); + +uint32_t radio_impl_get_frequency(void); + +void radio_impl_set_frequency(uint32_t frequency); + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data); + +radio_band_t radio_impl_get_band(void); + +void radio_impl_set_band(radio_band_t band); + +int radio_impl_band_supported(radio_band_t band); + +uint32_t radio_impl_get_min_frequency(radio_band_t band); + +uint32_t radio_impl_get_max_frequency(radio_band_t band); + +uint32_t radio_impl_get_frequency_step(radio_band_t band); + +void radio_impl_start(void); + +void radio_impl_stop(void); + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data); + +void radio_impl_scan_stop(void); + +radio_stereo_mode_t radio_impl_get_stereo_mode(void); + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode); + +#endif /* _RADIO_IMPL_H */ diff --git a/sample/radio_qml/binding/radio_impl_rtlsdr.c b/sample/radio_qml/binding/radio_impl_rtlsdr.c new file mode 100644 index 0000000..4364fd5 --- /dev/null +++ b/sample/radio_qml/binding/radio_impl_rtlsdr.c @@ -0,0 +1,254 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +#include "radio_impl.h" +#include "radio_output.h" +#include "rtl_fm.h" + +// Structure to describe FM band plans, all values in Hz. +typedef struct { + char *name; + uint32_t min; + uint32_t max; + uint32_t step; +} fm_band_plan_t; + +static fm_band_plan_t known_fm_band_plans[5] = { + { .name = "US", .min = 87900000, .max = 107900000, .step = 200000 }, + { .name = "JP", .min = 76100000, .max = 89900000, .step = 100000 }, + { .name = "EU", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-1", .min = 87500000, .max = 108000000, .step = 50000 }, + { .name = "ITU-2", .min = 87900000, .max = 107900000, .step = 50000 } +}; + +static unsigned int bandplan; +static bool present; +static bool active; +static uint32_t current_frequency; + +static void rtl_output_callback(int16_t *result, int result_len, void *ctx) +{ + if(active) + radio_output_write((char*) result, result_len * 2); +} + +int radio_impl_init(void) +{ + GKeyFile* conf_file; + int conf_file_present = 0; + char *value_str; + + if(present) + return -1; + + // Load settings from configuration file if it exists + conf_file = g_key_file_new(); + if(conf_file && + g_key_file_load_from_dirs(conf_file, + "AGL.conf", + (const gchar**) g_get_system_config_dirs(), + NULL, + G_KEY_FILE_KEEP_COMMENTS, + NULL) == TRUE) { + conf_file_present = 1; + + // Set band plan if it is specified + value_str = g_key_file_get_string(conf_file, + "radio", + "fmbandplan", + NULL); + if(value_str) { + unsigned int i; + for(i = 0; + i < sizeof(known_fm_band_plans) / sizeof(fm_band_plan_t); + i++) { + if(!strcasecmp(value_str, known_fm_band_plans[i].name)) { + bandplan = i; + break; + } + } + } + } + fprintf(stderr, "Using FM Bandplan: %s\n", known_fm_band_plans[bandplan].name); + + current_frequency = radio_impl_get_min_frequency(BAND_FM); + if(rtl_fm_init(current_frequency, 200000, 48000, rtl_output_callback, NULL) < 0) { + return -1; + } + + if(conf_file_present) { + GError *error = NULL; + int n; + + // Allow over-riding scanning parameters just in case a demo + // setup needs to do so to work reliably. + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_level", + &error); + //error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND && + //error->code != G_KEY_FILE_ERROR_INVALID_VALUE) { + if(!error) { + fprintf(stderr, "Scanning squelch level set to %d\n", n); + rtl_fm_scan_set_squelch_level(n); + } + + error = NULL; + n = g_key_file_get_integer(conf_file, + "radio", + "scan_squelch_limit", + &error); + if(!error) { + fprintf(stderr, "Scanning squelch limit set to %d\n", n); + rtl_fm_scan_set_squelch_limit(n); + } + + g_key_file_free(conf_file); + } + + present = true; + return 0; +} + +uint32_t radio_impl_get_frequency(void) +{ + return current_frequency; +} + +void radio_impl_set_frequency(uint32_t frequency) +{ + if(!present) + return; + + if(frequency < known_fm_band_plans[bandplan].min || + frequency > known_fm_band_plans[bandplan].max) + return; + + radio_impl_scan_stop(); + current_frequency = frequency; + rtl_fm_set_freq(frequency); +} + +void radio_impl_set_frequency_callback(radio_freq_callback_t callback, + void *data) +{ + rtl_fm_set_freq_callback(callback, data); +} + +radio_band_t radio_impl_get_band(void) +{ + return BAND_FM; +} + +void radio_impl_set_band(radio_band_t band) +{ + // We only support FM, so do nothing +} + +int radio_impl_band_supported(radio_band_t band) +{ + if(band == BAND_FM) + return 1; + return 0; +} + +uint32_t radio_impl_get_min_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].min; +} + +uint32_t radio_impl_get_max_frequency(radio_band_t band) +{ + return known_fm_band_plans[bandplan].max; +} + +uint32_t radio_impl_get_frequency_step(radio_band_t band) +{ + uint32_t ret = 0; + + switch (band) { + case BAND_AM: + ret = 1000; // 1 kHz + break; + case BAND_FM: + ret = known_fm_band_plans[bandplan].step; + break; + default: + break; + } + return ret; +} + +void radio_impl_start(void) +{ + if(!present) + return; + + if(!active) { + if(radio_output_start() != 0) + return; + + rtl_fm_start(); + active = true; + } +} + +void radio_impl_stop(void) +{ + if(!present) + return; + + if(active) { + active = false; + radio_output_stop(); + rtl_fm_stop(); + + } +} + +void radio_impl_scan_start(radio_scan_direction_t direction, + radio_scan_callback_t callback, + void *data) +{ + rtl_fm_scan_start(direction == SCAN_FORWARD ? 0 : 1, + callback, + data, + radio_impl_get_frequency_step(BAND_FM), + radio_impl_get_min_frequency(BAND_FM), + radio_impl_get_max_frequency(BAND_FM)); +} + +void radio_impl_scan_stop(void) +{ + rtl_fm_scan_stop(); +} + +radio_stereo_mode_t radio_impl_get_stereo_mode(void) +{ + return STEREO; +} + +void radio_impl_set_stereo_mode(radio_stereo_mode_t mode) +{ + // We only support stereo, so do nothing +} diff --git a/sample/radio_qml/binding/radio_output.c b/sample/radio_qml/binding/radio_output.c new file mode 100644 index 0000000..a49687b --- /dev/null +++ b/sample/radio_qml/binding/radio_output.c @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#include "radio_output.h" +#include "rtl_fm.h" + +static pa_threaded_mainloop *mainloop; +static pa_context *context; +static pa_stream *stream; + +static unsigned int extra; +static int16_t extra_buf[1]; +static unsigned char *output_buf; + +static void pa_context_state_cb(pa_context *c, void *data) { + pa_operation *o; + + assert(c); + switch (pa_context_get_state(c)) { + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + case PA_CONTEXT_READY: + break; + case PA_CONTEXT_TERMINATED: + pa_threaded_mainloop_stop(mainloop); + break; + case PA_CONTEXT_FAILED: + default: + fprintf(stderr, "PA connection failed: %s\n", + pa_strerror(pa_context_errno(c))); + pa_threaded_mainloop_stop(mainloop); + break; + } + pa_threaded_mainloop_signal(mainloop, 0); +} + +int radio_output_open(void) +{ + pa_context *c; + pa_mainloop_api *mapi; + char *client; + + if(context) + return 0; + + if (!(mainloop = pa_threaded_mainloop_new())) { + fprintf(stderr, "pa_mainloop_new() failed.\n"); + return -1; + } + + pa_threaded_mainloop_set_name(mainloop, "pa_mainloop"); + mapi = pa_threaded_mainloop_get_api(mainloop); + + client = pa_xstrdup("radio"); + if (!(c = pa_context_new(mapi, client))) { + fprintf(stderr, "pa_context_new() failed.\n"); + goto exit; + } + + pa_context_set_state_callback(c, pa_context_state_cb, NULL); + if (pa_context_connect(c, NULL, 0, NULL) < 0) { + fprintf(stderr, "pa_context_connect(): %s", pa_strerror(pa_context_errno(c))); + goto exit; + } + + if (pa_threaded_mainloop_start(mainloop) < 0) { + fprintf(stderr, "pa_mainloop_run() failed.\n"); + goto exit; + } + + context = c; + + extra = 0; + output_buf = malloc(sizeof(unsigned char) * RTL_FM_MAXIMUM_BUF_LENGTH); + + return 0; + +exit: + if (c) + pa_context_unref(c); + + if (mainloop) + pa_threaded_mainloop_free(mainloop); + + pa_xfree(client); + return -1; +} + +int radio_output_start(void) +{ + int error = 0; + pa_sample_spec *spec; + + if(stream) + return 0; + + if(!context) { + error = radio_output_open(); + if(error != 0) + return error; + } + + while(pa_context_get_state(context) != PA_CONTEXT_READY) + pa_threaded_mainloop_wait(mainloop); + + spec = (pa_sample_spec*) calloc(1, sizeof(pa_sample_spec)); + spec->format = PA_SAMPLE_S16LE; + spec->rate = 24000; + spec->channels = 2; + if (!pa_sample_spec_valid(spec)) { + fprintf(stderr, "%s\n", + pa_strerror(pa_context_errno(context))); + return -1; + } + + pa_threaded_mainloop_lock(mainloop); + pa_proplist *props = pa_proplist_new(); + pa_proplist_sets(props, PA_PROP_MEDIA_ROLE, "radio"); + stream = pa_stream_new_with_proplist(context, "radio-output", spec, 0, props); + if(!stream) { + fprintf(stderr, "Error creating stream %s\n", + pa_strerror(pa_context_errno(context))); + pa_proplist_free(props); + free(spec); + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + pa_proplist_free(props); + free(spec); + + if(pa_stream_connect_playback(stream, + NULL, + NULL, + (pa_stream_flags_t) 0, + NULL, + NULL) < 0) { + fprintf(stderr, "Error connecting to PulseAudio : %s\n", + pa_strerror(pa_context_errno(context))); + pa_stream_unref(stream); + stream = NULL; + pa_threaded_mainloop_unlock(mainloop); + return -1; + } + + pa_threaded_mainloop_unlock(mainloop); + + while(pa_stream_get_state(stream) != PA_STREAM_READY) + pa_threaded_mainloop_wait(mainloop); + + return error; +} + +void radio_output_stop(void) +{ + if(stream) { + pa_threaded_mainloop_lock(mainloop); + + pa_stream_set_state_callback(stream, 0, 0); + pa_stream_set_write_callback(stream, 0, 0); + pa_stream_set_underflow_callback(stream, 0, 0); + pa_stream_set_overflow_callback(stream, 0, 0); + pa_stream_set_latency_update_callback(stream, 0, 0); + + pa_operation *o = pa_stream_flush(stream, NULL, NULL); + if(o) + pa_operation_unref(o); + + pa_stream_disconnect(stream); + pa_stream_unref(stream); + stream = NULL; + + pa_threaded_mainloop_unlock(mainloop); + } +} + +void radio_output_suspend(int state) +{ + if(stream) { + pa_stream_cork(stream, state, NULL, NULL); + } +} + +void radio_output_close(void) +{ + radio_output_stop(); + + if(context) { + pa_context_disconnect(context); + pa_context_unref(context); + context = NULL; + } + + if(mainloop) { + pa_threaded_mainloop_stop(mainloop); + pa_threaded_mainloop_free(mainloop); + mainloop = NULL; + } + + free(output_buf); + output_buf = NULL; +} + +int radio_output_write(void *buf, int len) +{ + int rc = -EINVAL; + int error; + size_t n = len; + size_t avail; + int samples = len / 2; + void *p; + + if(!stream) { + return -1; + } + + if(!buf) { + fprintf(stderr, "Error: buf == null!\n"); + return rc; + } + + pa_threaded_mainloop_lock(mainloop); + + avail = pa_stream_writable_size(stream); + if(avail < n) { + /* + * NOTE: Definitely room for improvement here,but for now just + * check for the no space case that happens when the + * stream is corked. + */ + if(!avail) { + rc = 0; + goto exit; + } + } + + /* + * Handle the rtl_fm code giving us an odd number of samples, which + * PA does not like. This extra buffer copying approach is not + * particularly efficient, but works for now. It looks feasible to + * hack in something in the demod and output thread routines in + * rtl_fm.c to handle it there if more performance is required. + */ + p = output_buf; + if(extra) { + memcpy(output_buf, extra_buf, sizeof(int16_t)); + if((extra + samples) % 2) { + // We still have an extra sample, n remains the same, store the extra + memcpy(output_buf + sizeof(int16_t), buf, n - 2); + memcpy(extra_buf, ((unsigned char*) buf) + n - 2, sizeof(int16_t)); + } else { + // We have an even number of samples, no extra + memcpy(output_buf + sizeof(int16_t), buf, n); + n += 2; + extra = 0; + } + } else if(samples % 2) { + // We have an extra sample, store it, and decrease n + n -= 2; + memcpy(output_buf + sizeof(int16_t), buf, n); + memcpy(extra_buf, ((unsigned char*) buf) + n, sizeof(int16_t)); + extra = 1; + } else { + p = buf; + } + + if ((rc = pa_stream_write(stream, p, n, NULL, 0, PA_SEEK_RELATIVE)) < 0) { + fprintf(stderr, "Error writing %d bytes to PulseAudio : %s\n", + n, pa_strerror(pa_context_errno(context))); + } +exit: + pa_threaded_mainloop_unlock(mainloop); + + return rc; +} diff --git a/sample/radio_qml/binding/radio_output.h b/sample/radio_qml/binding/radio_output.h new file mode 100644 index 0000000..2192811 --- /dev/null +++ b/sample/radio_qml/binding/radio_output.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2017 Konsulko Group + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _RADIO_OUTPUT_H +#define _RADIO_OUTPUT_H + +int radio_output_open(void); + +int radio_output_start(void); + +void radio_output_stop(void); + +void radio_output_close(void); + +int radio_output_write(void *buf, int len); + +#endif /* _RADIO_OUTPUT_H */ + diff --git a/sample/radio_qml/binding/rtl_fm.c b/sample/radio_qml/binding/rtl_fm.c new file mode 100644 index 0000000..1c6a6b2 --- /dev/null +++ b/sample/radio_qml/binding/rtl_fm.c @@ -0,0 +1,1267 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2012 by Steve Markgraf + * Copyright (C) 2012 by Hoernchen + * Copyright (C) 2012 by Kyle Keen + * Copyright (C) 2013 by Elias Oenal + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +/* + * Note that this version replaces the standalone main() with separate + * init/start/stop API calls to allow building into another application. + * Other than removing the separate controller thread and adding an output + * function callback, other changes have been kept to a minimum to + * potentially allow using other rtl_fm features by modifying rtl_fm_init. + * + * December 2016, Scott Murray + */ + +/* + * written because people could not do real time + * FM demod on Atom hardware with GNU radio + * based on rtl_sdr.c and rtl_tcp.c + * + * lots of locks, but that is okay + * (no many-to-many locks) + * + * todo: + * sanity checks + * scale squelch to other input parameters + * test all the demodulations + * pad output on hop + * frequency ranges could be stored better + * scaled AM demod amplification + * auto-hop after time limit + * peak detector to tune onto stronger signals + * fifo for active hop frequency + * clips + * noise squelch + * merge stereo patch + * merge soft agc patch + * merge udp patch + * testmode to detect overruns + * watchdog to reset bad dongle + * fix oversampling + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rtl-sdr.h" +#include "rtl_fm.h" +#include "convenience/convenience.h" + +#define DEFAULT_SAMPLE_RATE 24000 +#define DEFAULT_BUF_LENGTH RTL_FM_DEFAULT_BUF_LENGTH +#define MAXIMUM_OVERSAMPLE RTL_FM_MAXIMUM_OVERSAMPLE +#define MAXIMUM_BUF_LENGTH RTL_FM_MAXIMUM_BUF_LENGTH +#define AUTO_GAIN -100 +#define BUFFER_DUMP 4096 + +#define FREQUENCIES_LIMIT 1000 + +#define DEFAULT_SQUELCH_LEVEL 140 +#define DEFAULT_CONSEQ_SQUELCH 10 + +static volatile int do_exit = 0; +static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1}; +static int ACTUAL_BUF_LENGTH; + +static int *atan_lut = NULL; +static int atan_lut_size = 131072; /* 512 KB */ +static int atan_lut_coef = 8; + +struct dongle_state +{ + int exit_flag; + pthread_t thread; + rtlsdr_dev_t *dev; + int dev_index; + uint32_t freq; + uint32_t rate; + int gain; + uint16_t buf16[MAXIMUM_BUF_LENGTH]; + uint32_t buf_len; + int ppm_error; + int offset_tuning; + int direct_sampling; + int mute; + struct demod_state *demod_target; +}; + +struct demod_state +{ + int exit_flag; + pthread_t thread; + int16_t lowpassed[MAXIMUM_BUF_LENGTH]; + int lp_len; + int16_t lp_i_hist[10][6]; + int16_t lp_q_hist[10][6]; + int16_t result[MAXIMUM_BUF_LENGTH]; + int16_t droop_i_hist[9]; + int16_t droop_q_hist[9]; + int result_len; + int rate_in; + int rate_out; + int rate_out2; + int now_r, now_j; + int pre_r, pre_j; + int prev_index; + int downsample; /* min 1, max 256 */ + int post_downsample; + int output_scale; + int squelch_level, conseq_squelch, squelch_hits, terminate_on_squelch; + int downsample_passes; + int comp_fir_size; + int custom_atan; + int deemph, deemph_a; + int now_lpr; + int prev_lpr_index; + int dc_block, dc_avg; + void (*mode_demod)(struct demod_state*); + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; + struct output_state *output_target; +}; + +struct output_state +{ + int exit_flag; + pthread_t thread; + rtl_fm_output_fn_t output_fn; + void *output_fn_data; + int16_t result[MAXIMUM_BUF_LENGTH]; + int result_len; + int rate; + pthread_rwlock_t rw; + pthread_cond_t ready; + pthread_mutex_t ready_m; +}; + +struct controller_state +{ + int exit_flag; + pthread_t thread; + uint32_t freqs[FREQUENCIES_LIMIT]; + int freq_len; + int freq_now; + int edge; + int wb_mode; + pthread_cond_t hop; + pthread_mutex_t hop_m; + + void (*freq_callback)(uint32_t, void*); + void *freq_callback_data; + + int scanning; + int scan_direction; + void (*scan_callback)(uint32_t, void*); + void *scan_callback_data; + uint32_t scan_step; + uint32_t scan_min; + uint32_t scan_max; + int scan_squelch_level; + int scan_squelch_count; +}; + +// multiple of these, eventually +struct dongle_state dongle; +struct demod_state demod; +struct output_state output; +struct controller_state controller; + +#if 0 +static void sighandler(int signum) +{ + fprintf(stderr, "Signal caught, exiting!\n"); + do_exit = 1; + rtlsdr_cancel_async(dongle.dev); +} +#endif + +/* more cond dumbness */ +#define safe_cond_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m) +#define safe_cond_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m) + +/* {length, coef, coef, coef} and scaled by 2^15 + for now, only length 9, optimal way to get +85% bandwidth */ +#define CIC_TABLE_MAX 10 +int cic_9_tables[][10] = { + {0,}, + {9, -156, -97, 2798, -15489, 61019, -15489, 2798, -97, -156}, + {9, -128, -568, 5593, -24125, 74126, -24125, 5593, -568, -128}, + {9, -129, -639, 6187, -26281, 77511, -26281, 6187, -639, -129}, + {9, -122, -612, 6082, -26353, 77818, -26353, 6082, -612, -122}, + {9, -120, -602, 6015, -26269, 77757, -26269, 6015, -602, -120}, + {9, -120, -582, 5951, -26128, 77542, -26128, 5951, -582, -120}, + {9, -119, -580, 5931, -26094, 77505, -26094, 5931, -580, -119}, + {9, -119, -578, 5921, -26077, 77484, -26077, 5921, -578, -119}, + {9, -119, -577, 5917, -26067, 77473, -26067, 5917, -577, -119}, + {9, -199, -362, 5303, -25505, 77489, -25505, 5303, -362, -199}, +}; + +void rotate_90(unsigned char *buf, uint32_t len) +/* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j + or [0, 1, -3, 2, -4, -5, 7, -6] */ +{ + uint32_t i; + unsigned char tmp; + for (i=0; ilp_len) { + d->now_r += d->lowpassed[i]; + d->now_j += d->lowpassed[i+1]; + i += 2; + d->prev_index++; + if (d->prev_index < d->downsample) { + continue; + } + d->lowpassed[i2] = d->now_r; // * d->output_scale; + d->lowpassed[i2+1] = d->now_j; // * d->output_scale; + d->prev_index = 0; + d->now_r = 0; + d->now_j = 0; + i2 += 2; + } + d->lp_len = i2; +} + +int low_pass_simple(int16_t *signal2, int len, int step) +// no wrap around, length must be multiple of step +{ + int i, i2, sum; + for(i=0; i < len; i+=step) { + sum = 0; + for(i2=0; i2rate_out; + int slow = s->rate_out2; + while (i < s->result_len) { + s->now_lpr += s->result[i]; + i++; + s->prev_lpr_index += slow; + if (s->prev_lpr_index < fast) { + continue; + } + s->result[i2] = (int16_t)(s->now_lpr / (fast/slow)); + s->prev_lpr_index -= fast; + s->now_lpr = 0; + i2 += 1; + } + s->result_len = i2; +} + +void fifth_order(int16_t *data, int length, int16_t *hist) +/* for half of interleaved data */ +{ + int i; + int16_t a, b, c, d, e, f; + a = hist[1]; + b = hist[2]; + c = hist[3]; + d = hist[4]; + e = hist[5]; + f = data[0]; + /* a downsample should improve resolution, so don't fully shift */ + data[0] = (a + (b+e)*5 + (c+d)*10 + f) >> 4; + for (i=4; i> 4; + } + /* archive */ + hist[0] = a; + hist[1] = b; + hist[2] = c; + hist[3] = d; + hist[4] = e; + hist[5] = f; +} + +void generic_fir(int16_t *data, int length, int *fir, int16_t *hist) +/* Okay, not at all generic. Assumes length 9, fix that eventually. */ +{ + int d, temp, sum; + for (d=0; d> 15 ; + hist[0] = hist[1]; + hist[1] = hist[2]; + hist[2] = hist[3]; + hist[3] = hist[4]; + hist[4] = hist[5]; + hist[5] = hist[6]; + hist[6] = hist[7]; + hist[7] = hist[8]; + hist[8] = temp; + } +} + +/* define our own complex math ops + because ARMv5 has no hardware float */ + +void multiply(int ar, int aj, int br, int bj, int *cr, int *cj) +{ + *cr = ar*br - aj*bj; + *cj = aj*br + ar*bj; +} + +int polar_discriminant(int ar, int aj, int br, int bj) +{ + int cr, cj; + double angle; + multiply(ar, aj, br, -bj, &cr, &cj); + angle = atan2((double)cj, (double)cr); + return (int)(angle / 3.14159 * (1<<14)); +} + +int fast_atan2(int y, int x) +/* pre scaled for int16 */ +{ + int yabs, angle; + int pi4=(1<<12), pi34=3*(1<<12); // note pi = 1<<14 + if (x==0 && y==0) { + return 0; + } + yabs = y; + if (yabs < 0) { + yabs = -yabs; + } + if (x >= 0) { + angle = pi4 - pi4 * (x-yabs) / (x+yabs); + } else { + angle = pi34 - pi4 * (x+yabs) / (yabs-x); + } + if (y < 0) { + return -angle; + } + return angle; +} + +int polar_disc_fast(int ar, int aj, int br, int bj) +{ + int cr, cj; + multiply(ar, aj, br, -bj, &cr, &cj); + return fast_atan2(cj, cr); +} + +int atan_lut_init(void) +{ + int i = 0; + + atan_lut = malloc(atan_lut_size * sizeof(int)); + + for (i = 0; i < atan_lut_size; i++) { + atan_lut[i] = (int) (atan((double) i / (1< 0) + {return 1 << 13;} + if (cr == 0 && cj < 0) + {return -(1 << 13);} + if (cj == 0 && cr > 0) + {return 0;} + if (cj == 0 && cr < 0) + {return 1 << 14;} + } + + /* real range -32768 - 32768 use 64x range -> absolute maximum: 2097152 */ + x = (cj << atan_lut_coef) / cr; + x_abs = abs(x); + + if (x_abs >= atan_lut_size) { + /* we can use linear range, but it is not necessary */ + return (cj > 0) ? 1<<13 : -1<<13; + } + + if (x > 0) { + return (cj > 0) ? atan_lut[x] : atan_lut[x] - (1<<14); + } else { + return (cj > 0) ? (1<<14) - atan_lut[-x] : -atan_lut[-x]; + } + + return 0; +} + +void fm_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + pcm = polar_discriminant(lp[0], lp[1], + fm->pre_r, fm->pre_j); + fm->result[0] = (int16_t)pcm; + for (i = 2; i < (fm->lp_len-1); i += 2) { + switch (fm->custom_atan) { + case 0: + pcm = polar_discriminant(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 1: + pcm = polar_disc_fast(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + case 2: + pcm = polar_disc_lut(lp[i], lp[i+1], + lp[i-2], lp[i-1]); + break; + } + fm->result[i/2] = (int16_t)pcm; + } + fm->pre_r = lp[fm->lp_len - 2]; + fm->pre_j = lp[fm->lp_len - 1]; + fm->result_len = fm->lp_len/2; +} + +void am_demod(struct demod_state *fm) +// todo, fix this extreme laziness +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + // hypot uses floats but won't overflow + //r[i/2] = (int16_t)hypot(lp[i], lp[i+1]); + pcm = lp[i] * lp[i]; + pcm += lp[i+1] * lp[i+1]; + r[i/2] = (int16_t)sqrt(pcm) * fm->output_scale; + } + fm->result_len = fm->lp_len/2; + // lowpass? (3khz) highpass? (dc) +} + +void usb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] + lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void lsb_demod(struct demod_state *fm) +{ + int i, pcm; + int16_t *lp = fm->lowpassed; + int16_t *r = fm->result; + for (i = 0; i < fm->lp_len; i += 2) { + pcm = lp[i] - lp[i+1]; + r[i/2] = (int16_t)pcm * fm->output_scale; + } + fm->result_len = fm->lp_len/2; +} + +void raw_demod(struct demod_state *fm) +{ + int i; + for (i = 0; i < fm->lp_len; i++) { + fm->result[i] = (int16_t)fm->lowpassed[i]; + } + fm->result_len = fm->lp_len; +} + +void deemph_filter(struct demod_state *fm) +{ + static int avg; // cheating... + int i, d; + // de-emph IIR + // avg = avg * (1 - alpha) + sample * alpha; + for (i = 0; i < fm->result_len; i++) { + d = fm->result[i] - avg; + if (d > 0) { + avg += (d + fm->deemph_a/2) / fm->deemph_a; + } else { + avg += (d - fm->deemph_a/2) / fm->deemph_a; + } + fm->result[i] = (int16_t)avg; + } +} + +void dc_block_filter(struct demod_state *fm) +{ + int i, avg; + int64_t sum = 0; + for (i=0; i < fm->result_len; i++) { + sum += fm->result[i]; + } + avg = sum / fm->result_len; + avg = (avg + fm->dc_avg * 9) / 10; + for (i=0; i < fm->result_len; i++) { + fm->result[i] -= avg; + } + fm->dc_avg = avg; +} + +int mad(int16_t *samples, int len, int step) +/* mean average deviation */ +{ + int i=0, sum=0, ave=0; + if (len == 0) + {return 0;} + for (i=0; i len2) { + tick -= len2; + i++; + } + if (i >= len1) { + i = len1 - 1; + tick = len2; + } + } +} + +void arbitrary_downsample(int16_t *buf1, int16_t *buf2, int len1, int len2) +/* fractional boxcar lowpass, len1 > len2 */ +{ + int i = 1; + int j = 0; + int tick = 0; + double remainder = 0; + double frac; // use integers... + buf2[0] = 0; + while (j < len2) { + frac = 1.0; + if ((tick + len2) > len1) { + frac = (double)(len1 - tick) / (double)len2;} + buf2[j] += (int16_t)((double)buf1[i] * frac + remainder); + remainder = (double)buf1[i] * (1.0-frac); + tick += len2; + i++; + if (tick > len1) { + j++; + buf2[j] = 0; + tick -= len1; + } + if (i >= len1) { + i = len1 - 1; + tick = len1; + } + } + for (j=0; jdownsample_passes; + if (ds_p) { + for (i=0; i < ds_p; i++) { + fifth_order(d->lowpassed, (d->lp_len >> i), d->lp_i_hist[i]); + fifth_order(d->lowpassed+1, (d->lp_len >> i) - 1, d->lp_q_hist[i]); + } + d->lp_len = d->lp_len >> ds_p; + /* droop compensation */ + if (d->comp_fir_size == 9 && ds_p <= CIC_TABLE_MAX) { + generic_fir(d->lowpassed, d->lp_len, + cic_9_tables[ds_p], d->droop_i_hist); + generic_fir(d->lowpassed+1, d->lp_len-1, + cic_9_tables[ds_p], d->droop_q_hist); + } + } else { + low_pass(d); + } + /* power squelch */ + if (d->squelch_level) { + sr = rms(d->lowpassed, d->lp_len, 1); + if (sr < d->squelch_level) { + d->squelch_hits++; + for (i=0; i< d->lp_len; i++) { + d->lowpassed[i] = 0; + } + } else { + d->squelch_hits = 0; + } + } + d->mode_demod(d); /* lowpassed -> result */ + if (d->mode_demod == &raw_demod) { + return; + } + /* todo, fm noise squelch */ + // use nicer filter here too? + if (d->post_downsample > 1) { + d->result_len = low_pass_simple(d->result, d->result_len, d->post_downsample);} + if (d->deemph) { + deemph_filter(d);} + if (d->dc_block) { + dc_block_filter(d);} + if (d->rate_out2 > 0) { + low_pass_real(d); + //arbitrary_resample(d->result, d->result, d->result_len, d->result_len * d->rate_out2 / d->rate_out); + } +} + +static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx) +{ + int i; + struct dongle_state *s = ctx; + struct demod_state *d = s->demod_target; + + if (do_exit) { + return;} + if (!ctx) { + return;} + if (s->mute) { + for (i=0; imute; i++) { + buf[i] = 127;} + s->mute = 0; + } + if (!s->offset_tuning) { + rotate_90(buf, len);} + for (i=0; i<(int)len; i++) { + s->buf16[i] = (int16_t)buf[i] - 127;} + pthread_rwlock_wrlock(&d->rw); + memcpy(d->lowpassed, s->buf16, 2*len); + d->lp_len = len; + pthread_rwlock_unlock(&d->rw); + safe_cond_signal(&d->ready, &d->ready_m); +} + +static void *dongle_thread_fn(void *arg) +{ + struct dongle_state *s = arg; + fprintf(stderr, "dongle_thread_fn running\n"); + rtlsdr_read_async(s->dev, rtlsdr_callback, s, 0, s->buf_len); + fprintf(stderr, "dongle_thread_fn exited!\n"); + return 0; +} + +static void rtl_fm_scan_callback(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = rtl_fm_get_freq(); + + if(!s->scanning) + return; + + if(!s->scan_direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); +} + +static void rtl_fm_scan_end_callback(void) +{ + struct controller_state *s = &controller; + + if(!s->scanning) + return; + + rtl_fm_scan_stop(); + + if(s->scan_callback) + s->scan_callback(rtl_fm_get_freq(), s->scan_callback_data); +} + +static void *demod_thread_fn(void *arg) +{ + struct demod_state *d = arg; + struct output_state *o = d->output_target; + fprintf(stderr, "demod_thread_fn running\n"); + while (!do_exit) { + safe_cond_wait(&d->ready, &d->ready_m); + pthread_rwlock_wrlock(&d->rw); + full_demod(d); + pthread_rwlock_unlock(&d->rw); + if (d->exit_flag) { + do_exit = 1; + } + if (d->squelch_level) { + if(d->squelch_hits > d->conseq_squelch) { + d->squelch_hits = d->conseq_squelch + 1; /* hair trigger */ + //safe_cond_signal(&controller.hop, &controller.hop_m); + rtl_fm_scan_callback(); + continue; + } else if(!d->squelch_hits) { + rtl_fm_scan_end_callback(); + } + } + pthread_rwlock_wrlock(&o->rw); + memcpy(o->result, d->result, 2*d->result_len); + o->result_len = d->result_len; + pthread_rwlock_unlock(&o->rw); + safe_cond_signal(&o->ready, &o->ready_m); + } + fprintf(stderr, "demod_thread_fn exited!\n"); + return 0; +} + +static void *output_thread_fn(void *arg) +{ + struct output_state *s = arg; + fprintf(stderr, "output_thread_fn running\n"); + while (!do_exit) { + // use timedwait and pad out under runs + safe_cond_wait(&s->ready, &s->ready_m); + pthread_rwlock_rdlock(&s->rw); + if(s->output_fn) { + s->output_fn(s->result, s->result_len, s->output_fn_data); + } + pthread_rwlock_unlock(&s->rw); + } + fprintf(stderr, "output_thread_fn exited!\n"); + return 0; +} + +static void optimal_settings(int freq, int rate) +{ + // giant ball of hacks + // seems unable to do a single pass, 2:1 + int capture_freq, capture_rate; + struct dongle_state *d = &dongle; + struct demod_state *dm = &demod; + struct controller_state *cs = &controller; + dm->downsample = (1000000 / dm->rate_in) + 1; + if (dm->downsample_passes) { + dm->downsample_passes = (int)log2(dm->downsample) + 1; + dm->downsample = 1 << dm->downsample_passes; + } + capture_freq = freq; + capture_rate = dm->downsample * dm->rate_in; + if (!d->offset_tuning) { + capture_freq = freq + capture_rate/4;} + capture_freq += cs->edge * dm->rate_in / 2; + dm->output_scale = (1<<15) / (128 * dm->downsample); + if (dm->output_scale < 1) { + dm->output_scale = 1;} + if (dm->mode_demod == &fm_demod) { + dm->output_scale = 1;} + d->freq = (uint32_t)capture_freq; + d->rate = (uint32_t)capture_rate; +} + + +void frequency_range(struct controller_state *s, char *arg) +{ + char *start, *stop, *step; + int i; + start = arg; + stop = strchr(start, ':') + 1; + stop[-1] = '\0'; + step = strchr(stop, ':') + 1; + step[-1] = '\0'; + for(i=(int)atofs(start); i<=(int)atofs(stop); i+=(int)atofs(step)) + { + s->freqs[s->freq_len] = (uint32_t)i; + s->freq_len++; + if (s->freq_len >= FREQUENCIES_LIMIT) { + break;} + } + stop[-1] = ':'; + step[-1] = ':'; +} + +void dongle_init(struct dongle_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->gain = AUTO_GAIN; // tenths of a dB + s->mute = 0; + s->direct_sampling = 0; + s->offset_tuning = 0; + s->demod_target = &demod; +} + +void demod_init(struct demod_state *s) +{ + s->rate_in = DEFAULT_SAMPLE_RATE; + s->rate_out = DEFAULT_SAMPLE_RATE; + s->squelch_level = 0; + s->conseq_squelch = DEFAULT_CONSEQ_SQUELCH; + s->terminate_on_squelch = 0; + s->squelch_hits = DEFAULT_CONSEQ_SQUELCH + 1; + s->downsample_passes = 0; + s->comp_fir_size = 0; + s->prev_index = 0; + s->post_downsample = 1; // once this works, default = 4 + s->custom_atan = 0; + s->deemph = 0; + s->rate_out2 = -1; // flag for disabled + s->mode_demod = &fm_demod; + s->pre_j = s->pre_r = s->now_r = s->now_j = 0; + s->prev_lpr_index = 0; + s->deemph_a = 0; + s->now_lpr = 0; + s->dc_block = 0; + s->dc_avg = 0; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); + s->output_target = &output; +} + +void demod_cleanup(struct demod_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void output_init(struct output_state *s) +{ + s->rate = DEFAULT_SAMPLE_RATE; + s->output_fn = NULL; + s->output_fn_data = NULL; + pthread_rwlock_init(&s->rw, NULL); + pthread_cond_init(&s->ready, NULL); + pthread_mutex_init(&s->ready_m, NULL); +} + +void output_cleanup(struct output_state *s) +{ + pthread_rwlock_destroy(&s->rw); + pthread_cond_destroy(&s->ready); + pthread_mutex_destroy(&s->ready_m); +} + +void controller_init(struct controller_state *s) +{ + s->freqs[0] = 100000000; + s->freq_len = 0; + s->edge = 0; + s->wb_mode = 0; + pthread_cond_init(&s->hop, NULL); + pthread_mutex_init(&s->hop_m, NULL); +} + +void controller_cleanup(struct controller_state *s) +{ + pthread_cond_destroy(&s->hop); + pthread_mutex_destroy(&s->hop_m); +} + +void sanity_checks(void) +{ + if (controller.freq_len == 0) { + fprintf(stderr, "Please specify a frequency.\n"); + exit(1); + } + + if (controller.freq_len >= FREQUENCIES_LIMIT) { + fprintf(stderr, "Too many channels, maximum %i.\n", FREQUENCIES_LIMIT); + exit(1); + } + + if (controller.freq_len > 1 && demod.squelch_level == 0) { + fprintf(stderr, "Please specify a squelch level. Required for scanning multiple frequencies.\n"); + exit(1); + } + +} + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data) +{ + int r = 0; + + dongle_init(&dongle); + demod_init(&demod); + output_init(&output); + controller_init(&controller); + + /* + * Simulate the effects of command line arguments: + * + * -W wbfm -s -r + */ + + /* Set initial frequency */ + controller.freqs[0] = freq; + controller.freq_len++; + + /* Set mode to wbfm */ + controller.wb_mode = 1; + demod.mode_demod = &fm_demod; + demod.rate_in = 170000; + demod.rate_out = 170000; + demod.rate_out2 = 32000; + demod.custom_atan = 1; + //demod.post_downsample = 4; + demod.deemph = 1; + controller.scan_squelch_count = DEFAULT_CONSEQ_SQUELCH; + controller.scan_squelch_level = DEFAULT_SQUELCH_LEVEL; + demod.squelch_level = 0; + + /* Adjust frequency for wb mode */ + controller.freqs[0] += 16000; + + /* Set sample rate */ + demod.rate_in = sample_rate; + demod.rate_out = sample_rate; + + /* Set resample rate */ + output.rate = (int) resample_rate; + demod.rate_out2 = (int) resample_rate; + + /* Set output function pointer */ + if(output_fn) { + output.output_fn = output_fn; + output.output_fn_data = output_fn_data; + } + + /* quadruple sample_rate to limit to Δθ to ±π/2 */ + demod.rate_in *= demod.post_downsample; + + if (!output.rate) { + output.rate = demod.rate_out; + } + + sanity_checks(); + + if (controller.freq_len > 1) { + demod.terminate_on_squelch = 0; + } + + ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH; + + dongle.dev_index = verbose_device_search("0"); + if (dongle.dev_index < 0) { + return -1; + } + + r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); + if (r < 0) { + fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dongle.dev_index); + return r; + } + + if (demod.deemph) { + demod.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(demod.rate_out * 75e-6))))); + } + + /* Set the tuner gain */ + if (dongle.gain == AUTO_GAIN) { + verbose_auto_gain(dongle.dev); + } else { + dongle.gain = nearest_gain(dongle.dev, dongle.gain); + verbose_gain_set(dongle.dev, dongle.gain); + } + + verbose_ppm_set(dongle.dev, dongle.ppm_error); + + //r = rtlsdr_set_testmode(dongle.dev, 1); + + return r; +} + +void rtl_fm_start(void) +{ + struct controller_state *s = &controller; + + /* + * A bunch of the following is pulled from the controller_thread_fn, + * which has been removed. + */ + + /* Reset endpoint before we start reading from it (mandatory) */ + verbose_reset_buffer(dongle.dev); + + /* set up primary channel */ + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.direct_sampling) { + verbose_direct_sampling(dongle.dev, 1);} + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev);} + + /* Set the frequency */ + verbose_set_frequency(dongle.dev, dongle.freq); + fprintf(stderr, "Oversampling input by: %ix.\n", demod.downsample); + fprintf(stderr, "Oversampling output by: %ix.\n", demod.post_downsample); + fprintf(stderr, "Buffer size: %0.2fms\n", + 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate); + + /* Set the sample rate */ + verbose_set_sample_rate(dongle.dev, dongle.rate); + fprintf(stderr, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample); + usleep(100000); + + rtl_fm_scan_stop(); + + do_exit = 0; + pthread_create(&output.thread, NULL, output_thread_fn, (void *)(&output)); + pthread_create(&demod.thread, NULL, demod_thread_fn, (void *)(&demod)); + pthread_create(&dongle.thread, NULL, dongle_thread_fn, (void *)(&dongle)); +} + +void rtl_fm_set_freq(uint32_t freq) +{ + struct controller_state *s = &controller; + + if(s->freqs[0] == freq) + return; + + s->freqs[0] = freq; + s->freq_len = 1; + + if (s->wb_mode) { + s->freqs[0] += 16000; + } + + optimal_settings(s->freqs[0], demod.rate_in); + if (dongle.offset_tuning) { + verbose_offset_tuning(dongle.dev); + } + rtlsdr_set_center_freq(dongle.dev, dongle.freq); + + // It does not look like refreshing the sample rate is desirable + // (e.g. the scanning code in the removed controller thread function + // did not do it), and behavior seemed a bit less robust with it + // present. However, I am leaving this here as a reminder to revisit + // via some more testing. + //rtlsdr_set_sample_rate(dongle.dev, dongle.rate); + + // This triggers a mute during the frequency change + dongle.mute = BUFFER_DUMP; + + if(s->freq_callback) + s->freq_callback(freq, s->freq_callback_data); +} + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data) +{ + struct controller_state *s = &controller; + + s->freq_callback = callback; + s->freq_callback_data = data; +} + +uint32_t rtl_fm_get_freq(void) +{ + struct controller_state *s = &controller; + uint32_t frequency = s->freqs[0]; + + if (s->wb_mode) + frequency -= 16000; + + return frequency; +} + +void rtl_fm_stop(void) +{ + rtl_fm_scan_stop(); + + rtlsdr_cancel_async(dongle.dev); + do_exit = 1; + pthread_join(dongle.thread, NULL); + safe_cond_signal(&demod.ready, &demod.ready_m); + pthread_join(demod.thread, NULL); + safe_cond_signal(&output.ready, &output.ready_m); + pthread_join(output.thread, NULL); +} + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + uint32_t frequency = rtl_fm_get_freq(); + + if(s->scanning && s->scan_direction == direction) + return; + + s->scanning = 1; + s->scan_direction = direction; + s->scan_callback = callback; + s->scan_callback_data = data; + s->scan_step = step; + s->scan_min = min; + s->scan_max = max; + + /* Start scan by stepping in the desired direction */ + if(!direction) { + frequency += s->scan_step; + if(frequency > s->scan_max) + frequency = s->scan_min; + } else { + frequency -= s->scan_step; + if(frequency < s->scan_min) + frequency = s->scan_max; + } + + rtl_fm_set_freq(frequency); + + dm->conseq_squelch = s->scan_squelch_count; + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = s->scan_squelch_level; +} + +void rtl_fm_scan_stop(void) +{ + struct controller_state *s = &controller; + struct demod_state *dm = &demod; + + s->scanning = 0; + + dm->squelch_hits = s->scan_squelch_count + 1; + dm->squelch_level = 0; +} + +void rtl_fm_scan_set_squelch_level(int level) +{ + struct controller_state *s = &controller; + + s->scan_squelch_level = level; +} + +void rtl_fm_scan_set_squelch_limit(int count) +{ + struct controller_state *s = &controller; + + s->scan_squelch_count = count; +} + +void rtl_fm_cleanup(void) +{ + //dongle_cleanup(&dongle); + demod_cleanup(&demod); + output_cleanup(&output); + controller_cleanup(&controller); + + rtlsdr_close(dongle.dev); +} + +// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab diff --git a/sample/radio_qml/binding/rtl_fm.h b/sample/radio_qml/binding/rtl_fm.h new file mode 100644 index 0000000..f5b2a86 --- /dev/null +++ b/sample/radio_qml/binding/rtl_fm.h @@ -0,0 +1,70 @@ +/* + * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver + * Copyright (C) 2016, 2017 Konsulko Group + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef RTL_FM_H +#define RTL_FM_H + +#include + +#define RTL_FM_DEFAULT_BUF_LENGTH (1 * 16384) +#define RTL_FM_MAXIMUM_OVERSAMPLE 16 +#define RTL_FM_MAXIMUM_BUF_LENGTH (RTL_FM_MAXIMUM_OVERSAMPLE * RTL_FM_DEFAULT_BUF_LENGTH) + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*rtl_fm_output_fn_t)(int16_t *result, int result_len, void *data); + +int rtl_fm_init(uint32_t freq, + uint32_t sample_rate, + uint32_t resample_rate, + rtl_fm_output_fn_t output_fn, + void *output_fn_data); + +void rtl_fm_start(void); + +void rtl_fm_set_freq(uint32_t freq); + +void rtl_fm_set_freq_callback(void (*callback)(uint32_t, void *), + void *data); + +uint32_t rtl_fm_get_freq(void); + +void rtl_fm_stop(void); + +void rtl_fm_scan_start(int direction, + void (*callback)(uint32_t, void *), + void *data, + uint32_t step, + uint32_t min, + uint32_t max); + +void rtl_fm_scan_stop(void); + +void rtl_fm_scan_set_squelch_level(int level); + +void rtl_fm_scan_set_squelch_limit(int count); + +void rtl_fm_cleanup(void); + +#ifdef __cplusplus +} +#endif + +#endif /* RTL_FM_H */ diff --git a/sample/radio_qml/package/.config.xml.swp b/sample/radio_qml/package/.config.xml.swp new file mode 100644 index 0000000000000000000000000000000000000000..a158e216d21e627114d23d6747611cea3ed51d17 GIT binary patch literal 12288 zcmeI2OK;RL5XW6^AeBdZN5+Wb#=9*NRmg5t4j`mf;?W}YguIEHwVK$$b~fDu4+(Kc zd=|b4N5luBA1rG4zrzZ@6|-JR)yqN zWXimCGBr9AcEKx=9)b^t`GLx#qq4YsYqUTDNPsMp^|jG3fVj`@(bbhbWP${c01`j~ zNB{{S0VIF~kiZop;HxF_5zc$9Kl4i8FP-cADRxKz2_OL^fCP{L5 zda+H{qG19_bq@kfQTv&(lb1f>{V+Vuq)V-;JP@4h&Xl9@6Eu^hp|3)PITcj}QA99E z_*v`V4aMdj%HgTA>6pR6yQ*|X{h|WyXI%MQXOYN@NJFH#WZm%;_;iGnC + + Radio + + + This is a demo Radio application + Qt + APL 2.0 + + + + + + + + + + diff --git a/sample/radio_qml/package/icon.svg b/sample/radio_qml/package/icon.svg new file mode 100644 index 0000000..b49b495 --- /dev/null +++ b/sample/radio_qml/package/icon.svg @@ -0,0 +1,14329 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + HVAC + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + NAVIGATION + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + PHONE + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + RADIO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + MULTIMEDIA + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONNECTIVITY + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + DASHBOARD + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + SETTINGS + + + + + + + + + + + + + + + + + + + + + + + + + eJzsveluHcmVLvoE8Q77/mjAddDazIiMHMK30cCe2KcOPMFl93HfxoFAS6wqHkuiWqLsdj/9/b4V +Q8aQm6RKNchuMsApdw6RMazxW2v9w//zm6+e7V7e/vH6Wb/tNuof/uHw7vrq7vbdzzdydPPlq1cf +3t+946Gf/faLjZ62HU7afTk/Dyf+6/W79ze3b36+MXrbyYeXvPpnu9dXb15ebQ63316/+WLzsy/w +we9u7l5d46P/+csvn+/evv3F1Yc3L769fvf8t1cvb26ff/nm6sXdzZ+vt+///M0XsSO48/HqDheZ +To/PtH5m7Gb4eT9tfvNLnnL15s9X79/f/BdO0GM/9zi2v/3w5uXNm2/2t/+JqzbPTO/QtX5jLD78 +nze/vX5fnrHth24Yp27AD9wc589bN099Z8d5GnCp2Y7W2d44yx8b08vHxg3a9b2dcNfj7YsPr6/f +3P3m3e2L6/fvD7evbt+9//nm8NerN5tfXn2DT642/3b96tXtXzb7V1cv/pRdcnn75g6n/vb2j7d3 +t89+e/3Nh1dX77LPf3V9/fL65Zmzdl8Ozy9vXl1jwF9f3W10z+HffanN8/2Hm1cvf/Xh9R+vMRXG +9DzcP5eO/f49eoTO8W8enp5/+RpHvrq+u8OY4Cmcwt/+yz5/GRyU9rN/x7NvZDlgYv7PF+G2727f +vr569ydc+2ww2wFjOE745X/yiD/vd9ev377CZMq4644fPvO/8n/CuXgtOe+Znjt+Zscev3o38MZT +F89bhv76zzfXf/n55le3b679yOze3X3lV4a1Xed/+k9+++HV9bvfv7nhmBoecn5ofnn78voVzk/X +X766khGRppef/oTfXb375voOC+r21Yc72QJzfAKG/hdXf73mKtCjzMn0fI+he4MHvblDf5/ffP38 +z37nPP/m7ud68k91z3/99vrN727/Vd7lmZ70dnbD2A1Gu8lurLXbedZuGFxnTDduuu04jrjWmnkz +W/wxSyfHje1Tr/XyM/Rk9+ru+t0bzETszY/36NObl88Dxbh+mT9+kMfz4XHgxvA1hd9Ylr/BQv31 +uxuM48+faeew3Lrer+F/eXfzclnCk9nM/odM1xbzwi+tnekc9vAjjzj5mkY9zHjNxxzxA4llc4f3 +CisJ2/Hwy2x7ddtffoV3wUgcbl9z7b4n1eLiwJZ7dfuN/yz9LZ/g8g9v1b+r3l38x4fbu+v3uNer +640bL755d/Xn640288Xu5c31O3zy/mL3Dh9fHF5cv7x59erq4nT14sPd9cWv7kATri9+HU9TF79P +V1z5U67kbhdXL27eYVt9/er6Py+ulnP89Vdy8xfx5tdypbq49pdeZ5dep0tv/O1v/Dk32Tk36Zw3 +cnt1cevPvfXn3mbn3qZzb31XPvhTP/hTPyynqosP6dyXV998c/3u4iU6eH198QLjffEey/8V3+L9 +9Qtu3Is/fnj16vru4u3VO47A228vcAXZ1x9fYZTeCcnD3V5evLh9+1csv2/vLkACX16T6F34PqTH +bd/c3r28/vpid7r49ftXV++/VenQW3DS1zdvPiwnxd9/vX5z8fpDfVg158Xft+9efn2NW928uebf +r6/ev/jwiv/EE65wPDz9Pz5cv+dLvrz9y5uL6/988erqtfyJ1XXz4uoVLkhXfQ0aePOm7cY34Cav +rl/fgnt/fbf850cCfO3mLd/8/durF9cXOz8Zu7DYwq/TxS3XCASC999eXL+WX7KQMcRy0/iPv6f8 +txz3B1/e/PmGCyQNWhrzf0t/ff3uys/o6cO7W+mp7JTUb/lPbqcuvr7BC4flgSdfvMVzbl9ygchc +L/vsj1fvr1MH5R+cevft7Yf3WCLqYpct0VP2986vjFPq3MkPzZf++Jf5cv0ynfSlP+nX/qRfZ/eL +7/1rf8bv/Rm/z2/ze//RS84UxKKL7Go/Ea+vXrzjege3lNOuXsiG8Fva72h18e2HN99cvfvw+tXV +hzvsQ1DqP128uMJ16ncnIdXD/3r+u/dguwu37T13O715cUvJ6ueb56WsUosu/35RnXBRne85yO/+ +P39z0MN4683v3n24/t1f316rf9ejDtsaYml/geG5/o8PV6/wz3hx8+ZrbI+7v2abjkMiJ4BmQrLE +ePMfpWfNvYe9f3dz9erlzddfX+DdXouEc/H23e3LDy9AGW5wxzvSONx+dhe/fn39zdVGgR1egBBw +H23AJS+u3uKC/wy9cPPF8foVRD+jbVi82HT/df3mm2sIox1PfoXl/Pyrv77+4+2r5xf+d/HmQxAa +MMy/wRyRg6hfvVUifv/m1Qd89C/vbj+8/fLN17fqZ15e/wXIwMZ/tpEPIXvLMbzfX27f/Qn/fvny ++moRG7dXN2+/uPeWX/3p+u7Ft/VNw9Hvftt/BfEFvfmv65ebX//x/+If3oOiKKYYHOjNN/g/nfPw +7Y7XX+PBoZe41B89vfnz9avbt9fLcX/ew/f7zaurN1iI8XXj6ILZ/uYKU7HckCde3/3h4TtCLHiX +dUT+jb8f0R8IRW+vRUOqp+LBE7KPHvGgq7tvoaeAWL9P9/b/Ln3nOPhjD9/vcAUOIWz15sVm/+7D ++283v7u9fZXuvfJ5ek7+mXzEKx+xYl9QAHu39rTyo/SgcPgze8Zv5II3v37j56R9UjihfhJUF3/N +Z/qsdM3ac/Dh38ozPMm+ef96mfrsyG/IUl68uv7qrxAfH0NxwgBDYgDRO7PJ7z3nq79cgSb/4uaP +925LviS440us0K8+3NxdLzvx9vVb2kY2X3179fZa3iCe+VW64SA6XMaRnj1TZrN/k/GrfyFPhFzx +883PfnX9l038d+O7t6EUvTFfqPs+BAvETV9C5fknNfehmaLprJX/6bnzbbqUdkI7pnZQ0wFtX7RD +avtpl5qTNqcWv8ayKfxYDg7SbNZ6NBOaTq3zbbys2mk8Kf4Yj9IOaPtxr/5ZdRiLgz2Yg95f7k/7 +w363d/sZvR/2dt/vzb7bXe5Ou8Nuv9vtZvR/3Nldv9Pu0h3dwe2gp85udIOzrnd6vpxP80HN+3k3 +z3i5cbYyjJ0MFkdhlpdi97V06yg9ceMMZXwY+9GMeuyG03AcDsN+cMOM9x7VMAz9YAZtL+0J7WD3 +dmdnDMNoB9tbSD79ZX/qj/2h3/UO0zr2tu9703fm0pzMwezNzjgM1WgGY41RRptOX+qTxntrvI2e +w1jgkb7tirYv2qFox6KdyqaGy7yNXdF00UzR+qLZ2JT8GopWf5UraS6aKxqmU/FHaHvfMBb/pC4f +/jp9TFMrB4+f0hR+HD6x7fOmyn/lEEdiusS+Jz3osZwHDOKExe2wxPfzYT5ixV+6zmlnsAMsls6I +/U0Tzs7tsUOO7uQud91O7wz2jcViGhW20bxz2FB7bKwjttflvttrbLYem27ABEzYgg5bcY8NecS2 +vDx0B41N2mOrDti802E+uMPusD8cDsfDSR0uj91RH82xP1oswhEkaT664+64Px6Ox+PpeHnqTvpk +Tj22zwA6MJ3mkzvtTvvT4XQ8nU6Xl92lvjSX/aXlKlWgcHirS3QMg4SrLy8xEnbzD8/30LNUt7Wm +wwp10yDjIVa6beeMBQ0YsOu6fvDHrHZjN82216BWw4AjLv5jXYcPNxo0WW/GzdBtdNfxCV+pf3j+ +Az5h/x79Bylx0zjOnSFF8nfiXumGbhyNc3iMHOv9PeIDaPrbWjd3vTN6wG4ytObHu2e9/4Huj77v +j4lhRja3ziV//+bN1WvoQd9EZjgNYI9rRwu+qIUP+pXu17pvc1jzXPV7Wfl+7WP1x4Zd0MlOiA07 +QmFT+GZTG1aaLX7b4rfNf6vsRo9p8fEmtaV/0luV/bPSltdr2qn6LzS1/Fm0Y9MOK23fHlNy+GPb +7nxTxb/uTLv/a8qbKv/9xIZ1r+bx+21/wzcUHtRptO/xS32fN3u64dMN//vd0EvJJ4hIDiqWhTZx +giy1h1w1Q76ykLY6SKl7SGETJDIL6UxD5DxBZNtDdJshxI0Q53qIdV3QvfZ7pyD3DUH50kH5OkJK +dEH5GiBCGihfpzX1S7gVGc2ifw0KnLwXFewSKtgpKKNRDaNOSf3Ra4xeGaMi4BUyqmRWlBGvoHRe +ozmK2rMXxch5zXTgl4WSRjXNDBBzRFWL6hoVNqps5MjoT1JmBqpvChocdThjNVoHXe4kulxsB2kY +D+h2bF5xpwJMzWjq5am93KSXLwXFzzfNBhXwUtTAsh1D24e2k7b8tROVUZoS3TG2XEsbsmards+X +Cr9126CVnm+n1YZPVHbS8ZPawTcV//i+2o93w6DJyyZwcRvILjBhH9AY4feBCzthEJOEt6R0mWEi +7gXI8kpUbRtsFNwMl2KnOGZ7YZa9MBa7QafdcLKgAsteUGEzTGkr2HIn9Jdi1TilXRD3gBMbx7IH +wg5QYQOkld93YgCJq9+v94OYQ5Z17te4t3/lCxxdV2lVxx1VLtuObWVxVmtJ72NTepfaIofnVrbM +llUaR/RQNOubin/ovmmru+vMVxebWv5cWnf5yHZqm1o7+EA73tfU/R9/fPvxbigcU4xmoxgxpqDg +ODFm0JyxF5PGQcwaR/BKtkuxbnRi4dBi5TBi6aCtA00Fy5s3bUaLrNewnLSdtH1ocudj/DpJCyYl +P/pKbCW+RW7Rp2ZDW0x8Y2hTaovS59iU/3XaZW2ftUPWjkUrv5LZTPHHyvprOYZZaX3blBh+zrXh +3tbYmtlUc2j66FZo1+q8Gv4dGgQoxR/fZ/sbvqHsS6wADVJvwYcmcKYdGNURc9+BD/RgZyOYmxPb +90nM2DRQD2JrdmI4PmILXIJqGzClgb4LBda6Ey/IsTCglubTjzCeKm89DcbT2nyaG1AXE2o0ogYz +ajCkelNqr8SaOiRS5IJNdZ+Rn8tgWtUF0RkSrYlURiiMSgQmkpZEVDJqslCRhX7kdCMjFqqiESVV +CNSg2f5rWz3sZVVs53P7c2W7ZG2XNxX+aCznYjk+3+616id6/EktfD3GkfFRXz/eDUubO/UqSEVQ +LCBo9pPYj3UH6VTP1k4a0p71VvKhyyzIPS3i02inbphnA4HUWbGId96mPJotdKjO2R5XQcjKTNg/ +yuO8Nb4bIJhb3NjpfrS8acc/LSVnEAWCYh1OnyGOQq5zk6CBtxCZ80fTxJ6s/mJRxxGT90SbYEzX +4xYawQTRHCInhOnCdP8ZdOZBO3+N3jL6rLf88kogbl/96a9fqPyfxeqPrrp51NA4oK3owU040rsB +OhEUH7wEFCNoVGhbyNk6m1xxpBSTzXuVs5+v4Ooxm+YxHqhWP2bTPGbTPGZZYoUX6Ud7oqzjH/Zp +rZfpR3rex3idfv3u6s031/8YQlOw4qoDuN0QfU3dkLXoE4//0xA0rLRx9dhI0IPiHyLLNG7T6DRN +LtOgT5jCX1p7S5O/VJE5y53Flre0ISkf/Gmb1hfNZJ/466C9UIURC/8PYbeUOxcqxQ== + + + YaXtV9pupblMn5E7e8tIZhaJRhFvEgnwDTGGiCFEzCDHgN9wCcFhxeqBhaxo8PDS6GG17R/ZdnVT +8iPxUwy37cQ8IgvNhv9s0ZaFWP5t1xap9DqItw6i7TEItlGspVAbRFoItEQCeEnWS7FehvXyq5dd +RW6NSy5fdFHDHZtji7bL35RM45n+7/D/D7PaxBgepc1c3SwV0txYUspr+VdYrHLTZNQ+PGDRW7fn +ldY8iC9B2Sna6Ww7nm3FwixWlreL9c26WvvL/xePLc3fQf5S6U+/XJeT5HL/PlM/Q3TYo18nHNPY +UF6Rm7HR9thyJ8j9WlQ5i+1IVAVBTUfoAFpUOVuocpdq6jB2PUZxxIg6jGyuxvlnBvhMlOVL6f5U +HaOTZIKa4dUO/uz9akhOk0kFPWgEzeXYa9zhGMw1O1m2NOuuPG3ROBbFJFdYFkUmV3IyS8WiEeVm +D28ZEZMVXTVDcNbo4K45isMmwuXGBJhbvDaEzOV+mx5arN517lIF980+OHCm5MIhOsHvpe4ADnWC +UtdprY3uwcNp9xwhks/a6Z3eQ4890vqPpaKNMb2xZhDL7WRm48SXcYDSeoIa2PWaTpG+h9wtPhO/ +XHZYMAcumf6yWMAB+UCwYwQUhpb/Pa7y4qEgjn6FVnS1prM5BT7XTN5U+e+5VhM6mnJ7odh8Eb6e +63bdXmyLJ3xowjhbGeUJo7yXUeY4X8o4d951Q0v4EAabRnMnwx3dR95A6ZV9r4XHt4hmdJu1QQXz +fWzTevOsYMZOOGB3adkhEcm1YLkWE0E0DeQmgT4z52VmuilT/+fwPQXFf15T+s/r/DWE7oz6H/fy ++a/vpPK3EMNPAhiWxoj7TgvMj8yuC6zsKHLVTrzBs1C1QWw+PZYFbUGdXHkSS9FB7EaecUe2PapM +qPTCoxE7lCxXGUUvvXkK6b/2oe1Cc1mbVQUrmtab5yf7AKSdxL3kwbTiURJf0jH4kHbiOZoCsHYQ +R5F3EEXHkHcGibNun9w+0dGzOHYWD07up6ndL5mHpPYxHNZbaUHpoLHPBBBSzaGK7rrJmamD7DoP +1PTnXk9DD2qsHZ3Yovt32LliEegnUetdhi3sCO3bmgJvSAifMVNmDpjOQBw/j+6I5trp2UEn7Cyu +Gw1tFSA50zyjc2MPzsNnz5iinmICaNQ4O9+b0XYUeDWuFsMIDRuLbkk04wLORId4JJg/wllu6c08 +b3EsG5/PqFNhlDBbI0bTQeexU9CjwTjAl8GEaQlCh6zBjHEfdHbwKE83FD3gdYWyrc/ahmgyG7cz +FkE+LD9hL/w4dBAVOzy7wzRYrlSjIUD2WL/zDPFSCwp3HJ3t3ITFilXne5BQrbIcOaE51NXKCj/X +AzNvOyhR2Tj8lL3w49CPzBDCIH3dzX6UZzuK1tsNk5t767M7rIy9yTdpN4cnmDm37/xA9/8Ye85X +H94ypOf26zufZmTzrzffvLm+u7v+Qt3zGZ7VJ9sidAb0Qxuo+sxm0G0xaz1fq3eT0VDIcMRy5Wpm +SIF+ohVJ36ihTKPvWNzOcrBzGjbS0lhNEo/kBledbI+fRSdWxmLTdGPTdGPTdGPTdGNlwTbdiObK +ERcbtxmmLc0umS3xs+uaN6n+tN3a4gYGFGHc9Ho7j12/mdx2mvTnM3Dne/hZjJ8b1qzyn1GnPimk +Qq9FVGgauW00covtYBQ/sw0WBBNwUV2wJJwya4JvTtocLAvetmC9fUEJkKoTI4M3MxwlOm8v5oad +eMZnMTpMYngYJYDNSuvFBCFGCJohxApxVEFB2Is5Yudzz4hRYpIYMYnLEKUAV3a4xsNO+YGHnJ7E +LpeC/QRnusfVk1jhaIE7hSA/2oqJJw0Bfgo9m4dRkHI6mIZ3gg5lUJ8WIChNvktAnw7hfF7voM7R +SyQf4/h2elbQKQbRIbRoCwe+plgxBjEvmGSpfNCeSbC9kZ/UQIx8G7EfmGR66xdbhpIn0B4yi4WE +xoWdmBf8T//XPv3cp58HMUDEn0mdUeW/3kYRfp74clSLghpt90U73NNWXBSpJWiTWv5M7T540H1W +INHu1KBXWwGf9Q6FUQIWvR3yEEAlXYCVWA8sCQZJjyw53R+cp1YAJvfG5j0UmqceE5vnfVCd7FQj +1y64FG/dj9iUBZ1yFDJwKVqrR6j4WyaIigpwuRylEnEqESKnQxDgOkolouA8QOWkMnyKzpApOSZl +zu2C3owQLARiFMJGLLZT+080QfvZnXziLa5bkvws8q1fHiPWDdoyvI8J8zH6iOMYCBP2Z7WR/eOg +/IJ6QAz2D0woJX8rmVBOaYWsmA3JBnFOfdd5Obsj+zHkLiN2vI/g61vFoQw1pAqfR+/Ni+Lg5i3Y +z5jhDH7Eh3pRYIYqiH+HAefKnUBUu3kee3rgRquDt7jUlsln7aaZrkwzNFCwC4Hoh31O8LR3hKLw +F3iFSBCmn8ehGyeHu8kRrImpx3roSZUn7Y/ouYcqRSO5Fi2ptgPYQhPU93ZIb8nlcnf859MpGSVa +2TqC0EEUB3nYOExkpPMEQXEa5elmwMTg5py2OZiYaJMSgxxNB1uzSFSYL6rHfbMEx7LPa2iFz6I3 +nybudavyXlcIfAHUvhMrp//Lhb9bkHsJeJ8Sa4yWUasHVSLeV+DuJnyfh70X4HdVY94XC+sK3L1E +pkfD6j7IMtJUEHNcOlSF0BbNO5TmxpU0JnjHqFZ8ScMZZ1F0tvrv4qUWt4/qVoMnPSOT0F8J5j2m +wNk5eJlHiYLuY26QLO/HPqXxmETS7SWSCjtYyYudQjjVQSQZJ4GcgfsJWKJPAVWXKYZkiSKZJa9D +iCJRIahKi7h1CggKH0YSI0hiDIkNMSQ+jsq7tsvIEbyMCoEj9Db1i2U/2PZPKSpqlyJDpmDdH5J9 +Xwf7Pj2QIRRnHyz8c1rXY1qusvjSevLmei8JL57GuASCxzBOrg7SeAIZ0EtrQrTdIXhY6F3pQ8Td +KXhUvD9lEjcKXSgaj/XRdy6PvlMh9ckxeXPHIv7uWCQ/GZIX92wEng/XXnAKAaUQkqAcAkphDAiF +LiAUPD5hTjpSTINyHPYqQWl8VFEJpSGQZsoCiPJkKN6LM0mQXPDh0A+oggNncd9E14133Jwkdmcf +5tLTIU9aMIlpBvdhq+PFlEydDUqWKeYr7NC1uJr19sDX33DE6Od+Q+9jLoJhMvS6bqJiysiYPDom +w7erKkymDpaZqjwJLmu7tZgZ9VFhMyUkfDVaRjWhMiU86Hw0zJkQF9Vg6M/i5+/xl1d+6DVo+z/7 +TFa2yNbhM3W4kKmjyNMRsnOYoA37JBtjCLrwaYd3SixBh6Aen6THnYTsGVGTvaI8iGlpElNTDMbY +i9P5KJN1uQRlqHs14H2hAV8mDdjrv33Sf7MgDRWCxdb033NRGilGIwvPSMqvCrlx+rBqk/abFuGC +rTiFbDldWDR9QlXEJTD7SJs4uYcUyuDna4HkFIicCo8jIC4TYFyjaNFOoFyHAObqIpxLSXDOJOE5 +OwnQOYYQnYjsGj7OqqIeNqt8XM4j9RjDysfkPFJ+0o/fW84jJdN3T86jf1KCsUpBr1ng6ymEvh5F +FvJhrzH4dZ+EIoyVtwqtCxmnYMN1GKYHRIyYdmABuESKkMNe9gkFx33v6VOEuMlvz5tbDNcaGMvU +AKwKY1UGZFbRmGUc5r4IkUpBUou15r7l+qAJ0G+wmM0vy/mTxfTvUsS/b4eshdjSfN4DIiwqZV5p +i4qdb/sMJ3YI6+CUEGOd4PPQPLWOeyfuHO6bXcIFayGwQ4YM9lsl3yhhm/h1MGXsZc5mfDm+y1b0 +qUJYZVirJcvMemvnvkChVmh9D8NPkKdeRAWBPSXgUwt9ysBPNfbJj91jIvnP4n5zpLpfJ/kq2J1p +7kwrskYW1sSsUEEW+FSb/+4/y6MLnDPToJ3VHXHlgteY5r53Y9cNYy94IMZQUf/sO5w2TWIwIRSk +A9MwA4EK3XZuvGRDgxnSbWzL1gYAjNlyw2WohM+rXzJWUF+JhrCmG2ctQKGeC6QDzSBREdTH0JkB +2xjcspcjHej5PGJTgwWPgqOZCxTQuGpayo2xXe/uMQd+Rn3y62kaGLeHPjgGB3G8JZMeLsTdsMdl +3kA29QiGM4/QB71JzhJe06OrrhNsUZWfjqGCNcBKFx1atwd+Jv35NIugXbUIWiJgkkUwaFc6BAUM +CYDsAgA5uvcWsHcfQMhzxl4S2FsVeO8p8LqI917Ey0XAXEDfUcyMgqaImkqMNF7a9PIm2yzpenbB +b5icgMFvx0ACK6LnKElPRAEJmVIPKiVGPYmF6zJkO415TWMK05isdA7sPuYgPQjbPwZl8dLHI3TB +SGpEbO1FGrAhM65Pdeq/fBY5l7WdyApLQl5wGCVGvEUJzaOfK4NllQYY7ZwLueaY0V1cuIqDLTMZ +O2P8mgrw+jl9z8mC2rqRvev4EH5G7/Bl8A5finc4dEQLtF3LyjLBQEx7zhAEGxtszWMScBYxZwpv +LKhdFSTZfSX1xN+HkPYly0sUZSD81rksJCtY0vDqlFcmZplZciktzuE831KehylnwyFR05rMd04S +LNr5WY3fOsECarlIZ5JylIrkWyVxOp/85ffQ2czEvYQzLgtjDOTC/zWpZC6fU2zGslZdWDRzZnx3 +K39ni0sVK81l62z5ndv34xkus/QX1v/cHbDvSpfArmgunbWvPtmFo/vlhudO2J+5PPYmhRqcJGxo +L0LyHIKR7D2o/YjZzxH7ybasAlh/MS/3gs/vAi7/GNK87ZKxeYkgijFEMYpIkD8qQH4WwE8fwon0 +CtYn4nymYJQeAr4nQ/eoCPCp0D1zhe2JSVJjatSY8zSmLI1pSfcqyxa6ZACNPpJBrFC2yKqe5U1P +5DUS3ESD8yzpS9tVzZUt2FKC8hIDwvZhdl0K9opqr01hiSEIMYUcxphYiXlVIcjVh2xMwn6GTItZ +12OiJrPoMkmbUVmw5lCoNEtAh04BHW1IRx7O4bztKw/eGBO2LOLLbAhIjCptQpoFtNllWHcRdXZU +opHHyJH4taugaBGOFls+V2PWwPxVkSvdrrYzUbvLrF5elhE8dahfGeZXh/eNhcFjUGVIXxaf2sSl +rkSjtoHTe7USJb0YrRdT9iJf5KbvPD18sJSrbIUt6yy20vheZgqrQ5FCZ1Uyhrdfh5W2P9N2sanl +z6K5h1tpRyuMirOESq8ZFCNQKwVNB5NitEBH67NTwfCc5wHqk61kLLIA0fTXNWbFmPonJP7JjYsL +mmpI1uS5siSH7GHBMdIXZmQPoQqpA4LlyduZfFigERmdUjr9c6NE/zHmyomzNkrpSU4Pkb1BTFci +pU9BSvdhvkFOl6SDRuIJKaUvEvouCOaX6F0Xsjj1QRSfGc7v5W++6qVIFyYJ2ZNQXu74I8l4SBRu +Q8j7JGxhLxzjUvhIz+TfwcyYgx+95Lqwd//zkH4eKkgkpVuvIkVJ96AyUOTyM/7lLw== + + + WB60Kx60S51xCx6zlDByycYFF2f83/81JVTDFCR1L7sn2U2FhADfh7Ou8ND9LdzQF014RCj+o5NH +9INRj8kfEfAO68GLeejijrrCnAqCBNd3iFdMNUEy57d3fV9mrm8XQAsRWqzjm4vYtia4HQqI9j2i +Wym5qUZwW8Q2L7QtIlsU2PZBVoty2pgkNMhmKgESLoMJ9Rikr10wpM6hIs0QZq8PZWZiaZlTqCKz +9ylS1eidG8mGO2diTy74rIo+Z4Wfg2rlnzPiTyv6ZILPIvQoL/MkgScXdnIhZxFrcimmDyJ5nF3M +r8qhpP+kgofJNSnbjtEXnXkOc99h6U5OAdmlfd9lTuP8O7qO62jseGYUlXZ0TK7Kxx4INYg7Ygpc +l4vu6DmvkMXo/R3EPTHJGuYXVzXXN9Y517sEJ3B8eiVcOHp9BxlSDq1LPDkioHcyFfw+yvdBsmGf +ZM4uybP9t+JUhu94EH97QjsEQjx3PqQ/4tli6oRoS+PmPoJTd2J58CY02g44qzScBaOZEn4c3bIH +by1LTtnaJUt23wWW6xlu45FV6y7ZdS5xv/Nlcbvk6Y9iNgNGPVfJI+IYjKKQ+VFYEkdYsanMIp4c +IcF4z7QNwghf/qhE+vDJIfnWklFkKBDYbVfP+YfyXBJTmrXMHlFq91F5ibEQUfTNAIvymjqZuExC +Q6YcwSWuUuxb3uXoKmzeGLI8e4xeTH3eCW+6FJn9mPKfR7yeR+xNvlJVhO0tydB1SgGdJ4GOaaCX +pOhTBuNKmaBVSopeJIMOEQbCXE4JohYjf6p0IyI835NvJObXUQ+m2DmXNPsMZ1frrP0+dxnN8n2/ +JSwx8xXce1JIITjajtPPiFnJ2qfHwWBWDINnjQSZMUJn6CB1W0yoB9zbxgc15cBqicqfqwSHSyyw +22Kh5SkTf8JOyCg4ZoMbO8cZNk5cITM6YrANHemZBM1p592X2hAmvYZAZ5+KjHH9eci53joIV5vR +bvE+mffrp++KH5FRvEfYTB0oLp1M09DPzO0yTZwCJw/oLKmxNSMTDtDFppldgbWaMH0et189ss0Y +gKuqIOyyW0UE5OfVrU9zgY2rLrCRoPi+cIEZYQJTZNHCnK0wpZ13bzG/DnbJKCl19sGTRXY8Ztmt +SA+typJbeeZrAuP1TPeQpbYag3PpkMGechTJATp9t9glxsIuEa0SNsGccpDTqQkeo1wkBgnVgJxq +i8ROZJ0l7ivHvNkiQ7rAntTZiK+IelvSCrbom12Dvkk2ohLv2eY8X8t2vgreVAV20zUpBQ/3QDbX +8p2f1BqGczXz+blW5UNXj0yR/lArEqd/r+3v8IaLlJgn4JrF/uKTb12K6NaLhEbP404IgpdRtTBO +ClJzkNMPAmEX2bIX/3b0ay/WsssKOunJxGWRA29MWfBEg2RZm1OS0Icit/k+0A4tBrFeBJ8x+Jh3 +ooqKAznVzhMsrhIpKlrFDgJt7kJKyD4Bb+dk5dwX2lapb4nGpULBNq90HSRrJGS/ICd7hdSrqF5p +9db5aL2P9vxo6Q/a8Cmpj7Fah0lJDfPI4TG1PFmUK9pOpcRTS4Bq/lUanVN1h9X84ELYVG4lyKrU +mEe3KsZZ3RcA/WAb2qbWDn5K+zu84ZqOG6N4TaXdRtf5WjbWxVuOn22MWJ4heOxKfMWUHcm10MzN +rrKPc5+8rf6q0xCXN/Z9lTdRSR8ukQNd9d/67+XKLv5VhtIYn84A47SEzZjsb12M9nr8W6G7t+aH ++0wSqy0HkK7BhcvTVzI7NvDiVcTpx7R7b+jbejbKR2aoVN+pV/e0v8MbLhiMY0gEK+lfIcuF1K8S +vRfzve4gso4+Yg+cgKZgXy1vCLXyYqjerEKZcrPXCULvLeve/OGNH97wEc0eudGjTils1YPmjtrg +kZs8ojsjOjTMqFWyG5EORpuRyyqFjYWx6EFTkcpsRXndsMxiFKqH6bBiKYGVyYzzTNo+L3YoKRbL +isXSYrG82FJibCm0l4rtpYpjoamqDFexEhpJui7Klxfmi2D8rG7Z+bZ/ZCPO6zwE7KNagpSpFXz4 +J7W/wxtGYIePTJmlYGYkAT6IdxI4hA/h9WTAhcKZMXTXkwK6gEZPDJQAqTyIKiZiztMwl5ZR2kVL +q2hpEwV5UJVZNE88vtCJaBntMz/aKRCMQ+lFU4JLrd1oOrnRIg1JrrTCID0VBmkxSauAhAxW6UBf +LoN2fgx0JtqnvYV6l8psB6RWqNkp9EelUPNot47kqE8W7NiWzD15wFAZH9lkD6ql6LW0RGdgQj5r +lbK71fb4IuBz2VR94KPa1Da1dvBT2t/hDRe8Xo7CrHGYEYkZMXll/uSIxjQRgKcCxOmQBfzPAZUZ +I4gWf3OeN/kYEJr75FoWt7JqvMr9Ssq2CKFbXMlnHcnqjC+59CZHf7JOcNbotl0QZsGEpxYVewHp +7fIvl7W80HuJqBxjU+GPoWpre66tqxFTymVNZf/oB9t55G5qqgDnfA+V8NTKwdOnNPVpl/+3uOHi +9etC09KyPFxuYLKrmYEd88j0V8z5CG48jR2+Q85HrUcJWzZ6dNqXINNjns95LYPSmPvThmHjY4JW +UlP+dF3Yv1c+M9a40f3GJrdieTCetZ2mKqCqPvxpTp151akzP8U1PcU1PcU1PcU1PcU1PcU1PcU1 +PcU1PcU1PcU1PcU1PcU1PcU1PcU1fcrX38QNn+KanuKa/hvHNbmQgjOvMnkKKMs8pimvMLkUksxz +XR6UiD4JeXpPHchHft1XSvI73pA93K05KLw0tR4yJRA+We5c9jYw9FlgwS4kyDylQCktWD0boqOm +vVNFQFSABsc4J5n8PpQzzwHCO2H0s7D6/PtA0LDH3Xmk3UmYvyzM8Jf/7kUg8EJB/K88ZoLQQERe +WNWlMH+Qb8KUUzRWrIKyF74lBpxUypbNIz33EfotphSTGf84hAcvKaqAAx8ECb5gPZdEmTne00mE +UojLylNlSuVjictSC/AzJMxcUmYuEVqjGPBK813IR5iQ5F6MmFSQI1wwyR1FmkgFk+ezNd7vy7W3 +2FxssqyNyZw208aRgWirWsGjVLB1+RAn+6pH2PvhZchbH6LdnPLxXtQlQhHpUeCztJRS+urFMurt +oSeRs6yMkqDrg1hFZCxRsSd0ETR5ANndBenJivTLdIcx2eEjxYlHoc/WcGj3osvOtu8EeXo8jCyr +iXy2cM56eFpEF50LTWsD0xaY0cBcsUVQWoUzWgLS1pPKmyoW7cjAwEOQS3YBPhRBQ0OCCK2ll4/l +Y30G8qyErBID6ZkqspRglsi3ywzfURfaXkN5nIt9g3yhHiwv/5HRbyoJgI8QAR8jAaq+zOneCIF/ +L0F1/bB1w08cUxf68BOH1M3DFhNtPoeQutgVPyI9g4BxO2aolJK76I9GF7RUXjW+Ii12GtYv1j74 +Yqjn18/gMDOmzEezdZVDFDPbFbVdeGQu8l/eG1L3WXXr07yvbtX76r6QjRq8rwnYsZgvl+LeUV8K +Wksw3MVk9IVXxIWCNSqlhjeub5pN6eJjG7M2hZ+xiUKngl43p7Z8eWq8AFW8GX8vokHWWuEgx7ev +8fdzDHlMfqdBpfIzkxg8XOGvKYPOD1kJBF0EmccA8yFW6FmK+LjUIqxnCVxZuhq/hB17bYLawz6M +hZOxGwKv6r0LQ2ZRnBZgU2OoLkI25VVesigXGBQYjPIFRkSzPQpnmkSAEJYU6s7shRmxBqNJVRgP +WRXG3mpwnqOvwqikDGMswujLME6+CKOUgjkwflWqvhipE3IUg8KcjAm+aBvdVsGZPU/L15hahCdG +6FifNPUIn9Rx9oJF/KQSlvIYpPR9QlTuwiqdK1yll6YybGUmVRG5XYhWObayRlYumMoxq9vjJf7k +xFi0+aX1VcsRzTpr2XJURYqPU+7xSO3QuD3ucXyoyu9R+DwqV8fi0ihgaz45ty85sSvKThxT2Ymu +KjuRF53YhYoTizUcSotKYbV58YAsJ3pVQGCthEBRREAVVQR8/YiPLCNQVQ20EGkhIXK546cwVq59 +bFMwBSipegqiSM4/pIJfnuXakv0OReLrVBF52oKO2Txp8o/5UOH2IySHru/HAdutF5apoWd3mEsz +OzPEEnY4rYfCj01A0YpR500O5rGp9zdXR3jWtALK+gn78El83KzWBza6CI3PvPFr9atociTl6cUO +oxOENTriczd8n0DxobLwsbAFcptNApEfKrtfQp4mzOlxgZiqDFeaI0kX2OgCDc1xJxm+s0RZqmAF +jpbg6MePvvylCvFSiTh69sfg3y/w3So5+6PD3yS3f966upVFegI44ER98JRwAmU7rLb9Q03Nu09t +np34omWsWMYgKBfinzqJftqFUqlGop72MnqTDAxf9JCKNAt4ARothAXlJQWwVy1Cwj5UIRuFJ3ox +4VLY3i4Vax6CCYE6Kw0H3mgwe5FBidIqQUhiJTiK42In8oOPLvLGgRg1FIOCTkmkWKrOUWMZlQhI +vRR61plJ4DKZBGKZlaXq4hyQXrH2HCW1gBnrLpU4xGM2oRZn01YtrGsUVqVSFihU3daNSw/at74H +31Ws5uHDG33SjX3AYhrByI0inh7ELNgnTFrIAiXd1yG43meB2vcnlXy1Riyt85ILKthZbYqsn0Ia +jn1IxbGYVoeEjXRKwJFHH11Piyq+exH4onN2TJjHiHUMoMYEYDSh/pVUwFIiElPOc5k8sihJiypU +KESZSqRzlcgZldShXP0Zm7YoPgvZyvWd9KUyBahth6atAQ9KFekRSIUHWpDJZbp9OaqIqnUZqjbh +arNVYBavfYDXcuYCwFaJ736f6o6nQuKpMLjJfPlWxOaIuvVefT/cu4C+3atkrj8GmfwyYXC7kNnL +JCxuHwR7G8T8MaFyIzJXgAFxCneZnX+x9R+CTrGAdgNwN6XqS4okCY5KSqApWl+1NjxmWGnopsrU +orI9/mvOmyr//fgWsExnEmmcKz12rvhYquik0jaPRZ2Wsk4RVxPLkMVCZPtFxyg0DEHaqJCuJ+7J +XUjbc4hpNlYL2+Wl7ZbidqJ5REDOIUCEQpW7BM6Jxd5NkKtsSn44hDXlFawoEjhV5OWIX4vyFtW5 +RcnLCwVmOmHUE1XK4FG3WtFs83ustlJ7/Q4tLJZKOKxCf1aDcFpatyiuO5WRzFxQXFqOqRwLwTFv +ZwTIWoz8DsKkqiXKqrWC5f0CpuTme6SsmYoY3y9O3vux+/imvstFeSvxdMGDfQz6edTO56CZe73c +F/cb4yKLddMOkhVHh0w4xMrtZD9digPdHsbHOB0LeHxgkWewOatuGe/AW0cBrTqB/FtcpmC/Glgz +B50raVw/qjliq/sVzfzHfKh3PrBgFm/l+g6jJzcaZovNixE2dvI14+3kIL2aecI0+Q4YSZ9XVBNj +V5e6UXaITjDTbyczz3zs4lz4UR8rb0rjqAXNwnWQ1sV40c9O4yEGC63rR++/25qisg== + + + lTzQ1cFoY3UOz8KvuiLXj/fITzKr9MOaWQVHcWNTBafl6tXyd77Hq8+XbRs3bfTaxgLcJnhrva92 +TtQACu9Sm9N/eaD3qcE4nRL0+xg+P17uY0RHWxd4rSZwUw7Yk4/76qzeU2VVLo6FSkOE1BQip4YQ +UdWHGCsfc9UJbFACs0o6hNGkVwWrZjCdJKk0EN5oihh7KOCOW93NIBLYNfSljDTfbaRAXr2GupxC +aLs4aKdx24HQZrXkfsSHcnfKkp+gL3d04EyjeGOdGw2WzQSBdXDe0VqUprM8aaycznQvFh7HLLVr +D9oBgrE47H/Eh37SDl2timcL92XaefcFj94XOpoFjhLVpDLk2BI0ulZp+aFayz5CFOprKLW8kjVw +yRv4EbWWVVW/1pX1ax+TCdx7OON37uMcQlrFLPCSTWVhl2UYXIxi897OJVb3GJB6XUiurXWXRVha +FZyeNoVWTmFWYl3cOURS7kOy9boirg6xkkZCJI2SyEgboiGHFPbrxBD4qODFPPn44hHWDTwrBauq +Bq1Vp3orU7uFEMX0M0YppghFVYQhllGHc6UmlFj8+F1+tldFsGLC8ydc/0cE/50P/SudDc5HdcWw +vyXor/Y0xHA/XTgZYv6dGOMnGXhUAdIqIVrn0vCspiaP2KwHagCvB8/tiuC5JXQuBs+VoXNF4BxV +UZWFzeVBc1keklTQOA+Wq8sZL8WMH5WNZEpunaFKQ9Il32/w9qrMwTNnsZbBzfO44LP7Qs+qwDOO +nWrCzoqQsyrgrAw2K6PMgsavquCyMqjMFpFkZQRZGTOWAsRUERVWxn1hzT0EmCtE43Of/2QwuVIL ++4k68GkywqpzFEc/SkrwjKtFPs8B+VzICMaqQkbYxSTjS92PrOjHvm/wRzr1JE92EGtvVEkvkvSi +A/MMvVOhg3MlyhxDUgGd+WNGM69nT104Xhmcv56p1MfZL1kYJDh+YTj79L1EnCVJgN/fF78puM1x +Uh/HbcoUUnUvHgp6PxP2ripf+1rYewxzQK8e4jDngrPL0OyFv0jv1Bn+sgRkF8HY3x/lMv0AbZ8x +ldb0VoAV+M8ZbHWIxJP2+pBj6W0ItgZLp/dZZqqSAjQdlIhIUo780HCGdP1kPfg02mVWaZehBWJJ +jxNdwDEH6j+p4NF0Ivd7jT2lSZYo3LjREpsVVivgwAgKFPlIDoV8nwGUnxtP/UNjvOI4Ddmj5BGs +QJHrvXwAAzM8vN779aobmsapnbu573N8912es9jEeIolJ69A+im6ROExT95YZ3T18iJlxSgpxmyu +e0iIHuHQQ50KsiElw7Brl0QKU6AZY7ZLF/rlM1LukiwSt2QnFOwkuLCQKiOlmvvho2L9O5wtbbBa +yaDNxl9la1RZ9bEQcrLmpsvV1l2hti4x71PyyxVx7yoEvgvcz8eLG4Fz2JD+Js/zVGZ66lIUua2U +96i+iwKvkg4PaaeyRXng2DxR8rGUZ6ybrO5peLcgMhSMZnREOm8stHCfzcsNhflSkPa1TcWck4zc +vAWnz41TP2UvhM4zY9kwzUTr0hvBHgyQCGb2glcKEA7UZB6xg6aZ5g7fg8aq29VpzUxu5tXj0oHR +bHGgz4fhp+uEH4UOHAT0EgxGjwL+k9A9yFigIr3U3Jl7CE+OXcREnXn80Bwx5xjNqLfYMVNup/yp +uhBGAItwBgsSswntgJORDuDRYzfL2oSWTQu3s1QW3OihlXhITzcHZkVMqWUACV9D54tVVJC++FqT +TT6X/nySLLDqjBieEuU9Jcp7SpT3lCjvKVHeU6K8p0R5T4nynhLlPSXKe0qU95Qo7ylR3lOivE/5 ++pu44VOivKdEeU+J8p4S5T0lyntKlPeUKO8pUd5TorynRHlPifK+ZwDeMG4nq8efFgUYO/GUKu8p +Vd5PkipvWEWRDrqIBVvyrz3YVmA1uRvLN1X4sdrWp+RuNrXakRWdWGJEUSHkITqn9slQdAjVj70l +8DKYjbxjN+JihiJng+BjVGFBKm1Ia4kb5sKMdBCJcMnUYKh9R39vEAy9n1c0u8tCGhRLUkipsE9u +3CgFJjSRCo7aGlCkk13JJ/KoYEU+UG18dJse01T4o3Ty5tHeS8HKVKkzyz1zKLyfB31SHs7rWbJn +zcH9mVyfye+5LI8pLQyXBcFwNexUEASWpXAKS6ETkcGkBdEXi2FKWkBhTRQ2iaVgwmKwwkGHkL/D +L4ODcNlj8Pl7a+ISBTUkj7/zGoISpu3DofJEHLYIiNrl8DIuCj+fj/+6Z9ctTYU/ylLkNmtLKeN2 +qcwpjWPEaDuVnN67yt3Nn6dAOU5BO1vimzi73q+dBzgR1J2mmYLdXjSMvYh7J7ENc3ZPCcOhRXbJ +U7PUyVkgXx5F7Flys1Ai8plVppCpZydSk5/TUzOnNsypE7lrpzCpHr9xGVS+UuHzgW4uU/lkTv/7 +Gj1/mhue14lLFU30qAVdMDVBFHW4pfUAJG/WOz26nf/KvE1qxeW07lNaEmNMhUVxTLBpUclUYVh8 +jGlxX0RbuWRTDPZEtVL9uct89kvV512IfFtshjG5XmEDVo33Pk/okGliSRdbouJybSzpYyp56Gt9 +7Gx0nBSkl/msnYbn26NmWq06Ftdn91FzqzKD8eNn9pBmdpfF0cm8qnuqendNQN3+nni6AMpQmXH/ +lBn3W9N+Muwns34EY0SLvkf0BwzGEvS4pmk3MyvzWTiO72/mbMtczOpBT/PaMqjnPY+1y6b7YceA +qea4nGGZX1VP8JnZLed2bc+GHasavE05r7tiXu0SwbqyX2VWVWY+WQtlPWM/qXK6QNQiFnrQdh4N +VS7bO0h74NZiURSka29pW4GmDwlBdHzcWPCVEzHl1NzsmH9Ru7NNBg/b5EFdjTT8TDok2jV0/KHr +ma9k7GYBBs+QZWYmRNDj6JM5jIPziuzEoBDR6OcmF83cmEDmVR1/6rdd3085gvkn7MOn6c2rKRpw +9CP05gf15FpJVtk/j9WQM3Bnqx6rQj9+tHZ8XjmOQGhTpTWMAnTMaHhM+rGu4NBRPXbebaKSSnRe +Q649JUvETR5zE5RklXJf5lrySvhNSmqps6TbSzY8QdU8Rpt+lAadK84q05vnpDfHZPi7pDc3WnNS +mk/Rnu2VZpWWzEfpzGGhrKjMKuhVuc5sM93KZzxttOYMg2MKBWtUq3pz1LF0gcRZcoi4iJZfgPLR +s6ZSqtSh0p89OueU5Z+sQ7QWu0qwrDxGx36UXp2r0yrTpsekTU8P69JJlT4UdpSjSrr0R2nS4hNZ +VaRVIgsnulQSWfCEIdekSwvJyVtIMryV8TOtRJeexM/n0kyfwkxrmeklmemYSEGc5dJ/quMsx6Qx +ZeKYQ9SpQ+BDzJYZgx6mImFmnOWfSg39u77hfZ7nXMsuHZVjiPEJyWFaPbvUtGOwzy4mzKm80D4z +8+Ex+viD+netnKkV/ewhzfte5UwV2tmjte7zypl6pHa26N3d/aB5leln5yT56AdtdO9CmC8y09Ty +fKN/B3/oA4i4x2jpj5v7wupyv0b+mPnu8/lW96DX79HFzyprWq3o4vV8Tyva+DLfp3K+1ao+Xs73 +OY188X1nKrk6o7+VWvm6B7yZ8cfo7g/q6rWiru7V0u/R0Svk3tTaYj5KQz+voKuH0hmdme8Vq5qf +bdVs77HS0vWZuZ4ylEOGc1D3aurrlrWzWIdSox+17ZyDJAJxcRCXvEU3ZguJgDlTg+bbdbPDKSOE +9UnSoE7MwzlrM4xQGPvNWsJN2zhjbe547cYzKv1n06OfSKdnWlL7E+v0qQ+fpNPPayr9TI1+8Bp9 +FyVEnXIYjQJlz/Mt6lQgYspAcccgjXv5O6IOIZKoKl3D4n+sEzVcpiwNXrcekzC9aNXQq1WQprX4 +pmzwTY1FDIPLJGqRqbMaAEsFgJD3X6W0/3mm/32KcziWWf1DNv9YaqxO2Z8l5Z+bSOM8YG0Jaztm +7ZS3GLSpzkca5/GtqfVn2hCbWv7M2vjo1nyp9tCjv75D+vHvUh7n7/OGi1bn9+wobjvu1pNEdfdY +8rPfo1JT0O9OJ+Yx70AOgNWIV8UW7FXYfbtQvMUrr15pdalki99MEd7rfJUW2RGLrWEXjFJhqVoB +sRZhXakugxVQqy/IsJRi8GUYYgmGWHphVrs5VXs7pGpvXSiyEAsrxKIKsY7CXrDgsWJCrJKQ1UZo +ayL4uAGve3gZpcy7vwu14nxbJNuT8kJPrCMUosV861MbCj9lVkykkbadagLnareob2vRe16kq75U +fSB8Pd6ZW7VS73y8D/Fs+xhH5N/QDZeI8/h1Wmnnrj6caXtV5AQv2+6B5taaWjnYVER7sGWZM1T+ +z0e1cb2pcx9813buhsN3beq7X/p0w8/phlk+gWORI+I7Z1MuM1yuZYeIeS7z/BC28l1Xdi+1AjdZ +qjlmtRwzbEJWy7Et5aiKSo5eaS6rOa4V6zlXpmfPaMXzlRzXCvQ8WJ5HpTo9bVnqukjPWqGepmCP +amv3rJSCPN+acj6qPfTotloFSN1TIOg7tb/LGy57ljuWWR0H7FWNfXrErnGSubE/aexL7komaxyl +kKqWTXiQzTfJpjNSUfMkm8ypkIiyl8Kal1Jas0xDaZKpeDEkrSUtD9gdVZiF7zceJfNRMiAtYbYx +wmlUVYBTGd50XA1vKgOcpEB1inGS2GodshBdpmCnU7DxeyF5n8Kedqlu1pwCoGIQlG/iKhtCRJRN +cVF9iI6KrYDk5lFfTd5KSfJYtuNqO1PqTMKBiqbOpCDZfdemin9XaNXHNvV93ORzu2GeC6QLTUv7 +6IMSvrUdetlA8zyYUapNbedJCkP309TTZ3wmg2KTP9g0tkkGULUG0x/zmfv3SmyLOKJ7Bs10oDWx +JyufxPO344APRr2la3/T2+2oB1tct35Gef2Eu+INN0YqaU8r19dnpOunqcr1WB/+NENnv2rp7IvU +8YVXKAdoVkUoEigzD3usqflpPkSsDEllH1JCGBYUDkn3jiFxyT6l6osJQYaUAK4PWQEXZ/M/l4ri +p3wlxTIW/y3bp7rFpepnCvd4oPDNI9MH+5pVS1XNaOiJtTT7zNQzhdpV0dQTS2RGQ0+07/i016ux +xPqRzbSt8uK42WBy8U3e2ouLYMJa6ezoOmxlvfEl6S1Gpps7cGgr+Xt7WwRSchs1ToOzGX2xSSdS +m8Vz81P2wse9WlaKmwzInOt7v8ed0yPkHZK2CXeTY0MTUVqUxONZ5zPYNsW+ftSnfhKhcqsoS2fP +V6r7uK9VRIpaDbWv4+bHLEVCTJNQ54F0MZ/jPoFXDsHNfBnSKHShwoVuEGI2A7ZEhGAIplOp7kWO +ASzhozExaJ+gfgvQb8nhGQB+qgiIMxX+s6xnXaI+l2rWOod8KrGPz8k7tdSwjsFwEdI3hEQPefrb +6JLSgTpi/6mQ6nZJdLsgP0/J6bSgPyPJnAooXyCcQjqTb6iP1c8DDnRKXpe92LCPsQ== + + + 0HkyxS851iImFE2lquT7rEhyTLumm0LJZankpVxy/NrXBZNTyeSUtDOGUrZlk2Ph5MXGD+KvfN3k +rC1ZCvPiyQvKpSqd/H1C5FZSaOgm6up8zot6G2abURU7sc13ekh50I4Z7iPfkHFThi2pih05pLpt ++a5sQ1vLqm3LpjS+Zlu7L0v47ZKLOo9Uzbemx2DK5lSZu3i3sj9rUPZYOY+z8vIyrMbn7yhTVEfI +7ZLQZoFjLq7jBaI9JXlGMlzlWW0iWrspY57AtwU0c9m1yaXbq6yoeSxrnhc2T6XNMxx3LG4e8yOm +vUtUd9y/fmu0hc67rNi5SYpquZPHbCfPaql9Hrd01Q4rLfNU/X1ut5rz1ehoq7JNNlYA+Xyrldwv +32p5jETvS1suW20JhnArGPdlq9VREEsExKxCFvj70O39gm4PW20OOI2VVPAqoZ5z3HOJbz+mRPAL +W1zCiT9iuy0BEkPSK+YsTCLqF6cso4BWCTZhM0Y5pbCJuO2OwSybbzsd2GYfzF7yaio5s12IqNhl +225hn3Hz6WzzrW2/QYUdOBY8Neetnr+6c9vyCQD+d3/De2mgaehfTvOmFPO9ELdDJGlLpYBYe2JI +kHRXoMBOSQqwIRN/AKanFGnC4lWRgU7iKUIsxRCiqfJUab0AvHxy2phQhPAtj9iiNeFSCfAkJqH1 +OdN6QZs47NqT4Ex6yTHoQtI0E3IKMpvgUbII9pI90PmEgUryBNqQG9AJyEMSAIZEf1by/fpcv/uY +5xeDpSW7L8T7+0w3j/H3F7792NSqz/6B9NZVdusit7Uq0lrnCa3zUpxLBus8b/WSqzpLf66W/OdF +5dOILl6qn0ZEcZ7+PNVAXSDEqqqCWtdBjejhRwf31i7Sx0UGtCH5KXRbVVjxPDqgNBiWePEyQiDC +iEfC8zLMeIMaX3DjLXJ8iRZY4gXEIdTmUMuzqJV51MpMamUutZBNTWUJddfyqZ1Lq7sPieqavLoq +S6z7HVLr3m8pfdpuT9vtabs9bben7fa03f5mt1vmXpqsY9LOUXLySU6NcWJSYIwTRsJKrspx6vDZ +yIwazseWuE7bgf6fQfej1iFr6XrQzw/2BLqFqnyp9FGP49ZCV8G9/c+NcVsq7mZwbsRd9blkq4+7 ++GOcNP/725u763/c7F9dvfjTF6r8d8Utc1/RvvWCfYvCdEhhM9pbcYaQUNotpcfFX9Gn+qZtyu48 +XfduST4xdCqlbhtSSkaP3F+8shG7X+QNOOeXVVkaxphgYqnuWiaYKJNM6GQdWcySjibJ0iqy2ENK +Q2S0gpQGyGjkiBRsn7sUDo1j4eT5SuFawCCXVhEd5nMJfxozrTjTiIv47CEVxAszq/JqjFWYtgv5 +2I/JGqerGY5zfAiKMZ6gQhJG73VyWWRGnpN9sWLvGx98zBcRvPBqXMstogtbdUwgkCzU9827mneZ +gSyfeFPYpJcMI7vGEB1dSTJCKk19aX2ei8nf5abm7zKXcYfGSPsh7dJghVVpJpeA+0HsrHGfHrKS +mvlMTqmYZpFiX2VbNqZdbPPrj1lyiEMxlzoZSG0MYJsyr2GRPjPbyjYzhroMaLHqe6g9Dy4zgB4b +A6hZ9Tx434PMtaomOzN+njN//q1bK9eTQfTZeiyLEIRVqeKyXClCEBflQlmWaMsQ0ZX4xRCiuvZM +LH8qbGuedsSYrmhXOxVWNbGpJZNaKkJAg5qS2C3a0xizNUm9jmOypzEsq7Gm5dD5+wssrsPnVwH0 +6pgXV1zA87GwYiyrGIsq6gCXP4YA8lhLcQjCsVYPY8GqRPjrafBTbLg6mwS/TQDwqCJI6vtJgS8y +rUi16nGVkHKR9lPncjUUQn2/M7nvVFHU4BPncUnf8fA8PrqUlfpeZjHTTNTj5zCpJf9t5rKYTfXo +XfnI2VTf055Ms6k+Zkf62XwIgAhVDr1188Ty8VL9Yexn9NtAhdN6EpjfJMUPHERNdF/S9XtscsTJ +8YjJC6fLgeyEXp9LIvF59GdF+2yKzp/7/D4dEgee/+r2zW/e3by5u3nzzbNnmWqZf6B+9Zaf9P6T +31zd3V2/ewOd8/L21c3VN9dQN+NfGyjfW+ptrE8xQeXeaD1vsS43g+u3Gtr5PIi2PW76ad5CLsRb +Wyx5cAm+xE5+/uEv/p9r/Pogf0al/A9/lX//F/78vzj4FwzP5pebf/8/3ealv/K3BGXXfagftXmN +sx7s0OYXa2fF9/nF2oPu/XD1/m/wfbF7d3e8eXF3c/vm6t1fNz8XXPnF/vb21eZnuy/DcD8/vby5 +u333fA+FHlPy/Hc3r66f//b6xd0Xm3/EBf8vvutB+7Ws4VlDqBomByEf8poWKL6BSGc7HJl033s4 +LTpp8IL9xOoqclaxZrn2B1evWpPiAHie3vzhikNmWCsEIttIEX6cN3qetswKIqPes4oJhnE228nR +BANShhM26OS2E+ndDjOExI2eLM40nRuGWffWyRkzQxRGS/KHe4x2O5p+c5D7Tv6+uGoG/eFVlC83 +g8XL9RBVQZYmkDT/5ME/udd4DVC7LQuW4cX6DroLzpi3ILLhvvN2MoZgYddN2FfzsLUzbjz0UsJM +emVZeETsSw5XTw4HOpByO04aB/5VbtNLRZoZg9sbxzFB32eeBcULw745O2r/hsu/5i209ifgXXTX +zxuDrhm+CMiRxovJ8GrDkAfNpC0dKDhOMluD/xxtdq63m0FP2wnCPDQvgyneGDNtsS5wAlQzdBEd +sVssFQzwJBodzrBb6ncgagYLSPtxMXo7duDf48zqM+yN3uLe4F8MJJD7sCsQ/0dwJqw/6S+ZAvo7 +OTvghDGMyQS9A+sQBHOLUcXmwNR1bgoPGrbYd7yNoZaH24yESuMWHdjIxPtg6sFwZvA2MBzfFYwQ +M+3iuh5ncBAgvWD0Byp8eKVxi0vxSjQJdHEJ0RSIh4wET6/eRrM2jOUJ+JtvhL5hawxSN4krE++E +wcWbYP9AWaJ6CW44h/ubMMMDtCi+L+43jryjtuDcXEtui4WI+3DBYlNwcshN0U+qzFyr8xZLG7On +yUDRSc4D5h8D4DhBmxd80qj9KsDOQVdwH223mqGidoBcgZGF+r0lomEesAIhFGxMN2xHSXo0g6/N +eNkRq4vrBOLCADa4wSMwXRrnM30SniTvhC04DVhFHRZnD4Xbgs7wANbltu+wqZhgSPd8wCQLxkGh +xxsNsjEhJ/BloY/h3QwW+ATJxNlx6PA2/lVAUTusESxXSBO4jR5ZYocLyHQgpGByDiNiGCLA5Myj +LFdNUQpLgtx68+DGOWQ7DGtIeBgHwY297rAH/M7q8GAQQoYiMCX0BtLRllZkvJ6DQIS56awQFowO +lyfoKsaAQhAoaIc97eQM3xMzQFjDGSM240jhgiscu1NeuevxijzBjOQcoASgtJgYUBQIZhgp67AK +8DHLFllSa6FKxk6kStB8R5yBpQrBZeaG9GdgwoXeGtdPYWt1hhFenE68Kqd4xgygT3gQlorlg7DA +wffmyc4YVxCl0W0p5aDD2FBYoaB42BOgj9Ta8dY4o9tahijgwSMOy5OsM9jEmt3ByuvwpHHYsu4U +emQGbkAscUhSXPQYpGHyfdFm4kuDyxi7sTiAnlMGxqMYBYIDntRzpzkbnoTLsOz54mAN6CuWNaaM +BHriTewWYiduQqPS0EtH9MRXpmg6syOdXwQDtx6IEbqLofdUD6OAR4JkTCCEjn3AWRYDwbNATjFi +oP6YNksEDwkqztBbbGPch4sSL2Y5hIb2KQ1Ggn2kByzYwMYguW9ny089Q5ZVZmWCwKr41nxA54xU +pp7IhXEXbFTyX9AIzUkD43CQT+eJrGRoT/Bvwql2NJT1Hbg+zrJ+B1N8H7F6LYaOmcAwqV3XgR1q +UicQYUcLoAZVsdPoh6rnqFjxqvTg1eEBIxh8z5EGIwJF0BYs0MpSm0ZsY+wGcgzaZvq+G6SjkxxA +Ryfu3c3ZDckH7P8oclIbh9IPX2yesSYc9g09LZrhgORCWBFQmSRkcZJ4IC9VPtMbaFwjAxkhVGBB +kS9Zro3N/hs845npsXWgVEH3GbCSxs0zDDAoNJQ2CP3g8ui6wzKbWZkNNAmbcvNsEDZL3xP2O14P +Fw0cUSxXKAqYOrthETfsdGZhw9oBQ/gDCc0zvDmIetcxWxkItEEHwclJAnCE6/0xT4MGCT4JQQ+r +mh4m0F8Qb2wg8g3MSr/Zk9bg1lvxfhqaQzFEm2dYjFg5JPN69jv6Ue+GjQVOSrurAZHlu5ECzZr8 +UArHfX/v9oxC9ZaL22lI5ZBp0fGRSejASCAIYonLy30tUvB+vy5iX+T/by5+dXsHafr23UsspX9M +Yahn18bFb6+vXv3y6u7dzX/i5M3PDrsvo271u69v3732HwXZHGL8y9s/Xj/ffemeoyNf3f0Vsvvy ++EqChxj9Mq5v8z2s7/hTFnMYj3Hzsy82f/jfi8bwPz7IOx/lCE+EKAC5GdICtjrXEnQbSnwGQ4zn +jqAHnFBMFYQC/MR+BYnFLgebh7DXUWWigLHB7oCoBbLDWDQIARtHlQRcd8Ru0MJYRNLEkhEx3JMn +0OotXQUz9WqSAC4vLMjNSMZBsQQLgu4G3s6Qy+PxW+ImwUVBYCCcQXHD5aO/XX0ViCiWuMPtQAYh +JIEOQ4YCNcX/WLNWui1iMlYmTd9S2g9ELt2u7/ksTZUIunYPBYqdgNAEXsdqixC8QMEmLhcwejA9 +UEMSWwgx4E4bqBjYii68LC6nRds4DC7elX2Y2AdoQEaLtoEt4zaTwaxzSKftbEQalvR/7DTYqpce +8M5bDjOUGmy1aQOqucWu0+Sz0A42VmPCQLGwweVmIOok0r4jc+9FMrpeDKYYghJIOE6GuAgBAd3X +o9g0QMsddRvOv0jWPekhdIPBMaumF0NHy70MiQu8aLYYJoypk4uwWTE+mKpuonCCqZodHgfWE2aD +jAOMBJRkSx8g2BnXoCf8kEdDZ0ayNMz0IG+MR3npucdggDRs8DYg2Zgda72iwXUBzQZjAiarw0oD +b5kwwbgbqCWe6SSectxAG8RZEEwhf0CQMhtIKD3ndDRUobEhIHmKWAZpmMY7fzvQr4HSuwUx0xC0 +3BRvNzFCFbfDgnFY/1gBUCgxmww9BevDS3NsR3Yb+y4sXAizlrKgNSDjkC/IVXErTDkksw3EKojC +XABauoJRhi7puA0xJripY+B+N3jpZaT4OWn0bcLOxDjgSVhH6AKEalHmrKW8KtAE0FjsBsrSEBln +Hh/SYZlcUEJZhNCOqPBl18x+QEGCRlJ+7ome4f/1B1NHUT7erv7Qa7+QmradJG7FB8tBdAvKKg5C +PcFQEjgx92kCIEBuJlGUuDWxCLkC8XadAZOdqeWNffvBSEkWVF66U3+IdW0op/K1wZhmrh9LSRtk +B1qElY5SP0afwIZmzU0J5dGEaez9HFOWHakJQDdmflmI3VsaPfAcLNmRZoCt5Uhbig== + + + 5pAReyoHms/FW9kwj9h9/Bt7T7M2Ddg7aG7HPA3UGzRpFbeM7CdZPdS6oDJBuEUfB5NGnAwWb2Ks +SL6UFzhNoHQW3BkHGYrMu0EbH8UQQa4AOrWxJGfYetJPvLT0E4QXwidmhpsEe7yTzUhpFnwdsp2D +1usfjbVCQR/kBHqwptSM4QHNJsXTkFBA8SAgYY/h9h3pDybekHyiS6AgoFpYbGYcE6/osWKo1WnD +mxhRq2fqn6Sj+GCkgA2KT6qPzoKsTxhlfjAFZYgEH+SExJY5g7WPCOd6njsxbNAmwUnamAGvTFY0 +kYZLpzAbYrECHYokHXqBkO6ZeSOp62P+eA0NA5BjekKlsHxAFSgiy3hhZbC4kOYlG0MaZcLmwHCD +53I1gq17pJAnv5C8WaOIi5TVjzc9lw+6Qmoj/BOLCVruyFeFHhcIKP6hG5/incbqZtlnPHSQTuC2 +1ERBH7CoaTsbZG9TY+bdNQ01ngdKed3ZczROFZNncCOIFYdREhONPU7mhQY96WwPAZ+dBYOTu7u4 +/0HBZISxyqVSErUFTbMxNh5I1sxKSngKxhxiJt6868L5NB+CWoKHpBWBLbOl5QnrDqQXywWjDi5O +qglpYaZQI9OJnQJpxZDd695bTKDFzKJAW5o7Y98mefvOTyHvMTA3CJ0p6Egf9MVtYgFgjpb8E5wQ +Q7yhHYnDS6kVV1pJIe3k1ZhmhK9Grwxu5ffzIdidZ6rYULC5gniV49PxONofQXww7yBI3OKUS5oP +aDfDAf8G9Ye+t9iy2JRYZRTqROOR5bRirO9Cp7QXbwaI4ehoOh0yB2gqTqdpmGYCf/v6cN6l5sP4 +IgNtBSOjYCh3kaT4Nx9oD8WSgBQDtsSNWQxX2FcDpBCy2zTIIAaYB3R54GrPJoNmYEntCjWis9n8 +4dXCvSjp62WqB2ru8gElhbQg+AiRWvAIbMKpWDtyM+isvBnI8bLiOJaGhmXWN+dt4hoFOwjvD6GG +puJiZWMQaIvkIEC8GtJ+gMQfrsKjNNhP3D8D1hGoHzQqAiHKTTeQvE4ka1DAwS3TVhWjq3ODGF1B +DtPmpjlOc7pGx7eyBUmgAVWkhZGAn4V6DKT9hu5HWmZIqQO9GcBVNY0+eC280FBQKek555s9B/dK +tI32+oEiwUgDNjhspIZ8fkd+AqkeZG0oaCjuv6UFKxJccJ9gJdGQrewQKfRAO6VkwQbN77ohp+pY +9nTv0MJn6MRJrIAqLGQc3gyjAnYdmQefyiTxM62a8kHGcsDXIfNYrEuMucPByKhoxeeqwAe4aOwT +a6OxE6x4nKk7UFDL+SCvMuJM6fA8bhzPPAeKpGK2xijTyBi5LcerJ7MhtzSDLXj0QCFDs+cQv2lA +iJx9iNI7iERPq0WUBWgLtrRNYy12IGhJcPCzOXnDNXYqV0+UNnAI00AOApbQY5yjiPJn6YMFEQRD +hPxE7pcEGy5cbDfyBKxdLvMgCvleT77X2GKF3MR1OGs+HiqztknYwnYmThhbEcSFLqIonXHD401o +JUcvqJFlMt0w0n4tOegsdaYkCQ7UKMiyQL1nZ3SSHZsPcomz+TDKqTTV02yOTkxCqaJkS7ojuhcG +giCpQgxm13uKDAMTaYM/BtGZ80BaVv+bieLxWJTbuUtpUKBvDjrKIulz3EwHiQQK/0SukusH7ABp +NTrQYXktygMJb2cG0jcMeaaFDDQAkOhgnjSUnHUlBoIulEUS4WGSlDhRB6LTQ1YS7ckWSyuqSgNX +DacXHenpV8gVLL6cOP+wdyExuKSWcdjxYpx73B3TGxU5cZ0I4xhJIId1PZBjQ8GMa4rqdVQe6eLh +4EYtE2uTxGsmCca7l7oppCXQF25QO1IxSxotr8LA0ysJkRFsIKjA3E0ixkCb60AvVvXnIcjwUeum +B3OC1kIPZid2Sa+mg5Bv6SIGecDpti90ezCn0AP6b5I9gL4LGU5wLk0xNloQaJfvBzpGaO+Fhprb +HSB+YEnQn2HRBd4uGCnoMKEYR1dIr81i1SD1xuSA1unB9GNhAaHVmI4q0EF6vedoNiG5pYV7Fmsi +SFC0s3huRzAqud08FMYZ+ktZCpQcDxNnkkmHHlDvsKYhYuiTEYjMAEInyTrmtTAc0bfq52eyZBXJ +3MSbaXaWlhTukmigos9RRH9iZi14Wm7Waq6KxjCyAvALvupoMB7JfMZxIzfLbW0cL3KdaJgTf6os +yZE4oRWb3iC+Ee4NTjp91bVt0PcOs9pT9ODWm3ASiLbTA2VN6jH+pSnMiPmIq5i6NYcMG991eC/M +NcZu5PKmWi3TaylFi+cCHBXaND/s0CPxe0AqFb/HLJwbixEqJvrdT1OHDW9pOKP5baKllM4ZbF1N +gOokSVhM8Fw4EnI8nTgJ2UWj+CBxH6giwxBkh8HLDpodn0Te1TSZGi2VArTAQSDjWSwDUhauncim +ZxoPsdWwrQchc5DxDW9PDw1uD+JAaw/oHl27fgI0Yat0V6NHf5Zugj7PlB5GTL319ihKc3wZSynK +itaM8yb6jzVnYJSZFeW65xnkwpapw+jYxbrwAJYx+KLqy7HnRX5onmwo1YAQSeANoRrNG0DU8K5Q +LHt0MmzUeiR67d2hI04j5W4G1IxbyMsk5h0EIyc2iWY26KiiQ5PKH46ww/WM8kFgS3yQYRXedmXw +lXqQeHQHSpwLK6NeYT1dtXxx8mFD72G1ONGlLc2U6I/Dvl9Z2zyjhziC3naWc/Ai7ux8a2jLHkP+ +wxsRo7BpdhdIC/7ACM/U2PTKJsXg0e2Cv4nOntMmLTd7L9AfziWIAfoXyQOdcFgIPY0kE32rkZZA +HUPXIFAOBNybZZUXFEgPlK9xPiVcjzOpiBfdf2D2lu4/Impa2kcfZYeVgcEcO+qrq0SQbnf6Kxti +q8nYpB4UIY6EIJSUml50KHrQhHo8xS5Al4LME2E0EUM+DOKq3DQcgg4Zqq50yOARumUwmG1QlKQE +FFwJg45eWtyaIHtOZM3P6LOeqPNVTFBT1wSrQc+o8QYwQcVBNeQl7inHWtdEOzXMV3MNYwbcIHvM +tLwb62Xbj0KR2PHwIjXr51nctaRb08AFU8oMmgIIEUm1nEGnPY1XbqBLObxHLaRwkAVoEqQZupch +UlquDREza1EIKhleBC9HRjUGDayWo7gZB+9pdrNMbi2C0VtPwybWcUeYZyvB4XYBuAaCTknei3Iu +ubJxZ8NdNGJzbmpBUdzkHV3zYFqGOl8jb9JwO0Qxs5JShfbJ/UnhRcKvBFyuPVAALl1NIEorH/MV +aYvkK3ZJHa/FayITnAwoZXyao2vJXNNRw53eCPZiCXQkv9g8cxihWi8gxeCL4AGaxdw2jUqhqbY4 +fDTggp7aZK2RNGe8CDJ/odC09wkqEOEuPTVv4h4ICVw+IBax4xxTZZwKxYkQGLI1QmBmkWdqZaw9 +o9blSAzJ1ByB2omo1qogSR1nDveh72dFxdTU1sFdQU162h3aE0Y6XjDvxH5yPa8qo9ySHvyFPWRl +pCvtV2CVDK0d+gC8rJVnkifay0GesDKj8Fnr3iTCRIPgPoYp7zaN1s4zBKkC/oB1NrZKPwk93QV4 +EkhjeFBtMiBOkyueOE0jdLa2NhAzBXFvJGbKzf3cGiuIFLUk/CBvjiChuAwKU4d2AmVqDSR8E8hL +BJN2ZsS7ijhT21dIj8UAWltksJuFxBH+5pi8tjHo8AxSDp5hadjzYldlD9KOaIJNYz/CjbGeOdDd +MIoqU5ufCPvrBBqKRQKBIbH+wnoF8cP7q2p7Fz8QmCRLaBkxVVXmMp7RYauSh3T0j/kHVNY2SERb +jqETpBSJXmOoo3thwjDR7zGKjF2Z+XCiYDkPSaLMbYPaehXfCj553CRrIkZkFk6IAeqHNRsk76UJ +8pyIoAsqamPCRHeEF9ZGT+IyafXGwyG/9a3JlCM0YhgokEy5pauwuGIUoCBzomYoGQJZLW21mA+P +I+VgiP2jtvQKQrTnzMwMlF/AubmdmLfBy2LBMWjCDZvGxOwXA3UKJxpVa6GWrgy+K2CRYcRq+zbh +qD3LV2JRdpS6GtM4euFtXLVBXcRII0i0kXkBkm+jsMcTm+mBjBMGhoSoNuULLtNIfVEoeVPrCKCE +oyknYEt08UUqJwJn3i+tiSx303ofqLRxXVtxTzWOCyKAKU0QAYzOBMtA7fYw0GGZAgGPoc0Db1N7 +TDjsPZdg7WfR0+RXGOhz30e6XXtpSKU8oL8zTGO94v3pyOPoJ54pkemVM0iBOmJPR3mXdUdR88K1 +WwqsWtyYOAFj71pvFlYqZMeeAGAGEYY9UzvD6tu0Hra6I+0Zay/UntUMTO38awe39h2emSRxOMaZ +bRyTzaKIzszVNRUdn9V6DN7Reh03HtW1zdD4Y5stVXtym13ZOILP7O7SjRxpQ+N2bshK47VeJU+N +07shc42/vCGVwcm+Rmcbx3xDrhuffkPxG0jAKudoEAU1A2qxCIF1tQiGNc7XAiBqDtpCJ2rm2wAv +ct7dwjVq1t8gPRrxoQGKrIohDc6kEWciMiUKQA2MZVV+akAwjRzW4GeCBNeAblblvwaz08iREeUT +Jc8GEtQIroc1QFGUexsYUiM2/1m6VaGYGvE74p4ayb1BS60pAA3UqtEjGpRWo4s0IK9VnabBiDW6 +UQMva/Sr9ow1Pa09q1L3IhquURRrCN2qvlmC7xqltcHsPeaMFb155axK7W7Aho3GXiEVV/X+BubY +3qVGSDY2iBZpuWbL8OjMaP9oQJyN6aTBgK6aYBoIaWPKadCnjTkogVczI1KDdG1sUA1ItjFjNRjb +VStYA9FtrGkNuLexyLUg4TXLXoMxru2DDTg5GhQbSPOaObIBREdjZgOhbqygEXi9akSt0dqNLTbC +uxszbgMKX7MGN4jyaEquIeiNEboBsGcm7Ab13hjAG8B8Y0Rv8ParxvgGrt+Y9Bukf/QGNPEBq86E +9vLaKdFEJjSOjSawYdVB0sRFNP6VNraids20MRprLp6Rsi4W2swUT963VbmK5K0pHfOte9l0lbeJ +UpVMMQNze9lOK16rkTolw5wYciTSeu39gviypejF4kT0NTcOtIk+DUkNxAxEblh3xOG/LdNPzIxu +1a07T2RI2uQpQzLquXEJ4swgrZKs0yVTuxb9JEHi8NsCQxUdh5mHcpy9sA5tbXK9bv2cItm4SQRh +vB860w2tv3QSwxpjEDta3hZXK1iMaKqcTrFE5Q7a9qrav9s+ufYRNy9Qu5pfrA5D7bJuh7N2fQt6 +vJ4W7zevZ7N2t7drYs1t3yyt2vvfrM4IHGgWdw43aPZGBCm026rGNzwcQsV++yi1LPBqZJi4pdqG +Z3dzmnKJt8I4ewkfW8+R+kBEY9y+o+RsqEWyeKGEslKgovYPWURTWsZkQMkgBh2skbzLuI5ZAtoz +5L3ByJiHkmGx3dyt3YdxppQt0QX6oNgFwwjXkRgVeoyztbqcDI3E9ZJST0vURfMc5g== + + + DbDkta6D6m9X+luf4ddo/d7NfZqxoyzEqHgsQMjvDHs5M/TLPH2jAtgYYhdNZ8wMIzosKT7UGwg0 +WNGv18+yYhenbGwlCL+xSxE2sWKvorYvV+Lt9RSD/M9ePQpqbmYeBayMtec2Z1T9fxGNR8VZNN8z +bN6OXcdcGOwBg4FppmLKCZwxSIYOaOpghAQpNH3EkBODQeURJH9KtkRLazUIvPjjVu5Tj2Xbl4fm +5EU5h8YWG4tOkV6wFGC+5FTN4hjQKYi/0Erd3InIVy8wukcGepMZ6U6teHWhMuq+pz47Ucygkl6f +xfB+y0yVk2U1CNtuGsbTT5JmgD4zU8J22qur/dn2oN7a7ZuskYh2RJr7NKNak6t8HupdVq+/mQYt +GzZX9WFPWJzEWNRZfUYy/pVNRUg7r1jdS8tV1bJanlOvt9C7F6tbnzSOgVntSqeSpFe2/AT1PMJA +230Wr6qHKD3nzNjFTUBjiCGSiZiobhhKJmPmYOWAiMM8LPFDMRpMVBRBSgahoL3kQyDgCZKDj0Lp +qXbZid5PypraM0UoLzIUwgw6QnOxQCRDjpbbeH0YEjNl85HQItGyx75nWgVNRxNpGAQVLB4rUTiT +WDNpdqGWtion4kGCgYICabTxsC4mtMRZI/TGXjT+jgA45jQYDJ80edozeouNGJhFUYQIPhrnJUUO +DyXFOXLx9sWZ7cWyPz5/rQzNTM2QarKwRyqykhmCqTH6IVgfAtaLWVdG69V6/wDtMQR2FqEKl8/e +PUFOJa42B1mxH+ka4rRT+R+JSKVNgVk1eUZwpYMNzIw1oTjridxIMF9w6oGAiH8Y48/UHqI6exMH +c8MGxjUM4ivD2hGP2iiUwDEBj11lYSNNdBBNMdRD7kQSb+dAV+kwrdwHYsMsQ1J3IeRoWn+DefSW +2UFjsei1kaBlj5atASp0P6+NJuEoHAXCURxV1rVZ4VmDoGsgeHgFoZpU7I6tz55RrQd2YQL7oluS +q2l9XfEBeO+BD5hkIOv1OcwhwdWAjU7IS73ECb+R1CqD9e7+tZ3C3BT0RszMyeJEfKp23ECrKy2G +tHRqKnf1rk2vurbnBeFCo73o6aLiVLSDKYM8YMSh+8NCdgYJPRE0CpaOXVCqHm1x7qrmgZqA94HS +tzGTRJSF/lLcYK6mqZsgG4aZbV6XIodg6TFRkPU37ZAR88gUSMyhNhMnXI/8mt7SzB95LzPUMsnS +0PswunIJMOUR9azJMGfu2lIiZJBZkibuARd2W3xdKG8QDdCLXrK9bdpF3BGKRT5Oi6Ub283gqP9N +cbdVe4nejoF4l2YbgoaJ1WeytAFnuxh02osFIHGk9/6+fu87puwRXlxRC8ISV1MLMgdcRCXWpGq5 +qKJyy2NqIrnauYbY1u/WEOw4LJHM52PYMod6CloGU09jy6jWVkHL8OrV1DLNekW2zHdVIW+YeL0/ +Gjmg3mLtS69t1VYsqXf6eYnmnBxE0iIZWGJizf23aj3d0Nx/keXefExCIRq9WLyc9m2yRH9xffDZ +xFRUM3Ta0TKARHLqDIRid6CCtFH6nDpZlpv/8Xv1t5vqphjotbw37UDfn9lmkHyDTGRoO9LgNiuf +aBIMLx7JXHpBvUhuwB77n7kBDVNKQmSAzE/cD5YI814Zcq6ZVmGsdZAQyZU3doLC7YlLEGBFFzn4 +xAC1qUWlMCiBxlUoCdOsPWyFuEE82HGbtBAd02Ob0esvXsDIqGbqKiPxOpPkJGNaQWaZYyZGa5m7 +YiL8lKnxaUgGHzJca/TNWN31EtYrRm3CT61kxQ9ZIQN9n6jV8e2oShNfg8tNT1evZubIXjihR/72 +TARlJcMec4c5WrOZmk1YgbyKxhUjMySCFjD3IRiGAXFKQghIyMj79I4JFi2fhFv0BDIRnDSFFIyg +//TtyJyK0IS1y6RpmIsJkiJBWCOJoJUMmGJ0wxuLzuVhpzY8iSnSZidZJSfJCEl+NQhWUzAGHOhO +UjoyDgCMrCceTrs2QNBAeLUE5mK2+/gYE2ZQqgoM8tpz72F8Yjwk1NGI5gaFjxrzqEPaxRlLg8At +iW6WJJEucXJ6JSXnaEeIpfFXS85DrPReQq57n35xxOt1VDQZcy3YBI05Jyruwd1xUI9IsoZxw+t0 +G9cxFTLkIEhKzxJBGeisBJcjbK3Nq4bLiy+zecZQgG6c6bvGnTAez4ZBoFAO4ySOqPqiXgilZAIc +mFuXiTqZHG/LgAqmpcXyConVikt7smDcndaXiRZqvPowfLfncY1jj9DLR1HDhdxq9aUaQ0KIMV4M +lJ7iiP7O70fvC8GrEFlAB/Y/7PtxFxCyNhD+b+L7fVJ6tYfWyGeQX21taT8qoxpGVEPKAK+gX7A3 +kigZUguoBLQBTWWio/sE6wWEH3IOkT9yV0g/Pv+3T6rMySnSglufYZkgBMYIF0abbhKCClmKwMFe +jIaSF4SCpCPaEFLeqMXc2E2EMYGpdKQEEHiZInimE11c7ozTYW0sKqv0ckWB14MnsAQGUf80+Be9 +iNDyJM2DGB41Bd4Z7MFbhyAqioYHIdVnPJmJkqNAxwzYVDKxHcIDJrkf5W5JSSv6pWRWp4Fx9pZt +L1FjB3Viq7ExjQlBJURuMo5HXhHMaqZFNcVS82JSXEu/tg2GHppFqUh3g9xFSCakLQm9pS8PN8AJ +eLxl9oHGqNH7BJjRloHhoXZijVC59vLOzwRZ/NiNKz3QonITx8pIqDPv0QVtC0/rpmUQiKmiIEP8 +Z88osWb4wIOhbHaCnyZcLR98umdoYhyYz3Jt6hhNL7E3mhGQbmX6Ic9oLpCBefDpqlxdRoxEJsBh +AM8auUyb5cgMqowSgLRCA3VcyJRRJAEvfQIzXdCZ2XjlolncdlAUtID82gdDlWAEAFWJyZsD6hfQ +Aek5QQifYrxeMxCikjCHcUekiwdQF2NJ9cSKXxB6j3SlmgjoRdTeHbFqjLz3z6nnk0oNNre4AJw3 +TZcLAbdx/jYs8DCvrCft0Q3oKrMVLKlzymVJRCbd0lQIiY5ul3ZHfxRfmQhAu2buI7CRuZ+lXEIM +IWt2WHufepO2fan3+vo71ZSiHZua2jTDW9Oq1VlqaF4z2Q3dbNZLQ3/X1l1Lx+v1u8IBqj1Q843o +cDmjNq4UIfjy/fPfXr+9vrq7fklOW3BWV+cUZUpRCLFbZoUlsmWWmL215NqU0b30TZSMhCBWybVp +Sm3yaTP/Oi0VEHsh8DJp9Fo+bZ4lrn3L5TvrNp82RV+5DLL9JAuzzqeN6wRoycTTk+RlXsmnTR2C +jmrqEATCtfm0meEeD6PWQ6CVbfNpS1cYxt4L2luv59NG18TBhEczofbc5tPGPvVR23UabcPE7NO0 +nj2brzmQZBMh5WhvqfJnm2HwENw6bbYhHIzz3GM5Dno9fbaRLL3QTCFaUiNr02fT/kCIPrY/My33 +bfpsM9GDPBVZsw16IzoSQdOCuKqzZvO+kIE73pcicZsUG0qoQMtYmYNY9PW02Rw9qsy4D9N3923a +bD7J34fQdN1mzTbMEyIjRS2LY7mWPtsMgWD1hDVNbfZsSWIvqrFjBpGV7NkPb71HaXgPpxl+pL7n +02gzJQDf1YQs2oZmSM0A6BF3kOTPQ4dNQ4vMFJI/G+ZSpwkMZO8Z2QduRAI5z/24ZNFm4AmVLFH2 +iPTE60PiliABdnKaCfimmdJQBnjc08autxILAzFIxBPikYn9pCuWtENUIcmibWgAJd4bEr/Pog0i +ZFnXzlKreuS79RINgR1PzN+SRhtLzDIFwv77fDlCYbg4uSA0C1DEPNogEIR8m/8eit73lEj7x6+0 +w8gYz/8ogAhRXyrtMPyG2VUYfoOLdVtyxzDai7IXZWo99W3JHYmM0WWlHcaseHAONVzB4FYldxju +ImyPzGXigbrkDqOsBF86MJCarD0ruSNBMb02EhQzmJWaO+w4bVeMYQbRndZr7tAIa0iJrdR6Hdua +O2fHL9bcIQn1J0DuIEh3reYObaXetEa7iphpq5o7hjoOtiLD6aCRDW3RHSKeCC92DCsYGRC8VnTH +SEwukVxgqYbVUOqiO0ZwIwweI02lUbkqukPglB8UqGQdFtJq0R2pFyP2RL4qAwLrojsSVaVpVQU7 +1+PYVsthXBhnkAVfZindslZ0R1apVLiZDKWvtfvMEjXOM6BrjqnqDufXkhOuGS75dD9zE4sQ6bbY +DuFyEsJd19jR4nZhSB6GwIVoyKbGDiUjeSomzUmYWVViRxM0axiwM+pRultV2EG3xO3qiAcw45kK +O0S40zTaVNihAGcZtTZYCatsK+xwH1oxHYN/2TBpTYUdvh1DAJrKOrQ8gzCOtDwzoqitrPPg9ogK +BjvvlzdUHNKiVVcMIyJYN6fxwDCUgVZhQvINM+A0HhiOJQ3tjnVgrYAhFw8MtQIfljSR5raRvYxl +gJ4tcTTW9q0nRgJtOvFmGFrk1j0xIFYQ/WjKwKuZqW89MSLME0FNYX6WVVl5YihYWwlJmllnaCo8 +MUKG5S1n21FvqR0xvL+4RweKsUPrh2GwgpYXAUvSrDO45ofRUYYdCB9jMGnth/HRaDZEo4UJLfww +mvAL8DnMCKiA1et+GIkDkSdRrOLUVH4YWf4MxAFdZCHh1g/DB4lSAXXByIi1fhgfHc1xGcicXfLD +UBVkxgyqgowyTH4Ybm+/ORl4atb9MGRMM/nQwAI2s239MIzfYcoPbOleAgYaP8zDW+M7+2Ee541+ +jBfGOw264DQwq04DnChpNSk8ktOsO2GKK7kONs8wkYbR2CzhhmX9nR5mWUIO720kDscNXnB9jAPm +O77aiv/lB3q1H8D58nk4/H8Q38uZajZ69pBn7FSsEePWq9mIUNMLqpwu26HNfGkEO9eRJICE+Iyb +wulEEqNuDVLPNFpFhk3ScIrPMQsn5ThmRXJ0AIFdpbydZOGUcxzr7BLIlWf7bK6KOUIpPHqaAgGm +czplFSXN6uQKLNPeDUUuUt7OS/8QDZiDJuYvpUAg3NAKw12K2IiIQ75EqZAxX3meVDJtmxWv4Uh5 +QRMkj7mrQxZWke9ouqKRdGbkX5a6VUS7kQYYCSozKd8r6TXEv8EXnNQpQSwNVuC1tMH9/+y9S7Im +y3GdOwLMYTcpmVUp45mZTeHMQDKjGZuyavB2IHVEjF/+LY/4H+GxsYtHBRCXoijCiNr55zPCn8vX +YtbzjVVWroTKsKgMnF5bXLQWk3qNrWpI+6lmw/e3EIA6eKuYi1fGW5IOgF2wBCRqYIMm144XRQUx +kgXUTzUbxuo9QrQ3ejPht2PjVdCjm7FTlweTL1e7yGXAl13XU8yGWRAfNH3yBBPKEnPe5A/FNZbE +Lozfk+bSYB/2mLR5TFquPXVxcKiT+Rhn6VmbOSwaVpMrOen/oGKXBfd6Y1jmHuiFiBILncfJy0wM +4cEK/M5mdyaTs8KcBruAGU0V2XZE0NQOmUm+oYJjEnvySFNTpW9l57XFn5981dwJ3A== + + + FkQBVeTgL3zVPJzWpUUCV35yWWM59G5ZEQcz1oMWO/zhlUM7/tETSybO4eWhxlrZqvPfoTVR2HfC +HVreuLz1QRIjlJYswg8zGcAZOmZPTarw+d9fecXnv00ScqXKBy/XFgQ8JJO2nFvj2gzDX8zhvZKd +8+r8C6Nwmp8CNnA83IpoLQM9aNM5p7oGl4vmjM2vwE3xQsQuXgl6h2jUXlCnD/p2MiCN21vk1UTq +NAjfWWG+iLLwtG9KNiqzi+2hImXYJ7c8sWNRIgcLRH5XsuELkaCbRzhdGGvQ2OvOqdFz50zZTuJ7 +JoqKtuSJiXhjy2euySNxMHwpPTj2Mf1KXFnhOpuT8me6w7KliX5lfWPyl78wE3HTrzgsSp/8/xhZ +5XP2/Q625lQMICGiO8QMfYMF51VnADeAWqz9iqjuKW1DMErZY8oYEKJrOrRSa9KaeGgfcMOK1BmO +pXUx9BK4cjvwmRasSkl2CCzwulBOttel7sWbGgMfWlWDId0gQhFAqDBnsX6m2APbEtf5qgzBmoOo +jzVn7/qpX8MlNVBul+wwvk4FijzUiu3zHIme7Ktshbs1EnPcWnuKXYhkB+limH6IvKY8huJ+upLc +re3HV00NdUa0ja5M320KcZAcQm9CckhoMYU71Me41OAwW3e/C9nQgwDMpvydBGOKhCQwiZV4BjFi +mohDVgSCDWV8pEuUfV/FSLTFlQaZqyLFHwomOpv+nVktsc654gk2Vvw0Fo1a3tReVFKUVB/M51uW +hXzL0FUJqfJUYkmyDIrPAUmfb/otSQ0tZuAAvbnAFMwzzmdyOp+JLaWHSkz4w6u2TPij37Y6Ot2J +JWrTcJLr17hUex9S7f0ecjf0drwsAIkEnZp5vG1WUMNMBp5iYvTzr//8dk/rHx9PYjHOnbnZktxC +jEfHIIEWgo4OiOL7+xq7rltycZan3g2gjgvqyS46rKfejUZg6AZRg0rl9UvC9qNzQVhBoW5+feAn ++gNVS255LBdYBghsYBkwB/G2xOxkEC1xMuKr58LkqCs/VzDRmB4bMrI7LeveCZ0emwSWah18Mo5S +H5sK0jEzaoSxiRDvdScyxQ0Ibu5aec37sbupvjFM8moKruIfeNoNYAzwkwFjsLfxVK4RGOCWBjAd +1/vdPnFXfDkxIZ8PW3ZL/vWpV6MoiYLmq9QXuwfrOnXBLCYqT/kwXHJ/UxrDr6uOMFXJ7DXeTxN/ +HnI370pn/o4esmj0uv2/u34antou8qax1r7D5Tm91ym+pfvh5RScXm8e8RZF1cN5phklnwyG5vp0 +t0ynUn8220g3+001hixNxWnnWHqoxiRGKDRmYd62vmnG3JBvaFzXIwefhHyGGLqv8z0csa9sTk1g +lSqxvxHDpK75/UH52p9BT84i9GFjnC4f9hIqMcQAW/GMqwjOMfy2UW1V5Gcktv7hLWxb//iI8Yg0 +CHawbuaIn8GgrQAlLySMWLe3EJIZ46fsC+9Vdp3OPqXnT//9NaZd//iIhAHXwL0OhREjWI/YGRqk +jirvQdulvwfcuXgzA2azdFzPX4HqoLjbhZp+CewHZ9E+HcjVS8+QngK6fGQTTClrrRx0Vs9n/nG0 +8XkL+f67Low2eNIGF4Dokerw+ultYa+pwT6SI1Bqsq83aItP5EG5GcgsAe2ojzczM6J0GHtn5kYa +SC38Nc2zD0rDYmaCt7iq0swYyS7l+U9Yg4G57NJNj3rrI0llxOAA4uvJ7CUmzfyW+FrOqOs8NF5I +9I/8lHapbgRec+9GWZXoYwq5nN81hP9QpbWsQYRbr8q1ILsQ+Rwqt52mS34UFLTOz7eag5nwzJec +BYqzCt70UOOtcGSeb1WPE5qz2h8lEmhlKdPMWopFdsSlr3WXechTadgc9/2s5ugZrvquX2x3gpWb +5SF7CH3OUFDCLqpXegJia59IqVClZmUGihHurZancAri8+T7b3opXDE9ZVIABG3oUYqANp+QqzBO +UIFVrtws8k9TAIWqqPo1O92TDoXlWTZyJzTOev5E5SQxF3dF4hrlTwK5LZw3xxu87XHY1C6Z5wuS +JfMudkolj3tf6H8eD7zTJRmvJqqRzHe5shY9vsBWe2R8tqg44p83Co2MtbBlahrrJvA8PRbaShEV +1+mOauqxzANT1dgPkeRqbJ49R9bYaYFia27JwM41tu+W2+vxo8EINk1B5BAbdmNLQTZsTCAwm7Yo +cJ8Nu/XGl+aWLZKsDQv4YGUbVnIr7DEsaiCCm6Y3yngMO71X7xhGPdDVTes/Ce6mh9ix4k1nMqn0 +prNZufeiq9pR+E3/FhgAhx8M3IHTZ26pB6eDDcyFwSUH9sPo2l/IE0NAECgX11AisDaGQGTL/hji +mMAiGUKgSUD5CJx2XJUh3AqclyFSC7yZIdDb8m+GOHFzniXEDEygmyM2jKKboxZm0hkQb/6whNFb +ZtQQhQeC1RDAr9Ss8YAdw2s8amWKnflGIJkNWcqWrDYkOYH0NqRHgTh35FQ71t2ZfgXO3pmnBZbf +JbfbSmyEvHBSDYdsciuxEZLRSXQ8ktZAiDzy2y2d8syFHxzMnilH0uaRVu85n0cO/mSK9hw9UEqP +fH5PSO2pf1TDmCWCwIQ9yglv/Nmj4BBIt2dhYuXrflQxdnTfj5LHIAlfSyMru3ioq2xJykNZJpCd +z0JO4EmfVZ8dy/ooEAVi9llICpzuofy05YYPxavAMT/LXZOVPtTGtpz2s6IWKPFDDW5l1V8LeDtq +/lD8Wwn+Y9lwEQZYK45bUYFQrwyaBKHUOeUMQoF0q4EQyqtBSyGWbVc9hnjETtchHrU+cCgoRyDa +UojeKlWEOnY4TSiOhzsJR2yfKBwV3sxat49vdy37f/KVlq7B4yMvbYa4PNYWxX6ZhQ7HuljX1khY +7mtjZbtp1rZM2HlrQydu3rUftN/7SzfpYTnW7lO0NUvvam+y1s5XMH2haRasZui57Uxu6NgFgx2a +fcHWzxbh3lWsjcXgcWYncnio2Lbc+bXY9VzdYuyXrh41dFtf3fCjNbv67NDMDe4+9IK3wUJoJYdQ +I3ShZ3ASetfbkCZ0vkNEFJrmI4RaG+3bsCu06UPQFjr8M8oLuICtnEVAFTxizBWLsJWzCFCGGOiu +KIgQIwcQxS7CDgiMEJ4H8EYM8Vfsxz5VWKEjMeUYYJOYpMw/bHOc+cc1Q1pxLzHJWmEz+2RtBd3E +pG+F6/zMEbu8Mx615q8LzCimwCtIaZ9KrxineJ4VHhXT+gCz2pYHVpTWo6iw4rpiPWKFhe3rGiuq +LNZHVkBaLLGsuLbXAs3AwIWyTkDNxdLQwNptC0oBoRfqUSu0LxSyIkJwVwcLAMO1nBaQibP+FvCM +u6JdQEPOSl/AT4ba4Iq+3FYWV+hmqEsG0GcoaQbM6K4gGgCns4o6kamh3BrwrC812gCCDXXdgJ8N +JeEAv90WlAN6N9SjA/B3VrADXHhb944/X6vmE58c6uwB1bwt0wdQdKjyR2D12iCIAO1df4EsheFJ +O4/Zd7GULn0KPSyBMQ9bN7rpCqz0YQ/GUvK+P5LFN8ucNwpO10bJIqurqFkCs4s1NmYyLUZ4LsD+ +09bftnWYmxfDSoH9+y6xK6RA8iScMxsvn7I2lIijPGRFwOfctKNmwKde1dLD0oyQ2u4b6QqekhPb +7TXRYoS+WVZd63402DJpUcJMsszLu2LF4+C1aRevs/b7Hre5E6h4PNvaW4yvZqdLEV6xtzPjt1m7 +n/Eb75qnYamsrdew2mavNizW18buutRnEzhukrVr/PU0BLe9ClNgqFSLgKve4R1P+iletMfs1ZL6 +thGmYHoQLnimB5OUnle2eD5DlidKotrYs85TEinYfWj5lCCH89QkMUYLWqTvFBnwszy9LbRyqkX6 +ukTjjxfy/XgDK4F/fJCdEEB8IeE84aWuogSffpPnB9T4y1DO2wpVPP+46ETEapQrTIR/3+pTfP5r +V1+n1JNoxW+uG47YaDnEo1ZNCPxcyToCPa4r6krEe9zpUxDxnpfIxxPa2LvzjFcYb+GTF//j7fsA +v2r3uyIFYsLO17aqlFxoZG+WnSjWU/pEdoKFcl4b1QrS3PPeiEx0lyB449l6HLxqSszTB5WYeVN7 +kZnxKOsfHw+/WpH1Ta3rfF0TL5oR4Y9TyyGsgqn+EP7wqhnxF37l3/x5+rEGXjQYHv82BBs2S8wl +HuJeexGG2Czw+av1PTyu88kLmuuRakLP73oQVEK8OkAb+3quiCSu1VPp99nbhtOdlL7L1R4EwW3P +DU+2nchTUAhXnrJSyxN9e65qbj73O9LTk82mARIMURblUSdiuuHc2OhAiK+I1EWJF69w5dn39O72 +9K5cn+hAxAdeef+5kgjLAANIa2+VDPDUHbWCg/JU3UsPcD8636pcQBTvvHt27Xpu1A8gVVJH1zL1 +pJLWTkWBoxDMu8mpoRwKIgyK81Xbd63eqN8Ql+9OB4Kj1BUEQdHrRgeCN6BSYa92K+ne3QtlMFRV +qsXqA14VnwlktwgRKh2LzatBR7n62/Qrh9cLXkKvBQ6/+okwBEepaqyvnjcfuQBa5H6bZN7jOoFi +gHI2KdMn6hA6a9us1VKceKBDOJrTZr1nwmnuz6yBqAm2+8beoTjvUOsE6xi3nd226k723SAT3mzd +9UG3FoDznnq6fPayMSTism+Dy76+2CDm59UxhtOoPrWQJk5g/6v1eitjfLjrHfF8fPiVwD6+wJUD +P36IXQoRP+jKyT+Xwsrmvy6jnSZAeNhVWiCs5lWdIGyKV3GDsKemEkLYjauGQtzUOy2GYBymlEOw +K1P8IZilF8WIYNQeP1rt4eMywZxu7zKY5fC0w6I/Xs/qB95eanAj4ZsEVxQ+a3Bp29URXGNYY8G9 +htU5vfN2cQfnHjZJCBDCRgsPu92wIWAJ+/7TWGcJjDAv/9YCEZa+at/ySBm10P8QiPjXCET89Ym6 +WfbnCbvtZdHFuYTVvEqsX6OQVvokOqZOLU4a8FY+2bNQJDs7Kt4AyEf9hLE7iUISjKLth35tGLuT +0rkU2Z5FE0T/335q7+adK1qUnE1WA9bBDVG3Oji9T2pqQA/azjBpCjy94bXmN6pamYU5vYfzzo5N +siMCL237DT13jDVf6LlJsMSWZaab9tru52W89nKeIpULN1CdIKsXi49oMG8fowxfV6Rs83wH9BPk +hm1R5Hvz0ijrFneGlcb+2zunKqVMjwJ723wxsQYRmFUZ4c3HrvAXsxyq2fzyCT93AnBEt8bOYUtt +w8+tLuHNaxgkYnPZQgYG36CAI+ldlHLzo4WbOF545TeOD7DjSY4vYuVbDu9ypWyOX2JH/Ry/6MIg +HZfCSkIdV9SOzDouzJUUOy7ulVg77o0dQXfYYvE06yaNt7Lu9f0jDQMR3kiwLetLDZZp+22mYQuf +NtjEsDqCbd2usmCjw2qN1n1d8Z85h1nT+ivSckf1lwZuD1bilsStvddGcvJlO8pCYA== + + + i0U22khnYXS62xGWbqJ6ELSRmImD7jir1TPmBadI0mkfzqKMG7Bmvq6NShJAh4umjEWvyNtGlSSF +zZyjAuCYYnKrSlJnOD9vxJE6WAIaABbhkBtGcaR++xOUhCb1kPELKknAsUm5Ye+3fblRSWqnN/IK +ULZrp5LUWCJ0jihPtM9Uktq8UoN/sm9UkoiOcRf2dU/oEaNKUgcn2GGlzpkXrysFlSTicAuNbl7N +yWhlkEmC4swWsV0JZEbZyCTBzQ02qHQzB1OxMwglAYOkIlwsoaSlEBWTSDood1iGRPllI50Eip6y +sb199aV1paCdxHmamQTOc8PYH7STBKwXYzdvuG20k9bd89sf/u+0k8SWnA9nS4awU/is9hekk5yz +LzHUfthzRKGf8Jut0s9524e4AQiB2EifKCdxe4eDsSytVgH5913vGwhBkS3Yv0jP4TPpJBH3YeAP +VEDLRhnqZx8QUI4ZduZvzRztpZN+2QNC3Q3FtnyoJea/jlH7syXy67Oxf/hW3ItafvVf/rv9+n/+ +88c//PGP//XHj3/503/7X//7f3Dw31xj6W9Ott0sHKfEdJnZOolVCkUOgMgZedPsHtOyCoAIRYGH +WYtsRuZAY5VCc7sE/b3AsJY8yjXpgiD11hEUcS9UACgmFirCYPcslGhmj9x8WZisC2Rn4sBFSz0W +70oTWVdmCM+ujIG3IzSXjjnDNt5235dLM2QLR8ZIARYNnISdhmExO0tyWHqGJxbqC0qEMpuIbFqY +VSwsUkXcvKlIP/5Rp7GQ9wTgbK4di1sYK8C4ZkufOzJFX73FSb3dknPnIoxit3lJuKIzE1SquYE8 +1Bvt/IB+LzA+uSX5sQ5sqNiLkPpxOoViw2skWv84bxBDOO+zQfZRhzE/7VUB6jiZWMDJWUA2CVDa +QLODYSu6HUa2kgUYxSFfdh5u5RSBPAGq37AlLdwwztqO6OPtwFYKkgBCkTwGcFWR7vzcvFd2KYwC +ANV8bZY8FHNEMIl2isDZb0FigvCNE6BQvr3RRSFMk5tOTvz821yaRFIWzF5vvx7BAqW2QjgB0o2a +mArCcEtRfNbKBD8sJ79xd9yFf1lMJ0+HJomCF9IsrSEmhiye6SxYpr86g7VFAs+CkVIaFUgLnLNC +OKiyHVuLe9enbvCOE2pewIOJ9EjDCBE6cOlMqOGaPvlmTixDpCzzpWDUQwSyw8vW+UH20ACpmWcf +yHUFNcAnAazbm7+zcNJJCtWKDJhGSsAvLuC9NK3NJ9x6Evto6PgqawKLwkQ6eKksWYHxKBbogyO6 +gNeD/0ECGrSvhZe2S+1NUWG1PJjOud1J15o8iaCADYEj/np7PDvje0rUDjrRdvtlAQP8IB/2Ub5b +0sWcSEEgxGXlGkhu+89CeMwbg6aFt2dRWRWNF98KZBHwKYC29uQ0m+2kqOAUO+AS9uHyLQZdW3Wx +GpB/bQ7FK8o2i5Dvrv5XIX2+NFmXM2jk3j2TREKggRnkQlB5tKrxbAt0O7o15lxsYXTYookFx8j9 ++ttyeQxvVuImr+jd9V+IxBNAM7N71Af1fDIgrEZbj7KNiWyW4n96sFs0VT+4gLkTt++Zm77Egs9c +vxC9FkJ+p8lvD58Ta71Dtn3b/RfGxy1jttdqeQL81hkg3Ti/8ir7DugGYf+hwUbNI0HJDXsr2g12 +HU0L2He1Cw3lHLoVlsf284RGB9tC8RviK7twSwOIkQWStuf7zj4w3wBtDGATn8VAVogZinIM02Jb +sAJG7mDV4HVFT/vk6c3d1uGtOsOhbAezEkwJ6igkpe0Dm3HLCJDY7hOdB8TkOCWg/qBcEHvCqJWi +pWSvHeQh6ldKqs/BGXO75nVB0ZrXXhiAAjjPnoWuk6ECJKQZuSMEKPRhbKt2Gmb64HCfwyIIOLHa +xz+kxD2JXNq4UY3bsbgqnB92gaOeNMvs8m7VLEfrTr3FmPvB3kYi2z5NrW73WZ0Z5hyUeeT7CVTa +oNiqXYB9uxLgjOL7CB+cGBcQvqdoHO8Cy5jZi40meGahm/3hYcEKsXdYdVLo6MxfTJnsW82Pi+g3 +wYfbul/ATFcWVOdUC/pCTeImlrCVmLE6ao7A9gKtWKonjVn7bF3PStxxQ4N95TlCXNV1vWhE2e63 +o5ivYUOaUzPD+dHhC7DrJ3f9FhsII4Q+mSuGN+quGBteNlC8U0UmP730021v2/s3X5xlKRhe44VT +b7Pz9KG5hjABpi2PAR80+0h3uUXmEi4OaPHvWlvmrrVhaiKiOHdnufyT1UQ+y4c9zUfZizaTL1MU +jwD4bMsPzYxjtJE2B1Gts3yfkckLerHTpf4Q5dn81Z6lgAG19Lnz1S4vKyQmG8vj29u+lNljIupm +bJBswRahhM0uCMpBfRVR6B2IzGE96+YIYQkYpDldWUjPEI6y7SrPKu0wMa6BT+XjJlCuI0bup57O +xdkBYF9JhskWtS1dKP7HR7e1r5WHjBkoq6LBOMY1zEwS+SHlToB9wX7ClFsRqBX3zSY3i9SrRvXt +CEaf2GEEdXobF57Md+EAb3FTOFsExGRfaxLa1n5s8cDJEQeMe4S2tcMsh0HRskeB44Sr0gLtxtZk +RrxMlitGUxheNGeJEIod1eCIIhynlGhXonJvASicgLZXb13pZoATyJaFroNd6Nb0t/kDeOZst1S8 +TPantLepp6y8B6RQmEHK2cfsMImHLFbNqGnpCH1z8Pt5zIBiom2F4DItmsMvHWhDndxoJS6Ry8FD +XVk4bvuizOVTkoHxjEEdfA7zauZzSN2LQipbl/YoFnb3+W1Pak88it2oLlCF+rCfZ9WjmbM6RSou +YLYFnpmpZDMQvYu3yx7W/PNJeZCRHbOfHNEm6RkuXO38TLUd2N1doAQrfMmCT+/XISEdNHBYPorb +mIclbrOkKSuKUaVLklvmR/IJTz/w3kPaWX6h83uVExZ0oChG7coDr6Z5CYufvdBl7/zQVOzFcB5+ +E9+W/eswJIX6H2exIy4vY2WMyl2G40OkhrgMRDdc71IvVVmV6SFzoEVspf3S+A6DBMiB0u7Kqt26 +vVfIVckyr+4fgEXPvJZFuYNV4hKbgF3JPgqDDWLWq7pRkFEsI3sHVUtRUXu2nUwGRPCD2hFhuL4a +y29QO3rYw0si7FGwbokZFUhbg42GXJcykV3eQocienZuj9oi66PIHWXh5vWIqvhxB6QcQLpIXfSq +sBSyL42RcA/6hXbPzKWmSxqdlOYvpAdZx5Zku2NClYjQ06IeP4VYCrpCTK1juaE0JYCbBrUudY5u +7MsNgRUaNqdYIg/RVlxV6wwTwpRluqDVs/fIEcVzHPuOl2ykhUUqAIOjwCX7A516rQy8am0RNF+n +n5/81ZMHPoRK5h2dLzEzVx+OBCDQhr4Ql2SGiEtaHHWqPs/nRUNVH4+hVNYVRREIvpkmRua8kogS +A5hvGaayiBDP30VRtYxagVA0BI5eEam2XYrfFape9v5slZJV3pa6K662UEPPE464qk+PIs92jNmP +eNT6mGjG3odZU2AeABZil2HVr6UorDDSQhdbzfP7Jo/lLb89qfDHZkUWldTVMOWwFYRbCUfsHike +tb4aJHnpX9mtkCKX+HpRIVbTplEDUClm+5nW5kn43FRDGLJrDQPwsj4Y/s2StT1vprZ3q6sxqKfz +gxRJm8XZUEDVEUS9m1XNDShOb4zw53O/J3Sho+lC5og3e4uvlylxNYYN2rXuTosdxiu1REi1q+0e +vyC8KCRDnYnUaCtoF/l51MdJG3PTmBy1JzKzQja2N1utOj3AZdkWsKdo/lQyuuGaOO3ByhlNaJNg +HFU7Iqla96aYypCCYfzGzo43pqqFVGBcUp7aXQBNmaQheIsUQJRtPYiel6XI854419UTUaOkF33R +V2aWMngz7vEgDLE8/QA/u/WKdg+u6bY61QaJg700W8EMKbbomBvqaZYYs8Y1hrzz741YzdbeZS/8 +0PTbGiZYvOeC0CcvHLqKNdTgHml8QYTR/YhNyNIAuCFobkbBLNMZQx9Kn6xkOwIEQonhE1Ukhz8n +McDuoy/OkyUIeUCOUmIU10gcVSG8kPKrMRLk69AOZwUlWPa2ESWNtZZ4cr6q+MSXyLTNZN3eOtSA +MbqlNoeg1kWRoZPtrMGxr7jTC4pm31j8MchuDKs75dlFrTcG63/WHVeRj1A7J9aKQT+7lALMxcy4 +JQ0xcfCnPv2pGejfZB1ssAu+F5LHVDe5Cw1SDXQ63UCL+Q+G1N4I1U98QN2mUY2iMhwuNKALqflI +whrVB0KgTk07p5i/xSN2eWA8as0nqdKCrqEhLMcRclIsvjfcacizmjYZLY8riXdMKh2KNS1mDaiO ++Om/x0z88bc1j8fQMTdDA0fidaEWwAcCa0wH+2QdbmsK3DUu2e76ANW7OQ8UErnhhoD6b6obIA0O +zD5IA1TEtlUSy1UH2qCdamuHagsFdW0BBMMh6QhlmgaJOosOVhLQN9tyD+9GDSYzeiBwY9koYADW +ypMq94oluqiT9gUsXjEJDXuA9kEof9Fg8NLxUjlr4MhtQ+JL7c19UoFrCMXLitVO3ShW8jiPfWPa +ZHYGvP9aDcSuKILvBwxZ+6JiG7n7LEXSXDvN19JcO05tiaWK2Wjv26o0A2s/rGVfDW0g+nR79B9i +TbVBFMGXEvseqeUox9K1LrB0AIQokijYVHMrY57IvUMEeegCSzG4HTQf0dLNNB839WQcMSeGqSKr +MvcsQtPTINAyT8Rqv0IJG6cIsw2qghi2WAX3kOjsHhJdbV9MpydoyQ6UPUnzDKEoT7vP27UUfluZ +5Xzcu6a9zwMGo20rgIaiL4ETAqP26CRwUrYOJy0M64YmBL04ZfUdyEFpu1ZGPIu3QfDj5kp5Od38 +QYoNFN49shHb/gsvH4T+2r1R11Fbx750z5sGEEazaHcTa9PSXRtJftunVJ3hX2PmupwDV3rg5/Tp +kkfWKvlrb9EELOh8mj2yl8Nw/2EPftqWBxvI5uuDEKeKaBRon/llyFf4YybGRSUUCnZ7FXbfFn0Q +5BHgFXjiLWi9ae0A4Kx0SGjBnGRjrO9Ov4/pf5kltxL18pDEzpOzb/HmxAkHFHWEywo2mwebSU/S +PTXC3NGsI6KC4YTMGEYVvbJKOnPAUzHjZub2MRpmEoD960pabnYlIQIaI9WU2E8ALbS++Dj4ZPs4 +wJecQx1+KljPcTHw8PBcUgaAqxcAWz2d7A6CtwyZUVE6RUkAKhdbuxXlDcsGLmZNYMmw+/pOtnAf +gje6K4jnUWeTMMzcB0wg8V6u0ye9DvOeDLfEZ7puib382L6S+/B80uJO99Th1VqIblEdFwAAq+Jp +/EIiP7vtUlgE+0LxKwNbxNIT4GaJnayrhSchmj1AE6SxWNZFR6WBqOM4HMYWFm5FXx0yxZteD3oh +67qvGnljHVyC2P2YVuF191RKVsAfYTnsxG/rBryqk1nY09lTtM0+FpFY5wgoLdNjHw== + + + v9sDOoT6gLAmXB/TkFh4Dl3aRaJgr6c/zE9lANCe4xKyYZ52tV4VZIctQ1SboS+M1pML9L4xmhXh +C1bQTdng7HuzWamiEfyI/gfBltVuV7ywfX37q/nMO1j/CnybLv1FP2EmbqvnqBDDYNtXp2MbXfWH +C6FiyGqD86q8scHofZZWH5nhmxOsDM9nS63paaSBDXjzoxWWHJCUls5RVQpeuGp879CTpmlSgzOv +gLMT6S9Znp12jQcss8IThWiiiqzeAj8aWLMytMYiHAR+ewliKjEScfcFDRNFtjUUqpqCupJro88S +2hpS8bbR/ZWevSIqj8FYLGaS2UzUkVOM4NACAdmNm7pmBLcGguxJe6GFPZmUyq7BpD25LUByajKW +K8egtBKUkq9TbQMb5UGpx7TaTifTJqeHGms0XA9GLABnA6Fom5jabJFKHocKXAO1E0JzLKGug7Ej +YlvDe1YlZRgnbxJUckkTeFQGYy4YB80ujCst6UYVrxnb1AzuIaD1krJUqD6bGEft5nimkPrczFDy +TOatZj6yZlB682boefPEiR8hC6uio7p48wVgc8zmwhE/RubzlhXG84yEkk8LlpgpD3Nw18sfuqA/ +l8+BvKehlcKLbYLrHhMvIemNR6y5s61+0dRqxiLX9vjqbzk4xlDuDrZWIoKQx1fxxBNrCxWZNkfI +M1xoBLAL7n09gN3KDDy7tdB8DCWJyr5ojB2YP8stFjawVrKkF7x7M3lbCyRYZ4rYyKhBHP0Riiwc +YWYK0aKTKC+Waip8fBfDOQeQi3GlteRTAU9SkVurRdUSamJQHETOPcWqU2XihqUJPNGM7OPzv1Wv +KpoeCTI8vYEWq2BcSe7TrtSY0lKUs1bTKh27KqgMKJLyESpyZke/yw7YBgebGyt7FY48b01CBDDu +eK0QcpQ8F5y4RBuhymhrU7kPwuaM0MdqZe3Urx7RwVuts7bLi6jCTFCBXOulHGEBNQ7MOYlC3ZUj +RLwKCKROOb21fluZTCAOuTRF8BFKwJVhC2IUW1sHrHyhkmw5gbgfuJRt2uHG14q0LVGVPCzc1nr7 +mMXsyvqX90z2I40fLLVw8wLfGfwgbAS2OXbeUlOvjEPIkyKHOPsQr3V5ey8afbmQvqAmFur7eu/3 +o2b51hSojElQiFzaCay6S0G7/ZqIPHQluO6V2aq5iUXoAYh97W5wHnoml4A/nGftkOjuGLdhVfCt +1kaLbgXQg2orU0hn6dcQccA0bE8tPvWP0POpMK8pLDXzrdB27R0pBGXjIwFofuTRP3zrQGH84dy4 +YGHLvO+1i1XLLSwyVpXoJnbDaoM3pCsOEGnwLDO+NtXs72Nt2X87y/kR+nKVf7BQ7jqlL5NCe88C +LPuFFrHFgfds7y3NwQrnJkZ97Svy5oXdtZxPN7C2JysB25S0XJqbxJXyTnY7h0Z01gZp7UnMlZcw +LeXeHHEmwampS6Q+C2bhqPUp155vRfWNxXye9uWpqa2tYxI6oGdExczKjUdaWtDhPKGNHW4lHrF7 +pHhUeDVraz6+3rXF//ZxBAtYv2eAEcyVMMEH2/UzEAth8Q2EQ1i2AR+xXf0BZxF30YrUCDsxID4+ +2dHvwJFgGAL2JBiXgGHZ2agAhVktXUDTBGM5sDhbUxuQPMFkBxDQNPYBQ/TiIQICKfiXgGIKPiqg +oba+LqCqgs8MyKzgbgPAa+u2A1AsuP8ANlsjiIBZ2wYiAfsWApoJmwuxUEDdvURSAbMX4rCA+wux +XMAPbmPCgEMMseWEMIawNCAgQ3j72w5JGcLkgMgM4fafdaMLsjOE7RMUOgP9ACTd5gkBkBryjQBq +DTlLwMZuc58ArV1TqIDODVlYPGKXzcWj1qxwAo1DQrmilLd56TvQOSS3ASj9E0fs8uvNUUt6HrDf +IbNfEOTb+kDAocezrFj2UKuImPhNycPx9KFcEoD4oeQSAP3b0k0YDAgloDhbsJaRHqMJuypUmGxY +i1lhOCKUw8KQxbaaFoY1QlUuDHyEyl4cHNlVCMPcSSg0htmVtUQZRmC2lc4wShMqpmEKZ5Za5+zO +rj67Dv6M2u4cFFprwWG6aFtSDkNKoTK9zjmF4nYYl9oWycPYVSi2h4GtWacP817bMn8YFwvNgjBy +FhoOYXBt27iI5xl9jzAxF1omYfJu23oJA3yhcxOHAJeeT5wl3LWO+qRwKLYavWO2tKD0rMTTPGvR +5lu6WMRf+rBQYRZtq9gM62SfRLdw0Ci8X3tqFn59J0azULjRHA5tuZMOCb0Nux1GLrfdPbMQllfY +AmQeNcUWoYJOKvwKOHjgtc3YkTdTeAufHniFpVvpH6iIvAc8LEI/senZL5fWsriaEdFHy1ThzX2K +u9EetYPNjR3XU5U3JMMOSnObrq3ZWNGMI8WgYtW2+xvPs3aR472snejwJGtD+8f2hayN8fhe1wa7 +ZmjC91kb9esXXlv9cZnsIANhta3Ig7BgA3ohrPtX8EPYNit0Iu68FX3x9TQwD7JKAnTUQi3CMysI +sdcV14VmiEnq5HTtD8RgrAuzmpny9nGSXpJE8RoVlNHWx7Zp6oZEVNjogwn/xx/02BdUs50sKivJ +e/zqOqW5XRC+4uFw0GBbdqv2eTCKE/bliaooesTTX8l1G45Cabht7m49wlfr+nDhPPEF3WMVoVTH +LMyXL/r5ef75DwPXb/kBSZ1IdkmbC89xQcOQnYFwc5Q5oHpvilq2gASYsMhfjntzRNdPVVb7iZ9L +F5js0eIfYBCPK4c/LDf+Yxah3o460XqzHWvfKRNtcQt31xHotXBEE9PzZaHxfWm+Zb1Je+m2HPHI +VDzToxZZqXJboOYtvnie9SXGe/nqY/x4/3i57jcSbZYi/Aa8G+DP1nXSEAknMDeTc2iuel1rtFka +neuTunj7ZM3aYpZCyIXAHyxo4Siz6N+rlzkP0sG4f8xcfT9PwQDstvIniKF4Gt+z8Q7G5o4P8GIS +4vPPX8VXt9ig7Vtfd9Wy7JgzoAr2p+0f7/x9u9BsOSkKQEgKLozdEbd+ut1Mm58v6+t55fUP435/ +7Da/GajvhPsWJFfL1vpHWPsW9yilIoy+NjZAIxMwchR4c0p7TIK97cRwlvBSw3188trntqHSQpzJ +aulH24QnfxpZv9dSEpQdZzxKNYqTNNQMdVOyKmXCi4oLhB6qZheyOjMD/Ez7wh1pAU8zXMoBRNKW +aEW8Jek0SQliyZRXOymLcnp8K6ALpsCowiSYZYvErI4LDOcu6rSzC6dV0VPLDjzTYNCRqTNWVRWO +Q/U0y5/ypSNEc39IOdQHGpV7WjQPAZziTkvzOEdPaT7G+rDM7ZSDugD5aNHrEK6ZzFselj4Hne3j +GE5UBQ6HowHJJpBPaQzUWerocAb6DicjxhpxgkQUCbLRiSDwu6o+PnWFJhzuPXr5ltNdB6EmU2my +hIlS0OxVXN6WpsqbgJwcWbUTygreuLuJJNWSO5qDyuw9oH5o7mrrCOFd6lJkNktVnk5CjdRGO5bq +13IWvqJewnr5ixJh/eTuYQOkAtxgRkrPZ2fmiCKZ+RYqEJu3BgJG/H8SIE37t89RTcCeTJXwjh+v +sfyvzXfnFk5YNxvLEjToZvk0qUyBhbP9yrsLq7Bdg7yq2a5mZGJdyOB9uvrP1QePNtsBOkSEh5mx +gqrnsZlgdoSFHTq2Ey7ndRs+Hm+3hwWkEbOhWqRntAWwATkuhdtpG3sCr5HaTlDWHXUDmnW4x5fn +CfdCleTCGzONAeR4PsrZxk1a6MEkoT/K+iIUoTCUAFiGJmZ4h7QWz80H2KU34TNK5BV1jk6D7SMu +BLozFJUPuILBI4b1JDluclQKGnU8x3xI2khM3FFo0dhBWMlQQTL8edDJyHFDkCCJlskSpCfiIGws +ddlOW263vdgyCDrftmQ/HNw5NzKkWooqhCI6HzOjbH/GPTSnkw5GRT+C2ShUJ5m6AJ5EHT+YH6D7 +YB3smv2469PDvhmxzXkWQxhvZbWn2wcJ1ng8fjTk65ubfmD74qMbWb5f9ETrEogObbeComNcV2J0 +rstiji56m/EHDz82VAgN1q0YH3W3pWOkslqEn4h2voyasE7/1hoHlaKarZVumQIlTLPTTfgKSUGY +j/gPjYO/RJQJFlwjcW3UJs07q06qlOWg3EXyJYo8Bucs0qbaykQp6eRRpWd3KY3Dc9ABRZ001Voa +Hpp9LR46+kync16oFMcat/830knEUTkAYvFeNZ3v49fHgeYtaSAlXvDiVSxddt8SwM7wfNNnv3HS +aJ20ecQxTpGa1Id/G3nrRWZ9otRKpRr68YzOsG1ResR303lVFadGy6inmPXMKh1MwlbAL2YjuRWy +fA2QOk8AGcyo/5PcouREcotYs2bVRMKcLGchPa7uOM1+maXwG/EJZACKDu8pwhHSRxKfUPs+J394 +WFB1PGz2YT/xGCYEUJKjkJgMBgNzQmKpq3cmFXvSQM99jCFXWuzjpPAlardfhyiw+WM9T0m01wPM +pAUKaKVeIgjA3SNLl4SmUEPgorkOQRUNcFGTwgs52ONBVDhwxVlXtZpEIppQ/aHNSomArh6B8aHR +tcsZNBDqSkKZnQMVCT9oiwf4g9jDamQGvAfOqtEtZG4FJkaQG2Ar+ci3YzKKJGwq7ui01XAJcaT3 +Y37k8dIvQE7enc/MiOMkpcZtTvI4wMQdyUFPTPI33Z7X2T/dZb/94Sd4oGsCpX5I5E70oU1sIKiK +gC6HRH/s8RfbxHAJSxsW/UEKnQvcDrbybN3Z260fJzrSzH4f9lkkHUzHEYLZbF5FmYnIUdE0P8zJ +Zwyu6MUryLADBnQMrgYuDhowtiacERrybqYai9rShxS1gF3dqrGLN//LazGZ2JHbRGoTLMo3Cx+A +cJgjk39tgw0a7PBNm44BZ/qeDKawQhrcKxmi/595MEHuiCpoflw8GDNeuYILslsZVNC/4sm+Ia/8 +3V5XSkT25baLyWMfZgFO4Gu/gAf6Ly+Kv5HD+kvkzj+/rv9tVXqAWCBVsa8aCadiIX+lrFi9iQDc +yo4qoLYsYmPehGoVJAc9KZ/0phZhIgS6Fl1nmFqxJiKRxNBiJnlHbQiPNVHvCDra4HH1vJTsSDXS +RHR95aKZyWyWqikVvRmD4acX+EDCRu6cHFimHYf5yJTpvh2KkZ0fVyktrAF2HsGhWLUex9vzHyoc +ldEQy7eGgcytgUgDxyq6du5R/EUHiIpJv8FpaDdBzg+sVpl/dSYmEehiX/rts53XNtG50eU4JOlh +H7o86iwkFPYHIEPl5eeHfwIwbNDFPC+YpFfIqZgW++x+j5H42dmPc/PYTK3SCmrm8CCfj2/OnAfS +d4KQn/WTD4B3oxRqEUg/d98RF6TBJOgg2v1cAuLDQaMtJYl971cQFg7MRsvkPGWzEvkZYxKWalBY +j6u5icaJNQhYlzhrVxPfnOd00uhD+wQurPVe0NiD5gZ1ssT8W3wmR76qJJ/aowj2/g== + + + RkiHCn1J2ySnikjLS7UwRJzMBziHXuOnsVRMCsgHY0Azhw5fmIQKcglw3zV5Mf19kZxZYwx2BFi8 +ullsIDRVz2pgNtNzsb2t1T4bJ3b7AMbjMu9935Yj/xZVD/CHayqRhE32+Pm6LeOV1+29f4LVSsQ3 +sVqa+DZXi7X9KsHyhY8bjGZYH9H4xmUWbfi6Wjd+YFnxn7qR2UT6K+r5uLAqipANjVf6Yi7hAx0R +c/vQ9CNDIfUrs32oX9krb07QI3lHYO0SzII3Qtg+6dQ4fS9v0OJ4St5VDj37jBz4NF92xMIgtyDp +AQYlvS4Q/+h18TW0DsH7SoCLtWIROQTu+oOkNRD+SrfL1fpPWZeDtQPUhJSZmJ2DXECqpK4rinxv +VXEJNIcF7MfQiEPsBU1zu020ZgjQQRYToFeY8ZELyz795rK7uhLyUXpgOwzt8gJoWlpxCWyLLgRZ +P1gWRiqkfWaRtrTPDj0R65QnMhPaDxfOldJDBzQ8YJucxt4495saKDXE4jCJTFXVU2y89vlQH052 +GmRd+MiC5ohehxyruqqU5LAOv1cGn6HuJ8wZ3yaNCxXIbE6p34F5ttPYpSlk6pvAhkRMK9HBrgoW +I7R3y85DJO1MFCGalLaPoYcKvHtoeYrShAdPcMcVPVHjqsgnteTZNFhly5II57NuhVKWoKTiPCmn +UBVsRGDRkoZDewI5t8tS+3EhH9NmvAgf6ueBmSkR1R+si9RhMeKN+L7oqNhRfNhslp/K1P4Kij0X +8KKCdPFTYWZug63CzAki8sTCWZhvgQVcZN+BoPDlzJPvJXvE7wDpHYhne80MOPy+632rlEMBP9I4 +L39ZsEdI1hPFjPL7Hw9dwYbM6QU6cSvY8+sezzJMc7KsKdUbr/8Q7Pklgj0AfVVJvFUBLHtvRXdV +0yk3SNOcNt7qvn0e+QYad5eNt7IYpkpum2S9fOKsqI9hVw8zG+m4Ns7qLBoRI2LJaHxFr0Xpnn4S +HJkspr3XEgbSnAQYSDvTxmtdRRwxFqQzdNc3XsuCU8awbpgoz/yJ01IcLJnxG362jde6KEEIZ2mG +/agbt2U3W/VIxHJX/8RtcZ4jKTvq57lzW0Sw5tHstTj3RHBblGHxArYLzfS3T9zWPdqS982w3LVx +W/fl7ZobS4PyZXBbAo+Aqb5RNsp7t6UGOVAXGuR2oui3wGab84vuSthiRjjAFjNBsHVXFeFr+JMQ +FMvlfrgrRlgo4dqSv21/pOiuvt46v9t3PUtIthwfJaTFdf2E53qXRvvM0BYK+MWynvyZ13r7XRY/ +JeNu6MMxyHZCVPmvvtS3QszCbF+Dz7KebtJ/wmP9rsfaeKu/ymP9FRzVX14O/2/4KQv968GIDYb+ +lBKVyFpp8aLrKjfFAORtGSg7/kA98zqcUS8ju8ZkfxsKkQxrMsaVhVypMBJrWE5HdDq4NGgt2nX6 +XoTJoE4+RuMM4KzFWSwXBty65NKkr0k2Tv+8qoNBb4b551a9j5RoHB1g27vwqOTidlY7goZWcmoi +O0KjK7JPVBKYMjE7XwFM0oCzi6kB1/RISIZ2Jpc1gurkkZS14YiUkKtupXP7GZRNE1X4USc1HJNX +WVTmArHTYjmY8GFUB1mzi3Ad30CHPTOHkRASa2qVdcoeAKTL4ey4DNdLnS4fs/2UXBnv8EFn1Fbh +fjjl7roubO+tcuFCJ5/34p/6kOy0faOuGXb7Rs0c5/AMfFr8B2N7Ej+jtIhvYzQYlIj9pw8xmyu8 +DhjSL2bHKSfgRNV0HMPxDIJdorfGHiE7dhVk8B7EghmM+EkMcl8uC3Yd4kqvGpSlLHnlwpWKAy4h +hS4CJctRMl97o/Uw/jDbZQW+GjqNd3GNXuRzKWOhp6l2ov+c7rq0a23Zie2g+yuy75xBVWTRmdor +YiTtGNJ1NNOyJpbMW9pxLgJcxTygMQ1m4JLuifL8TU1Ve+SLrfaLmmffHq39xgijx98RkKDumb1t +s9ooqJoNVvsMojEy0Wxr6pt3fpod4arIlmPQ+kHejTiB5tA3i/0swDM/TSPW9uwHo2r4BGAfxaJT +d3UNJT77LXP46ip9S9IKzYpKLsR1f+pyjbDGFjzzpSpWMEKCajDkDp0JEfkFtdCYvIMQBo3Ab+qh +nRQVEAEu+aef7lDkRtkQ4A178nuV5CnjVcPj/aqnOwWkaVSwUzrpRl4EP7cEe82rp1+Xnn26Pv4d +ddL+5qKpaB/gde5cNPQs4MfttOJmQE+vUdoCZrLyFixUDiq7unrWTJ7LiFqQj3cFgtHFK9wOUBkF +mD8/KS63btv3Rogec59lYls3Q+2WCrZzvxKZFmm4ncc9CbDXOlQjum6PSrTfCt1Gu5Vb6lvErYA5 +E6AY/eRyVKk9dU4zczEXWw84/WkQwaUpdAf4hIPRkKwbTtSvGOM76H4wPZdRAkl3QZj6H3Uee/mI +V5sLqqo62xOYeS3EGWi6fnz5hqegqgQTdKBlQeKyN4dO2dzsx3HOdifCC8qfbMuRKwqKJ555CIgT +ygm0FyjP2YstuTu7bSeqsXVAuoSAgMbTbF1qgM2yevelRAw6LldkcKtOrhQV/ql2DemJWwoWxRPF +PvRu4bLWi7B3I005nBjM0gdMd96Y4F1oEhg5AdB2FJYVYB7AcHRr1SfBOlGhfXcoEvztX14YzuK7 +91ryYF5OqLWOC5xO3B1/Puq04nfqDgQlcNJE4sV7TIcgqHzJi24MzRfvRFr0AV7ZL3CPj8TC4DGp +XjSx2ZwFTAefl5legreM6qlmFlnCzCye/CQ3wX2ZwwejLuZ3QBI/Rn1W3xcWIjGh1zJ0UkqSaoRI +zxNAJkjjkpNj64aht1NdVoEMF6piZbOtQDU9P0rNtGxI7Cwkc8U7RRuMChNmgWH1Am1jWDmp4JsF +nbJQpaHMAg0EW0GVDAkREsJ0VacJEvUoCuhoXWZIZpjPq3AS0YHIIAirAjrRemewlKcjehhJgjE+ +S1Ply03x28v2gQPhhrLFvuk+MyCwM6eWbhHW2DsPmQHTL6oO8E0LWmRrZqD5GN0TdY907TMDTtyB +M4CNcgGLJTPQDaogviQEuQN526YByPMwuICoEdFpTANQok0MrRZmj+8a0wBdlxHmwqyYhMeeaQCR +pXSa1zQAMSXbIxYq03/LMQtA4BbQlRlH+K7OfRbAs2kUotj6Eb+0pwNAZJBPuiHYyRITW9IBfqkP +XFg91z4bQBeqUSwu4B9Tj9lAbqO8Zx+dobyYDdh70pwhb/igGLDNBjIY7pzpIJ4MVsRsgCtpMduV +QCM9gn7XwC5ZGtiK2l+yAV6jkN9mIaBriNlAVleKL9zM1ILTGtlABjSuNwT4hpW6ywZyh1gJ3ZxC +Pe+c2UBmxuAWpvzMniW85wNf77Bfiqb7CqA84XQwlSPfPBMCc1egsS2OLhMJBlWQ6Ge+DSTYcQD7 +qge/uXBK/YaXxJby/UwHoEk3B/UA1N0S0La3z6RHtfvLGpzgejK4P3G1jOn7TovPVm5DE+iA4MTe +wQmrmW2rN0AdI+cJPq6RDXRCwCrx9J98NP7Nohiyw6M8c4ETVuPjiaj7BY9mV6OxxyplQj7fj1SA +wZMGMfGvKoD9W4PA/11mAmKcUr0LDfuStpmAxTOOe6ZvLtzImglUNRIIqcyGYKZDJsDXygypoA9X +ettnApXGBnAOfEJrIRGoufhME+J+SXHXkgjA9SeaaXueW0nLJg+gdm9+QgbkhpY25AFiHlRjIEPV +mfd5gFnj712dkIRtTTEP+PL9zjygiq2bA9WMyPs8AC61KgKxzp2mmAfAkibqKqD09xXTALGl0bdg +FuCg777LCaAqE7Og2N96ijmBeZHvlRRvpAKQUepdACLHB+9SAV5Hi/G/WHogj4elp4NuWyN5KLrE +22RhVYdRcpsIaKGexBm2UMu5yQg4gsBALww82ZoQ8Ek1TCX1l4HGCgkBt6OvRUju0t5LQsBKFVsq +flSc6GtCUIEeCyTSoNRLbwmB+HP40PcFZq1tEoK7+3TWjTe8XhICYjjah/h+TcNtEwJadDBD3RoF +2yQE8JZZnlLgLasMlYSEgL6w6L/M8BMA7RMCVqRAXJoyTDUmBFBjSeRmzQO+3hQzDwjduPDZto1s +QZOAeSbmXZjAWxvZmjbQNAZ6BXrv741siRTJwFjEzNDMtpHNJgNWE/rXwixBmAb/jmSJ1v61Rt3m +ede2tUb9WGMH9fJaYttarDZ8I1htTg3ivret3UJwsduH9rZtaxSzLkH84JdMZ2xbc58N0cWDQgH/ +sLatAROe2iSdbZL3bWteANQt/CY1lv7atubb3uL0sgc9yErWvjV3Cw0gu5zH3PetsUMFGwLThIzK +2rfWuGLlXXUQtZu+NQ9pjyMyJd7Uvm/NM0H5B1AhifN99K1dtgmhtLMwMxj71oXc5pABx0jPCyx9 +a52HrcN5IFILDWxeiW+ICxr8TQN7a+n+LxrYX4XysYP9zVvYCFrYXqP6vTRgf6L/esKLejLpUUHm +7RrY9la/MbnZafXirljg/+ormRFgDIryOt+qfta//jYa2Fg0C8j777iUPRQUBchpXpLy2PWvf81T +2SJCms0sNWy0Z/9/Inz/vW3pv4fSfUK6mcTeTCUmZF+7t1hZs/gWa4Bgb7F2n6CVAd7U0LQCMB1q +94MnQ5OIU3s31O51nhvKM25+VL7five6F4YN7V66SkZr8T4x/tBTV8037Uv3CeojRsYadvCMlft0 +eWC6LdgnhIb7pk4fXuenhfoEN5vtM/NaaKCe+0I9uDJRA3RxUV+xUO+wMRkslLKyCvUA31Se6uQS +g1A4FOo5uZxybxAv3bFQr5ukXtWRJOGrrhX7lMcMAM8/uQtCyR5clHSOe8c2nI+SPbOCosRjZD1T +JV5L9gILCh1mKUIehN2zZL/5+VKyT9IRk+D0eYiKai3Zb4FXoWTPu6KBSfJly6jHkr3d8/ebwdKO +ykNusWRvCZaFA0AJC3LEbV+7N5Mg6lNoX0g7Y+2eMkG/JBGalIWsNfxEDDTGq0Lp3iIK8dJZMESc +HCv3dqyTI6iDTz9trdwnok7y3S6Gx7Sv3CeyTaYwe5aHiZX7JLDTpmAfNsdvDy+i6Yj//C9yDE/O +Qrh5xPN+W07IQ9iq8BDOA8o6KhGWrjWys4MldX5YlufxdD1EdKKUwUwP8AV7ofY1MhSzhy34at84 +ARmEWp0RKFFsURtmKVfZNVv3g5K4aiQB/AtUg/bWzZR9hzbbtghLSGTeYhkEm0Mh2haazmvHQMoM +OXXSxia2xzbardjCsJjs5mL2z49M+/08x+0wUvvYhSxLJP9SSTDjC5gS8QuUrC2JqojMSm5Bp4A7 +nB1xwZ0O1JK53DZyb6Bt1GiQI+i3W/xuLw9LXY/L6dx5L7YGK2F1Jpaozm/M7NnFG+I50qVJI5gP +4cEcpx+J89WR+7E1ocEbdqodSWVQ2ZwqBCx72opHkryDBIU9EaxCIyUN2usJNd8yQA== + + + V5a3wBV3Qd1sIa49y/dCIgOVLbwICFMcaBBczNpiWs9hemDvpVwCGunEsFwHFMHspcuVzCFmmZNU +oK7YLq61YJ6Poxojzc0CMVHOo/4sTJXA9gnmU9oBzZzWebhClajy4YK11WBf5JamsB7EIp/COBfy +u8wxZnipcBcV9m+EHiDcABei1MncFCtHM+9VPH+nSIW9PoBumznVXFz+iiLYyYz2byPf1W3SCiBH +y8T8gJHYC9QnKdyJi5h8qiBGP3QM7atZJA4KCYXGBvW55Zp2oH0cpr9s4ZGCplEu4v7IYGkKiLXO +dh2ZFLuuiK75OJySlVG0i/ZFLhI7s1sBuZ1HQYMBMgoatpUzQyu0zmBBT2O7hAQs53NcyVlaVbfw +CuB5M5yWmbWinkHPjCVLzIWPtV1t3x7sjxmu9kAEJ9f6uaVwZDYvdeG0buKBqmTU014oEw6zQKgi +QKCBkgiSOUqdT5R47U0J2GWLQZ0l88AE4yPtTdLvE7vVBc4q8Qqd81hO/rB8vrNEmetrdup2lNv5 +qA8RF4U/eOGojC0UftXGJ6J8Bzz8vpz3q/oLj0dkvhmFGk0m5jYuEI4aFU37L6mT99/Fe3gHw358 +gXjEMUsQGfsj2ynIOwJME6IPoWKBKZ5KKRAHWH0plaDp3bUJhgoJVD2U1DIyYVI6XP7As3aaWhWO +t+aaPPEoKiNnGYRwdRDC5RGxnjUpesaSUwSSC7ZI00IObKklDvl8ZP++0C6GW6uCTU3q4ZKhMIU+ +XRw/9l/5/zrCXTqiLPdQEGxiJT9sOV4y1tg2hNOhhhnbzkLHjHu0JYToCDGviDmYsiyHS9/AMMHE +8S2r4Yu7YRJuBdpTzYYPC5+HfVg4xe2pARAipAtKkaOLCJOpTVDU1IMlD8rNKEkF4Z90nu78+BZG +E7XZeVysjizBDOQ99CGO6g/Hheyu+TaWIOOhVKXtskoHu7/qCPaW1xOL69cgZ3zp/GYB7N2gjcD0 +txRHaKxi/ikfkt/ADKJCo6aoL9S1LPAilIJp3gz7rRrsb6MULxVRlDMr4xZUHY+myPe4JEViy7VI +MwXUnLsRhaBmeS3YzBJmlnwiGQ17XkcwE9yoJY4qjvntbmYL7neE2eygqobczc6iNo8EgEaLzTAe +YB0J3KDjwoaZfUwSABAhq/l9e0zmO82MHpgoqHGmI2gDSnpJGuNWjCrz0xOzAn7Dkp/CpmfWvF2a +up5dKcMcJKcEXiBBOw9UwtJkZAXHXuJoAjPMJCuaspVc4n3CXEbFSqPpzL3Y8rU02cuSBJL0UzBc +CrhuFpyc7ukZagO7OWbpJTxQ2Vt28kYa2F15Ta/6FOP/UIGBU5zOU0LYhwFVixIq+i5SDiBLgmAr ++SiS2JMaXEL90agQt/7lSjZaxJnOuS0DolyXhWA0HW0Igmzd7+2j1cxK+yNDkHpLWaf5nVx+J0wi +ePoAR51MSbp82pTG/MFbsC9YVRG2LI/K4cHkOZHV4XQ8ZgjNdWlE/xzngNgMHEcuvq7R76kD/HaS +MFNotWUNu1xi2NsyBDbeIUVvzLSQ2eYWCDRR2DOLcOO479PttlIdCDEL6x7dIpKqxmI4HAOD/fcK +Nsx1N1/g8MVGoUAlXq6kI2xNF4ai0AhqOHraKaLsPhx1cKAjwlccAiCkXmfJL/Ni+dQFfBFARZt3 +Q2DnIfooe/VQt196qYi78FIt0U6K0IbpRHJmjokBj29aSxYRVp3H6yidgn/VjSatwybVQ3j271Ms +EuMPUOvR7LKlAlHO+Ojjj+tT8ZGU2ccpbTg1TiVWotiz6MRs8Qgm+jW6Ckqd++bnTYxTqiIzwLS5 +cjhie+PhqPDcQIkIE8ObYg4hM4BPcVc1mN0bD0Pn4ctVaK9oX9J073nz9e0mgbBTKYHf8pPF0/KY +iT4QUk2bRVhH9RQ0hsbhwkKGaQobQO6gmGy7IVoWWwZXwhpsNhZNVBwpQmkH7Ebr3kT52N7qdmN3 +9DQLzY5DQX4wDzQW9UlWy8LgXk2fGKZEo/ikbmdu5EjRwKlKBCiN+qmAN6uRdDwZRTl8M+wDG1tr +cYrHs6uhpnEJiwSpEb2haOxpvkGQydg6MJm909BjsvISXJR40dX52JoQxdotGrHrCu6Le4RXzlI2 +EPV7JwjBN5AkytwCXgUfmtHRAAOGMBBNveCHMwQttFAtJ9KU6dafZ1GrAh60hXvfm7ggXxPGBTBH +bnCJLbKZaVsEdgSofR0RQxRAggwUMoZdRC+wRjqUfjQiaj8lD4/REg/NSAMPrdLONuriPDcTwxnQ +GlOla/QmhnWVBhtN/jsGfhQP7QpIOlZV0Z5RY8kufwu+ClHDGHSWkXTbWjobtCshbqUSl1QPtBWm +tGAJf32x1VE0bFWcKjGMzqdIUeE2RDH2EYX/WfdpDgDtQ2phSDiN0L1Iygsbwmvsm1Dfn/AcT1j6 +PmVgT7koHMaTlb6mHvAPygwm6OlUr1/SF/EP1q6OOdTFb9kPKAHBKpNgOXWTPGHD1AlFe4MAfuRd +8Q+7tC0cNbM+IBI4DkqcN8pdIWGEt3DwjBCY3Pu8s0JXwm7LVPrSJn21T6zgxHZdAWHxM0dsUulw +VEjJoeVQKQO0LXpfIa0XswfyZcBVksozm6qAOB8ZSoXzEQRiPA/UwOzrY7L5z3oErCun8Mxmoo7P +yhn1HNQrGULjXVnEbtRXPf10zMJSWGFEV8sOE1TrvjyDwfdWEaBFikSjuhN4UEJdSFV4ogKq8CC8 +t+Wlgqom2JRqV7HHj2Uqblt4WAiZQECvpS4cJxLZql9CSb6rmNF/azJVyXY7ONu18CaOIDCjtqlh +bA21uyKgJY0H8aO3fQ2wjHTcbKJK97GWSOesghq3/UKrKNYjafaAvlLB8sSNv5QzMcu6z9z4cC1W +Q4Gv66MBSa6pxHpqRj6WJlTJ0oLb12WBLFNyC2Vdgbn70A3p9CXW0jA+SPgsuxcaCvsSMz7IFhae +iqpKiRVqgeZhTIB1075urHJ7UHR6UGTLd18tJzBquoBK7MwSeDdWehpXqM3jzguV5l1lvxxpNB2L +1GBjh4DzCxPG9k+A0pcmA1078vebchKKptteRTzN2vPgDV4aTAAt1XpomxDf+HjDdZQEOHrXfdH0 +BU2/LBe96eIIYMomywW04aYTJFJ2WYQGI1GJHSV/d+DqDsFSmcO2o/J3WsSwDNciPtTTw2seGotD +V5C8qFIEYwkQjAk8CtslyzFDdoYTKkmEzVpbtPSE8AdYpjfMgyOCW8DtVA0IVITTijQF7YnGvrT1 +xd74yLRH8GdF0dUtE6abNxNGB3Ug/SHRhfjDNjwhcC4u3mZvpp5AwjwKbSMKrW4qSY8qPV8NvTcH +G0Llaq/KXoptMPC0hc7NIwi9JbrMYKjeXIF+60avuAofwCgBvOFUC5Mwv3wjRpap+yE49WfdL5hf +W65mPLF2eqoujK/F3jTps8p2toDIeWwf2u10tzDFNpomo4kJaJcrLeLdVZpmkGOfEoL1GYv1NOpv +omhnm1mrN9xKczJ2xjIaAMT4SJYoaE4IuXh7I8OOLG/Gsh6NClE0rHz78ILFXUAG2woKd/+ksyyf +qd8a3AZccWjUP3xpUKg3T11uGgubFcMDZVENnnamsa3Xhdcx4E2zIgx5fMS1i/QFRQAonQAkxT3A +3P+hgSTEPoenWHbSye1yd+IUuz/iZrT7t/CA4YMzKVEOm5pxG9IP+t1lRiPBONAR9++I8oJLLr0b +GIvSFV+jtA5uJxqqm/EMAL3m1o7SHlnLu72THok0TaHnqRvTi5QWEIRiSSKLN9pe83NdyxDFxl4+ +sb1I9gI8paTRCZ9XN1Dw4wjEZE8mH14EMI1irWxmysLAxwXefBBvEYiwNLnTyObltKSoCXICFWam +b4PPs4yGWgs1OPh4Hrnku+9EniZrlsveM+s3+F/bJ4Xk1xbCcWgKb/HjPOMJY02Wt3oM4b2FAyRV +SPfOAAJgh9yW687kGH8QW93tOX33Fr4QqiI8SahamAwLIRA5iiwLrU6Rlq8RFKnqpTxfIOwySi5r +JGaO3IJjKgr2/IrE1mjOHsn37qHcdRMViopkTlovMSVjg5rlgk77dFjYe1jK6KStU5CHTZDYNboF +leSjHhWMygxv1yj5dJbJGGCzHtfQXEOFif6t2ZQ+cTBrhN/vcco1J4AG9yTxIPCAuzDkFlB2oNVi +dutJ1RUyFFtHmocOyQ1svKCjbfWVE3aXkCQBQOYDoUd1z1gj5Fh2G5omROXeKwxLnlbIGy8ButC3 +6jHfC0d4ZrnkjZvzrBkqWg+q9IhGou2OAM/N3oMaOF/7HBbfh0Y0u7yK5zbk0/GINS2nn6FVCH/u +XFIhvWcy8ZLthae+x/oBeCXgaxTlRFgQDtAUBLil2hE42RcYMNAaoLCkFpGZj1Dj0BhSd655Whax +RMLGLRKa0OXSI9t8K7WAptQStBSMQaqPUK7hCI1pWNxMEBrLPjI1qB1kCvIjrV2rR8DjvJYm8hEn +UHirO+EjFJ5midWmWLYqGrVKIs3r9HHnengrf3F/yELcSYCMWEXjQtrXImbq3kQOxTj7St5OSODD +ILNbC3o8I3XDpQjIP1ctLtutFlc8cta3UiJHyWHxTwVMzlqOxGfI8ibmKe8rljWd+/Ry7tNr9DNC +eVRKLIXib2cCKX2EEivWSjh8AWC5l7VSyxHMkM9U6a3QW4qZcMALtgRu4AehWFzGcBeIQrKcWHSG +kFdjUSmhLD6TsqV4zY5UBQX9aQXqawFcWiZKL9/L51gxDTWYqUUUdOy7pQjPNnMvWoGt+YzSWyFf +0EcqK3TzsdRrP0Bv+9Y3uWSpZw30ra/AaRhwxIhZ+uBuVtpgcqYp9jE0bIXkdILip04eiqUfwqLt +5InprLaMro/QU9H9VU1dOVZktmR05SGmOfs3GCY+IoMg/Rp8xm+dHy1aZirtaik9u0YElEwnFab3 +ZmFo7TkRANKXC+0qcRhoVt42C6z5oe3Fp9OwCUTcbd722j7DK/l6ofUiOpKlBafRsEuzWBb1tNjJ +41W0poWJYshw3GtHkAsx/oz7OzVHunYV+TK3lhbjuWXTncSM+GB8BtU7G633+BLdWwMJJCJWZu2L +Iv3DsDXSP92fdT3CduEp1LXlkQClt/3V8MCh1/sYLRsd4iLGhM7Ah33yOe43+sqPg0cDOp5+/mF7 +d/OP4eHWPnl8QWu/ff9+w/Bb+E6j1RA/8YoY2C+VFXkQVtwKXoiLdgVB7Bf/CqaIm2jFYzz2X0Bz +bLdvQIWsm38FlgTzEQAqr0Yn4FuCqQoYmWDuVqTN1moGwM40ugHrE8x0wAxtzf0KPVqdRsAuBb8z +oU9btxWQU9PpBdBV8JcBvLX1uwEEFvx3AJKFGCDg0V5DiABnCxFIgMSFKCZA67bR0ETmhWAqgPpC +QBYwgdvAboUWzqAwgBJjPLmCG0Nc+tsOJBnC24CxDGHyn3WfwmWGIDsgOkOgHpChuw== + + + eD8ATEPaEECqMfVYMa7bFCZgZUMqFGC2IZ2KON5dWhaPWrO7ABgOCWLAHW8TzYBfXhPWiIH++ohd +8rw5aknCJ5w75O8TBL5P/1cMeUz/A/w8lCICjH1b0ghw+LU0EgH1o6oS8fi7okxA84faThgImGWh +ME+wqyrFuQQcYxhnGNWrMAyxLX7FoYq1iBYHM9ZCXBzweCnjxfmQtQoYZ0zWSmIYUdlWJJdBl1DX +DKMyoTYaRm5eS6thYidUZsPUz6zlzlmhXQE4ThqtdeQ4rbTWouPU066mHWem1tp4GLsKZfUwvrUt +z4cxsFDdj5Nka4cgTqTtOg3xPGvHIg7HrV2POGS3657EYb21CxMH/tZOThwc3HWE6tC3gVCleiNs +6SzpqcUFd6Ea3WJ3SnGYvrU9/9X7tsfFigaDYS9wRPVrqwxW6AJdjxlRQBKx3VZpcmBLd8069Fwl +Q2Zmw+K1Fpt+vHt6iR53nndsHBKXE8+uXccZomXfGRkbF5uXtUMSRtTK0Hvb9EAV4Zw0iwgqIUBp +JfZSqwpotmROpPjo9qz92Ja6ZtLB4FGl23V141nW5nC8k7XBHJ9obVT/2L6ZteH9eK9ru1xzMeGz +rG33+GnXzv1jZewa/3FhrQCCuDhXDEJc4zssQ9wrKyYi7rcVVvH1wC/P5CPDL2PChbHuSix8XChZ +rUviT8NpKVW4KENDvl0to7SoAaojnss+1KlGoIVZPm1eWDqQMjVom/B35uUPHPx6hG/yQ5Q5PH6m +uRVOA9cjoSiy9wQVdj1pLhfuikACbKkq+knp7H5ph7Pc3igueCjCiPU+zJNABGIHiGBg8zjrEf45 +x9sIP48v8nbcgogboJn56ns8P+I//2Gg+xmLP6gFCShpCxnBTIvKLXx28op4EPStqvWcSWXNUekq +h28gc3/lytfzDxQi9AO7R/qxP0btbv8roRvICsAji9JpuV484P2uf4zS1ftBtTg1nYWFZjTahkzI +ggf0PVHws8zmft4/liaR4CezFeVRepSaz2FfXC29+Ov1vYU7+Or1/3j/WgfLyywMpBwJkMRms5HY +wAYJlOVQ93VdI1k4ZMgkuuL/dZWRxyV1z88TCfT9IiXw16CJ0MDg18N5kFsQRxJcTCVuF/wgYsX4 +QUtmzz1KKJxl2brxRtbdHx9oZ0TW1xLOEl/sYsW+/D7L5ltXKEMMqqd1CFMu50qOR/UiHQkwuALT +PEaREI4krKDmWHN//oExEP0CgtVS3rbf5lfLotxccD1ivfEfO7PBbEUTB0WCesZ5w962UKJETPbW +E+61Pp/AYgiqGgxdFHPPj2Gwt/0bfx7f8HoLX36DuQWhBzTTlal+oimy83PmQqnQUIyyeCF+f9U7 +gCYzQEWECgTOgm5okCkoVgkW36SMRyU/tQPScNNgpgfm+ipeaDso2jbH46mZgCyDSgS2KlExJfRW +UR5ct0qtloEAi7Yjkjmovg9pJdtMpe2AGhR0VhuTRohSuNTa4eQtFqVCKKojZPwgiT7BATELYhtC +iJ/Lb0UccRA+P8Ce69NaaEuhzULbK8vwUpvI0qG+BGbozXGFKEEjf+t1E7joLLmFI00E2bxiwY0H +SzQ3I8iDfVKaX87tfTtbXIWf2s4reG8Rm3iTsK36/IhPiUaaoTZZUXL0CYHBNolWsFHy8M6A12SS +1/zZeeqy9Ho62MxeQ3t6FowOoSRpGPHcw7WorWrmpnnCN39VVZWVpLYAhuv1OnXGIvpM2tef3Day +q4TDShYlZLM+PmNhKrldNGbr84Whx6Qn1nfqn7zv5ho9tAmb5yzrd1PayI1CIHq0zafvk6LvgkT8 +sxXUboeeY/6Rs4wLsQ26q4PKKjs3LOaWnVM9oSckcvLdpqBThxVE9qaeabO5WneQO6dB7/axL8PD +7na12YpL0rKJLL5tbIPE/8CwtIqidDQvuY5uO0HWHf3pBIT85bOEG0E7Er1gCVX3a/M8hD5y5Jbq +lFFLiq+D8IdxiILaueZC11dapXaXVJc4dKX10+wSrfiJC60xFoF81kdcJQUSRzJbBs7qvVltsGTR +t+Q90ISaq+39wWETG83k9wVfkoOjzG1A1r3ZOLl5o7OCbR6dn7jv1ORjhCSDKbk+4t61K6l8Zele +B+oWbQDgM+IU2qNlMpcGU5Jdn4vBGqC+0QhJlFV4veRYuGnDjsHASlWXwGg653fLF34ejOd6B8EG +bx9kmvDwHoLRD+8yOI/tN1l9UPi0qxebi2J1gdslFTxpWJrBG6+rOzj17SYJwUHYbCGuCBt2fdLt +vg9Bzmo/voyTvoi1MGPikDw+/H/++P/9YU+KepX/NA5JP0mCiqosAwXd3i+aX/7j9R9h6YQtuhwq +fJrxP6/i5V9L788+Bb5eeDr/8ye69v+/IOt8e9E75s74ov/umDoD9fuWqTNw6wemzsCtH5g6I7f+ +jqlz5dYPRJ2BXD8Qda7k+huezkCtv/J0Bmb9V57OQKg/eTq/fpmfEulveToDkX7g6VyJ9ANNZyDS +33J2BiL9wNk5ifQDVWdg1N9SdTqlfuDnDJT6gWkzUOpviToDpf7mPO+U+oGwM1Dqbwk7A6V+IOwM +lPqBsDNQ6m8JOwO3fiTsXLn1A2HnyrH/Rti5UuuvhJ2BWT8QdgZm/S1hZ2DWD4Sdk1l/8nR+vTl+ +e9lGbzKgmS4T08cWSTD2sVfchev34AjUo0VgtSrugmexhcng6VlajYq7UJ94V4Ug7Lj2irtJCk9m +BRq4Z/p3q+Iuhkc98sbgaN8o7qYJgrDtjLr0KLovkrsJ2LOFb7ammH6rUXKX+W693aC0C4xYLC58 +7kebZkjuHtmrUSSXGcu4Su5aPjSYI5iUxv6ukrvcm9twy3yOwQczJXehVfBFmxlMzxvxXW6BAClo +7h4j8AJSniaBaNDclbYZFfaOfmndaO7CsUuiX/URNpK7qI/KU/VE33dcaJXcTd1DPFtWttPSRnI3 +sT5402YKSNaj9u56hF9pFeHFxOKczAR2qScHEV4zXhJWM0/XBXIMaryl+uxCxfJO8xbUeMk+mKms +BHQYr0WXl9FqIOe1sr43wrzrjvztD79SmPdNdxX4dmNuq+91eW1DvsnyooOxKslaHPkmJNteVHmz +EJASki3QsqDGQJH+XlV57RVW0XlN2doMHjPK1u4u9tDkPZDUsnzom709Bk7BfeKIrp0oL474VZO3 +9Z9+NJfkrbZyj86TYdfMZJm7Bcn0x1/3ZA893qa5POR/kYtR8RpfkH+dHu9ny+LvgMX/14hwRb27 +neeLipKr54uKkqvnC4qSW88XFCWD55uKksHhDUXJrZsLkpLBzQVJyenmopLkzs09JCVXN7dKSgYv +FyQlt14uSEoGdxfFJYe7C5qSO28XNSVXbxc1JRdvFyUld94uSkqu3i5KSq6+LGpL7rxdFJlcvV0U +mVy9XVSb3Hm7qDa5eruoO7n6u6834i9yeNMevFQ8or+LupNfyU6Wj3e1RIvPn7KTlnDV03Xa3d9Z +zkcQHmQn7VahfXkoMzaAy0GZcXOtF9FJMKXt41uVikyhfgbhUf9MdfIr0clPHsxFJ4nZLCt+urtK +pz1qTv7u53ooTgJhtMOezg5k9wEv4a+SrPlsSfy78XVqv+yE0sQTUBmBvm1Z5LoRSqvH99IZEqzU +mPNGKM2sn2jjLN0/xSK1VUqrloACB7B79snKxzjbIAwIAmlhlu9VIM0MjzgkLVA2C3tuBNJ4EqrD +9iRdCpFBIE3oVo2jm/U6p5T6qpDGyL8eLzkHRhBI48bFGnDADrjRR6O1oge5MrHdJ/poMsmZ+00+ +xhX00eqQTEkZlrt7o49W0dpkXtOyKs2wbfXRahpXotpXzo0+Gvp+atUV2+Mt7SBNC0nDVh9NJAaa ++7Qd20qURysDPgjq7Jir4U0njRktl0wBnNvLXifNh5CaDyEBOg86aQwIuXjKTdZdok7adpP8lOvZ +yUp9exTYX+Lojczxz4ijfZvqXnMn7OW9QKgTyJjpuj4RSHu/HJUpTs5sZGJIy6JLi1d/1+U6lZTv +luofGkQaxjk83k4m7fc+3kYq7a/3fH8FvbSvlsjfgfv5/YJp9qmxkRb/N5S81Dy5CCXtBR6ADz6w +190Mg/n5ZJ7mTH5Wtj+efjRa+DivfRnzL66PhhKRnYy/OJfZBjhF51H47MNSGPF8MUHObIeZLjOh +wIku6TOCnOj91hBsdsBUGcKYzSz14XBHipegDMlEHk1iH8CqmrFxBIZwh53o9vRuNG1hi2KoaCuw +pu7IZFERZRCNZnu6m0rjffjIAhOekHnZ+5tQo+otZMat8EOCcdyOavV2NMEzaWIbwmPAZ/BqjITD +Bn3Y26Z2DaASUUm7gwLcf5x/THYc0PmCh2wTD0lpobsPkAU9LATLkOtQQWWss5A03C+N+w4rDZ8i +n3TAh8e+VAzHLW5/28eHWC8LETGZAF6cxsT+9uU3brf3XejT5S1A+SbfflLqL8/3BwqxOfChMFO7 +f/0kXnKAgLCPtvmMpEJ4H0p3SSjrdSnYLZxaLKSK9ycrygK9w5ssTF9dm5VJYEOf3wIb8N6bRc1P +ND9NCeoT/OvmNFClEblb7HLridZbIdLjJZtZLCKTCU/kc+UzQnt/HzT1EUamqd8U4K3vlPi+aHag +5pOwI3wbhqwa98h0xYQ6hE8LMKDoPi1SUBi0ro4KVYrOY1aGWdWwyirhKaO9FnzdpT1X2eFICSao +QUqIemFZ3DT0nHs9p/aKylPvizkPus2Tjirsq/DzsDfD9cMe395+MBXhNQQrE15lsFbbTxKsXvi0 +wXKG5REt8MvqmnY7LMlo8tdl/ZXnmK0xgBX306W5oB16drDFquQHva7b4u5dWdt5mRwA50MZjRn4 +fIrJgm67OdPuROEiLrLQOuvR+b56hQkKIhe0UVWnqX7QfdqwVU0b5jJKIhCwM0RkQQkohqKKm6jC +zXnaK6OXfTv1RM/maP1WRLVcAOlJfuJ2hhwgEnhbgRh1iqqRVL+QiGJoZZu9YG4W2CVVfHQSNI5K +peviRTDiZv9BPYhpbclGgKu6VUPFFLEVeJLCaOmRx5PUoQgAYeel05ywlFsofjmRP89/a3C2F4cF +3xS87DYLRpHWrqqPnYQEEVPSS8ZF4TtitNevsyhIYMX9Qo1ybBcfsdYpXqOOT2tuoPBpTz4FHeAM +ZLzBDlp9YLegKlrUDB6v7BwQRBgs9G06QBT8RYVB0VXtBL9qjUqHV/+cp7rhs4r3mm+tAqRQT5+b +Y/rcbHoGYepXOv0TWjhNE1lPztgzwKlD8PVr8ttXjW35bCUMecxW9urE9I5FUfH2VOXUcizCdKqE +45mu5riHBk2/sNd2Hvn5quEzsY3XJioCs0g6TxkbAxyLJG2+2jq/O+N61nK4jVnLqcDgKI5/pkXt +2Rb4PdCi91BSPoaScv4IKQzZgX0BqOPM9Z+aO2IwkVGQxNi9Le2tHDXpLYkl1Jz2pQ== + + + bK/n33e1b6IVURU/J77rZ5LUSrUul+NtRBi/9+HgNiuQ8xcK1ztV6l/2cOqLUYuC684inl9a5dut +jF+fZv3Dt+IMOuU/ffyX/26//p///PEPf/zjf/3x41/+9N/+1//+Hxz8t07IPpFjBXelSk8TH8Ct +KJ/BVCo9lF69C5aSOVX6B50uZxsBFaBPM5aa/YJmphxYjyyDQb0PZRxG28QUWyxCIZi09+I8LKV+ +z2BhEs3wY3Qu4B7MPlOnAMdMmrnOJHJ1Bhxv8kW64k5N5ho4lZVy2smFh87OCcsI8Ogghd9SlsIH +gVO64CYVAxHdMG7ldpbEQwzft5AeQHvNbULkYp4Z6Bwz3mmQxXCBruVaz5brkJlJamTI/Vb5+tMr +o4xVmEdNmY5UGkxHzIcRTVHjU/8kZXqI4/zZociU5Q7REhWme7PeuiaoquUPSRLByZHM5mrEK1so +G3MH9r/ig4TGZjA/aayZflB1gLkYC244HWCYETmiaixYNHulcL4wiIYTYxCtKzy8XBnFQqcqHl97 +1SeaL7XR6fDbL0TN6M6bpy2D/SQNqMZZs1pBl4p9iFYfhDmF3lQX6z5kPbDuV2GfedUMeyaBtFwp +xM7qeke2ZJJI9QDFXc78lAGMIR3ipPEdW5hUxVakdd3+5VsGfjzGQyq1UAHDhueTAeRGmfVuql2z +cG2RITmCWyuDHx9GZTHnWahdDuqrFhoQKkHrXFz+4iBCSpJgGoLf9l6FzpJIxuGrW4JQtnug35WK +DQPh3HcDGpiokeYhwgBzEiIMxRMZepckMmlOtIVIgkq3zn9A53MpRBBjLUCD4/Bas7lmCGozJWB1 +XQ+pu4B7qi52Td/nBtNtjuERjIhS0IIAC2UuJ4XldZrHOvqQhPBI7mTgrjh9W8cO0FSSrlD13iTB +oMRRpGjEOB8twRn8KlCV5FJq8j4wmIBvp591J9cDFDMbsIycnQ36rqItA0DhL1WzChY6sVjiEYKJ +QIbHHgLkkcvmNCjriJqs4gqdXs2+Br22XKSbE46wRNAMFCakm2sc1wkHdefzhH75ck06jBbjllVW +aj2gnyPYBilODwTCXcJkCHdrea4FWyqsBR5C1lCUNPYOTtebHSxo5iFJ7akSXBKrm3/A7ICBwBLa +svfbn39MZFMAsIkmNSV6u6QDXQ2n/DKj1318lPsUsPA4nWMri2ML3pLzsaJ83VlecUogyYwqM5Vm +QeHQkQjGrSSEJgKknhgNsfCkzOyDwlJNEMOgJ9keuGX0yBfOy7e47QgoICzNBQstWRY8oN3MVZTs +3E5yZ0c4rwUC9bbXLfQjV+u+R3z1Z6rhzvje2KlQfZH6+XeGcfHSdz5VrjkgMxXf1lkpJUnV5BDd +odkzPTMcfdS6EUyzsOmfxnpR+6qBHxclze1aKhkMZnERIbPUSc/dBvWPPTtUMnY3ybEqRXZL4kjO +qcsnx4vD7yjzymchJ6rVfyXWVHHfAIoFyZFPnzZkR/uFkkuMKfvvo/IhR2cG6xhMPbYsmWvKLJen ++6eTXc3IHGRxZjWLroRplwqz5c7Y4Ury2F3xRPkDWLL7HliHLOW8Dg536HrkoUbQB2rFHLtP9YiA +Pol7976wJOReVBtK8ZqNZT10tsG5QwIt9R3NhVfh6avIbMi2ILOZIHyeV/kf4/ZOeZ9d/sTOd18D +F9gck2EfUCTWrHR8J/4t+8eBUck+Dt/wFlJCWVnGrgzmJpZl6k5e5r4TRDbKN9co8MH5IgZ22ygN +4HhWHcKtvqph91jqmHZbS2NDJCd7abhUFBgsxZE8xeHEdNxWJ0Jk3ZEAQGZ2iAOE7SUoED3j00mp +RLGTuxDlI2qqovzx2Ee6b7e5SJGXZSTU5DPVjzWXJL4Z3SgpMsuhyCs1H7PmGcXfS89L2gZs77Hh +qA/KztC3pfV32Lc44EBjsdJDb/gyEPHYQG86uk+qrrKXWvVTUBEWVa79QsvXrDgpub+yOuSOOkCP +y6k0IUu6eQs+8C4WFstA+PDSmNIULUPjmsSwuFrDVNQEsKxSytADiQHCge0ynEr5RV9a9e19cVmY +dkt1t4wjoNSSfAABhTDmxNNNkoWHGBcP8rXmhG4ntD2H7eGSnyWmQ0P89GNVh2INxLrRzT+w+ujc +4BTtBdWUVTO6z9GAHfYU1ZURWNXTZTRBdZyDwC7pScxQ2Ce28wDRt09OgtglZ1id1McsWtOzhiOu +6k1ckBL2Uf2dhaPW5+Xrab4RAahW666cNigNbNGePr9+e5yJ1lutcxXUUXQzByqVg3AeRitgSLL/ +tXWRNvcSjtg+UzgqvBvCL4i6O9eWYV7fbz2E57HosMIj+dl3GsaqM1ArJYz1e0PodgBZpiaBpZ5L +hRa/+KVtr2NGtusMtVudn4nko2/Wq6VUfgQ15Zo2a95cg0J5y/4KSdh267Aj6Up0pWu7LVir41GW +vWtRkr/JKubhzywAWOCyMSCQ4ennFprls25sEJhlhGGU9Z7n3pbdcMGAkVstIdKS7Y42VI2BoTAS +TPAlMtYzWvCE/6Y6f9YK2e3D+CfoCqmcW2By5XZ/4jt4FhYVzwIUdPU80F9KjWd1WheSDLnvXR26 +sRqCXj0ltF6S8ll8LA0scSpuPLQmq88S/btKlpuAAH3iq+3DCcql96B2fotGKH9Pzue3QIY0E4j5 +Ng7qYtnahFGaPrruGIHZezvrtY/f7sFxvwZ/aSbFFsXYoqybANJiYPGomskBCRQDUX1tCD51VBqy +BSGghQqRiWUzHdITXsJieOSoCVwwlq5RtXg/6yYg13Od22AeLlJ6pojfZIpNISWwbW/b+IAY7nIV +xjWtyAOrJIL1XvfZSSpqQz1SGhJ57DOj0EJkhWwoHLFNpsJRIRfjbsgi8GgWYW7SOLjaqJ2g3ok/ +22aD2ecuQyppr0PhAfS5k2r/iwM2KW04KGTGiH/SGzjNUvJWY3YNPTPAMns9h3g1t0l6LuIQh4Mc +i7w5T0EbHMsvRp5dwQBK08GGEusNuX6Hvu9GvwBAS6xbwOapRX6gynVuah/Mp2vRFQqp9yc1FExs +kok1B3FtSjHZ57P49MXZLJZqDtTRcrmYoqElEItCCagnoQwlv55ibYmMHjHMUI0ym5Wd3ntTzLqG +dMJaAbPYpEgYZS2epWPo9QEWwVlua3Ce7dZH5e5muVGLW2t9zGPcOe9LhWcZN7FWGhslVtpBozZJ +/xz9yW1FEwF5j86XeqgF1Q3Kx1BJFQtN7m/1V1tmlxClS9GW1s5NBLKWe+Xjz32NGBJT10tYSsyQ +XaRrlqSZXGwctqtjn2KC7o/q96kJ9SvWy6+mlHNTa3/8xMvzuL/JkfdWz2cGrg/umdAFQKYQf7T2 +EFDIPidW6LX7gCcTUcsJJAf459rF0Ao6vruUHPOhJ+g0XALvtXrQBu5bbPgiaf8gQuiquVpUnQc5 +uSZ3fBFrOtpObgaAkWRbNs1BxnBxADKWFoC+bdMWhPSVLUhSNmahv0v1VdQq6CUAlmf9KKBxQLJi +ZTY2xK0n3RoCA0qBhLVHrzCZ+muDjU5qMc2/rZ3NMufzg+SVb+zwFUAujGnbTTlDPSPQAwGDUqwG +j0W4TBnWkb3aKgelbRgVhJqjZ3of4maaqjjj+GvI/5mpsxCofDyugBYjDAEASQCpPO7LTIalI74p +5kPY/lYCcCT3FI9Hv8ZUEpQYZq0phc3XdVPMh3cEJ8SEw3y/ImtGgiMRZl3Pr8ItERMdzC6P8dfx +Je/i/gz4eIYCc3x6xsoJUGA8PRlsmutE8+ZY//tS//7H2A+1OIu7lAJsE6BE9FiLV3VyQPP1lvG3 +zVK+msMLDlK9Ebw+dsKFsBg3mUSNP3cOMggJZmfbzwdDiHO/QWwOuA3khL2BNMNN7VK4yAGQgShB +UuBhADgdrN1j30NWj0eyp2HQtb/tfFQ2mFi8VNex2GhaFTEVZMHVD2D+D1sk9RDklixquduIqIfZ +ggGd3G2aN3QTRD8N6y+py7CJlcHI4Z81dDc2hAypBEYQKIQCgxxvWl5ILEAeEFyLOHOaae61IG1i +95rm3p/GnQHdjDKBBY4oqE1vgMoHzzk8R9Xx0BFDfuMWdnoZ/oYA3nRHzO+zZ+zTAAe5Hk5M7OSV +YWAQEyPvn65P0i3kU/YfUKVPF8n3MWvBQkzSzY4e1ha3RjQwgNfwsNNBs47N4xXWcSJRGB7dnsL2 +JqkICau91xkGVMKAG0EGe4QypJ1n8KCleDLYcbqnCXEH0hJoNyAtwVB6DF/gNyevYwo5D960GAWx ++3UhqaH0jzWQYo1cSMNYEi6t8RCP8YTMoFx0G2xPPeKkt7iuKm9i+ZuNQV8gxIYQPzTJaaOgwCPN +0PJOTtgCMHrGe2tgqvecEB9oHc//EYJbODQS0/n40/PMMUgOR/wYkeVbsL05zxKw82lhjbqkn3Jc +uyOoyIvf1BL1/kng73ot4teD18HrOSJ8iX9Y0paKgFRnqsVuOw82lJD+YHbIXS9NDR45JlpVKR/x +lAstbo6gSJNE9MLav/epmChqYPCndA+N/0wCoYBB1wK2bALRkEFiVRiuuiRCMcLlkIliDqmqXVAR +VIbn1myWI8yNFY4gpJiZMFIP9WLq4bCANPv5Z/osGhtbXTPPhlSECAari9DLmqRDFt1ZhUgjl5Qf +3/Ut1YdfB60Y+HXgX4slAyknILsCKSLaEupdraUHGEaoS4o9B/qlUbQw2/cdZgcG4sG+zEIHug50 +NRBAtrv1u5vVEf4oZ8B+xTPPeorUCmjjolYAU9qswogM5OkMqdjAV3LqJPaSoI2bNR6nOmniBEHi +axaG+He1Du3fy6RhG8WkKk0VyE8EqPuYxScoPBiBhooIAd1HxaqiRZwZQ+VPg6NnlLmgjyebQ8mG +T/0x62LV/o9DHic1WLof1TQYR8BQELbAhOleZNTgoDlx32MxUJqVyJfqHXQngDqhJ2+k9qEIqHd1 +P0ovb5XDyiuwjGfWGvnSriJiv2KKc1YouYzlwHiWBte5hwFe1uRHGdZIWx4FjPSsg+rKoET5SjRp +1yqqLlezLgfHgxcLlmKs6NPhTYdoAcaIWceFCKspGDIzRxwVysCKhdhF0OEfY2Zw1pDFgVWIttBa +4c2t5Wd41c3eS+4DDx+q2BINqXDDtxPCm/EASzEcwn9fEjmBXP0IBXV4SdAjsm2LH0uhLg9FirkF +VlxFAHOY2aWqX0H8Y/PWhgDvuWkV2XriBta+AixXc42sXYmqWc3EV1RfNfY/IE2pihHBz5Z7cwR0 +A4TYcAn0ke7Ho9anDN0aiGAK6xMmkAoD0dr1qUAF4ByEbDyfs0OydI/iedYOVLyXcMT2mcJR4d2s +XbX4ftfu3NvXWXp74dMuTcHHmlhbivsltbYm48pc25txda9t0v0uWdutcbOtDdu4YdfG736/L/3j +aDbWFnS0OEsne2u31n74av1CSz3YzdCa31rd0OIPRjugA6aZn5iCV5ewAhGiQxkYhg== + + + 4IoCBGLryQKUIjjCAMcIPjSgOrYeeIJCgt8OeJLV4wdYyjZcCPCWEGwEiEyIUwLU5iW4CUCdEBEF +sE8IplbM0DYUC9CjEMgF+FIIAQMMKoSSv+3gVDEkXWFZIbT988DRvMG7YoC8QsRmSB3wZdtAPODU +QhgfsG4xFVghc/uUYkXchcxkYPViKjP/sM2E5h9DIrVCCmMytiIT90ndCnCMyeGKkfyJI7b5aTxq +zXMX1GdMlVfw6D7lXkGo8TwrkDWm/wEQu6sirLjaWINYsbmxjrFifPf1kBUrHOsqAW4cSjMranlb +4RmY57U+FNDSscQ0wNbbwlTAaoe61gr3DgWxiBrf1dMC6DzU5QJwfa3oBfz7th4YcPShnBgg+LMA +uQL4d0XLdQpg1DnD+MBaFw3DB9uqaphhCEXZOf4QyrhhemJbBQ5TGKGGHOY3ZtU5jH9sS9VheiRU +usMESiiShzmWbY09nmcU5ufcTKjgh7GbbQMgTO+E/kGcAFo6D3GQaNe3yMlVhKE97OqyrP0PPSKh +NI/IUl47JwrB9DlpuxI3bNouWfQ06Esit8u6Xps2jNWLHqjgs2ps9yAcQrCCcEiFRWvXK5IGFnPf +RePEJXaaFHnCvmef3FH9a5OKiMtjXLsPouG1wzUDQ3W/1rYYnPy3NAe8h0Yow7P5ULSmhe/Yecsq +fN2xVwfqSeSFcIerp7Zr9T1+vrYG45XXruLjftde5I/Xp1w7mPEdrQ3Qf/rDAF2/veu1fxq/19p5 +jZ9917gNq2dt+4YFGBrGYR2/tpnXXbC2puM+WnvaXw/28Ryr7CKm7BTvewMzccXPr3HAfIwMwAwl +BOisA1H8WXgCh5T0Jgtv0Q6waNd1j7LA8xDB4KrSBR7v8Qc9tTk36UJU6JuB+sxfwUeFnZFYhlal +RcpiXuziBzZLrk79drHGH6PaIuoBWPT7R7wuXPZFuubmlUvb3PZ6hC/f9anDeeKbu8fqglmSCbov +v8Dzu2mAk4WmApkt0xPPRE/MltGf3v5ozkRVu7WU1W5tEMsLLumfbo7o+qmC2Z/4+S1eOmpHiZ7/ +88rhD8v9/hilp/ejYKyocHkj0S6id0CMOuJEulj8zwdJlAW55iLq5gnsFcPOiUQCr/lRghRzCVgZ +2uyb84x3F2/hkzf+4+3DINICane7g+yc5udT/PxdyfxmBcI6J+DSbuHBGyr6jvWPcNeJ+25d8jBi +lfTJ6nr+ynfZ4/RjOz7u5WXvPm58/NvzCRfT8Ol7Wdf1shQA/VJg+tP2jze3tPn4iCvibW9qKL2c +uyNu/XS7wDc/94//vOD47+PufrzsOriDE/2RbLlUZiJnXXRiBhYu2uKSzeYTbhlSwQL/1WBxCVsg +nCW8uXAfn7zbuYIpVfS8cf5/GgUXr0HQXL82a4hsX+SAKFSAaZbUEPypSA2BqExiWiRjPAith96e +/Be8M9fMaQ/JPNzomGj6lydRmgXFQHW5BmXGpH39VjipUnSXis42ZpMIQxKVJtIvVQcJS39kKnZV +Kbk4LwHoo6nBERgHO0JCUCoLK3HrkI4w6YesPKy+B9pE4/bDQwKDR8n9AMUMILSdTiIFPuFUeGf5 +BezPUCqwT706UIuqA5lq23EIi0k8nNIcOSF0AJCnqQDpWSAskESLgnCDaFEqYGkwG0mKlmopW8Kb +IOogrnRDlCikjAS8gYm+OMoSeTKwoTdDJu51bfyv+ggU0y6XYIJuGrXnrcPJFqegx2vxFWyhY0V3 +bzgC5PC0ZjlL8ppkt5BP0Jp4H0lC9XZEIh785HkAUZPVo7gkFIy/jHJ52cmytyz0ZniNSlx5EZAj +Yfu3X4FaHHgT+3CaDw0fs3QX1LKEyGU71/WAAhc9F5Kse7+oCsZ4syILvd5uP4Vfb6zZ91Wdiby5 +Pdv6tXyyOYprpjjxEg5i7qhibpBY1T7QkZUOLXtxfbjtjkYIjSo7fVfIPINhsDxTmAnbN02o/2Bc +lO7RfK6FIm48YgIVvjjPeiuQMKG8coi8/44PRISgex3M7/6+1teicAHssp280fYLb5Sm3rn7HrtM +I35XMRQ1pxq7XT7ndObSg1LtIaHwFtaSmmqkgNQH6rz75RFpzDAIQ9mCilVY0j2p+wUlHNomYWOQ +qNDMI1F5tJPiBlPf6oTcFuWc+hF2Jmy+QMPDvu5thBMW0AEI9H292Acw4kLwp4Pxq49gYKD+Farb +Nq/ZoU2TF2CydKLMih9TgymYu3ie1WSGWwmWd/tEwW7PFzItfXiDq6PYf4ngcNYPGnxWWBLB9W1X +VnChYX0GN7wu7OnDt9sieP65q0LMEDZkeMTtxg4xTLAPX8dBn4VRWKi/kdDgvRMavMW75OqOPCST +YsjeCNagF2f+4j+EBv/OhAYpdxfXi7g0S1Zo0zOClBN4ca/N0IwhdEGLU9MlFMk1FGkf9ejOVePV +7qvRItZoiE/xXFDauX6GynBw+NOUQpP2mGw+VFKLui+ELT5ZQgUOVRNtaHaEM3WAnaCcapYhST+r +js4RrO3F+TGKaA1tx45gkPMfNAIQm2ia40nOCJuh9mM2+Cgu+lwvADenJgObSErhfbRF9Y86Tx99 +BbTCKOoggABbXYYWVTIeX7zPKTVIedwPpFt8uHJJv6Q4YjbOnuxPo7fubQC4pamZq28naYWEHMZH +5k1Bs0fcJloiyBA75IKWn53Nqz9Ojye8UpY4C5AVO8IO6c82gPDAcIKS0MHHSAMeVu2K5qM9wHd0 +ue08iK80v2MkQ4SS0ZXKeD0W4h4MorZsxqo+qRnArVKZL1KYOQREUtPgOLwxhagg/YBb9BO4MWZw +j3PIhJg7K5rkHjNSJYGyGS0TVqlZAVYp02MvPx/8i0O8XPVYNCVvRSm3i9BIl3dHHMjV/Uuh/CZC +yuZD1PZmrvZ/2Hu7XtuS6zzvF+g/7JsAUgAfzfqeM3fiiWIzoWFBFmILRtBgmm25E5FNUC0K+vce +zzNqrn16rd1qCqCRm1gSzbOr1vysWTVqjPfDwaMStY9+qDERX7Igg0KZdOp6Ixe6oX27IVeYmFjv +6/iSSDQ+2ZdXiFkQZa1ntqxn8qZhW+OBC9uafCGKnqmwSBxFJBXfmMRQ67i7PKImpCS0semqcNoA +8MMHiK0Caw3rrsTphgsBu4PL+7gS7N6vfMzwml3/q6YRWymrlpRNNe8fU32NA1T4/PVKM8euO850 +4C1Yh6SThgiXn/oIPn/xuYgsBEd7lDRasCgSmxhLNH4uMbmsGPMXSXHM0FFpp8Z9Qb8lEyq5D5lX +bMYw58GLh4DTq4jQFp1eaPqWCkpEDSAqM5GM8iBgngOYTJHln8zwQ0eKCjpxKlpcIGo7yVjHr1gn +rCyMTnO9qyydMcqxD1GGpdLEA810J+hYx2GlUPAOKcx5EbekDq84GOAhAI9gwPpcC2hytZmPLN4y +/7aeqk4pPBCD7VFjFNLHUFoRpsJ2aCWVS+Or2k7pBkvlpl4fHNKXRL2Xv988MW6N6iW3FnuXLlPS +0cqLGM4W41PqqJV0Y4Cyq6X7lW82YgZFfPF+uY86tjlUw9Ubf2nQdhqFWLNZTiL91KwMiEeTIIs/ +dwrkyhg9XW4wIn/YS+0dCLL70sv6zOWgsJVoaf8U3xTKqgVHAXnO6m3EwAIhYVVK9FejWk2w+Nwj +byCGrSWbGDHCLED1EbLCzmeGvNVj40RVIisxLkitWCxqSdnafDwYOPH89Kq8n08squwDI5S/Ziq5 +IYKqj4oTcIx13H0vOJZTv48s6f309/T5T/4/cAQcZtRjItiOgBdlWnBEDys7gAE95rOyrewuVj1c +0dH9PMGVkcMc8b1Vwk/46zG7U+GKqGQbAvZLtWY0cZv+qyd1ZWAmJ/Lxf9C5JvC0T4gg4/8Yq+q/ +waolDoOIw0mJ7QeGgDq7FEklaQgYc8/BVFv/0DsDYIJpPbbd3BmyCjFaccmNcfOzP96d4Q+KWOrE +2h61D+3DDegZw/+/H+Af7pH0P96ygg3tirXkYqVIZ4aP0utskpKy7l/TooKN6UHBW8GjkXrOkD50 +5znLLrLDtL/SH1g9bQLR1rP+E8+EKkw5UX6/Ucti0zCpY/SYsnNrXmStxJqVIvIYQmnEjMo2AOSp +wVA3O+gcTzrhPcFeUrV/OqYzVah4RRxHvKUQ85kNWZ+PUc2Wv0NOMoSJxb5kQSv9eOIKH3ojFPEp +fscHvW70GHUqKiPRi7pGOj6dlHY+Su5EfHWKGOb/3UBSBOiJsWY85gEN/vHztp83KR72G4/zARkF +VdjSVPlHLrft7FfDQ/384K4BKJmpK1PO+MvzwgC7ZXqsgy7++LlT6LYwBIZnfPD6+rF5hN2ky/sL +7zUV8OdGUX48XrSw0zi4Hro3vYy7xoopzHIcwj9exi5RJNtTcezlg+ztnVV9Os7KXUDE5GD03l6v +ZfWU5Yn931EA8b3eUyLqrUSWO6H3/ERUZQclEfsz6CAvDxXKrvZfYKgUhnp+NxHqT6r3YP76I3P4 +/I7X9ng/JKZkJfGHwwRfTo8zgCn2D4bb6jvFP0CHl8dw++FonXftdy7pKq8Dfc6P4QFkHdUfAlx1 +3mL9z1/Z49fPn+XriZ8/749vYE8OL/f/Mq+8PMOX+enDd3FPby+v8mVCfBkNrxPrB4PqZX5+GZuv +c/zz+P7JteLebf1IVq68/fnPvvvu72PF/flf/fL777/53W+++vk/fPXX3/z2m19+/82vWH1/sNq+ ++1z8yPHGkUv9lwf8y199+/13v4sF/Ndf/dU3v/s61uSv/o9v9ire3/7857FGv/bm//vl/x3r/ufv +fvvPX/3iu6//gN9w2d9/y+V89Tf//Ntvdm9M3uuPXtVf/OP33/3H3/7y629/83df/Z9/tlORL8/k +i87/9nff/VP2Q6yrFO0d5HP86Dn+5tu4j//07a++/2/5w/FjN/BXv/vm999+809xz3//Dz91LTzO +eDbffvMP70/mx3v/4pv/+v1X3/7mq//td9/95vuf6vw33/32qe9WMFxbwbD8y7f677759u/+2/d/ +4L3+9Xf/9A//6jf17z4clX/5J//TX/y8ffWXv/nV/mn++2ff/N23v9l/+V/e/vSvvvv1b3/5q+/+ +8Xd/9idf/HcRpUxWZMvAf74VKpdTB+Rl5og6qz1IgLiLHkf2KGxHZzde/Av/8z//05/8wAvmDiuj +5Z/95/8e//X/iT/+01s53v7923/5v463X+Uv//pO3X15Mc+n2r5lP3FBb7/4qNfLjf3iozP+Yb0+ +PONv/uC5Zr/an/3y6/+X1+roiW3F908h/heP8d2f4Hj7D8bjwIRQQZkt1sOILigzxayOewqLykmi +/LS0XlC7G5CfIC9N1I8qxhcRPbEJMKt+tJ1lfwOC90i282d/RdEsNl8TZYQrA3ZIKsQ3kFTMGF8z +FTJ+vRtZu06gx2T278ZuBrRBbo8IM5YpTFHwWKYB2TsbWK4wozgTwdUxnY4tPesQ5A== + + + HznWsfdAq4GwIZkuZaY+gtzHecbVQlSLLaAUIFZpckEUe5Txm7h+9H0C+G0SXFCxoLrd01MKM0x5 +r3QA+Y9XKEpM9MjFFO4jbAoPoe3TKXKZHpuC4EWM/JN8gogQ+lItgXLBqVfUoaYgPVxkJxZN2YMc +Gz2Ia7IH0m30mBuWBG6dLbTMgH40Y03yRMSI81SBCVt0WCCk9biByvNVSYIrqsJKCGdOouEDIBTq +fDATISXgzPrZV3EYM4DtOOWhcYHCtuY61gbLkFIAXIK2g4F1xjPz0yXQGX5uz5ANuEuEWpPMRgol +sUsgJ41xHOkoIx54DJOcXUlUaAbWnuS0umsqaoLfrmnqxw4GvO+sxi7nJ8AgYEZR8OSZ6TNrkXim +ma+dKsyi6MSNEB7tv5/Tamrsn7dlYKKJC/gzO5gIHBrRrcfhBxqdxCVwzOmlcVkMXKsE9hhD+kv8 +97xKJeYY2uWOz8iAE59deaI+9+FHagUKmG6574UYRRYtE3Srp6fSMRImTWiq4W4MjYPTQntVuNe/ +e9TRU3sS3HoTDJe/Idl2KucXw1bk1ZF29eRXy/iwR08SEwm9ti/6tdPaCIoDlbSdVUyf4z3cdVGC +rcEeo6ahcL6tp4a8/iutt15+NRNZxefbAOfzuGAWxZlzx6EDVX6IBTIU4S56mBHMxgXdY4ZexaTm +AfvVXgUDrAn3mn0JPRpPl/HG6BcMz3xTGIwJVqjWNdhgn4mKcBc6H7Qf+sDSpM+CsytyomoyxhQ4 +PEoMK26IMlZ2iMXLDqtnh2F0rs9yzR6nqIlJ/L9PhHnZdPYBwOsmITdasWZqDYze45jqPQ5rQqS/ +FTc4VtEX4rXHmXyvGMcY7u0zPfci/TsbrO8xtMoeW1uZZOKgQkwBMKn0CAd1VSXFdUHCaOyZnnvk +KIt3QpKd/G8qiz8fh+mdwtFE8ocF5ASh0d4bPhq8dxuEr6KbNCsCGLYTBg+bbnRKY6fcoOLIWGCs +xLcUIyshU7vDNIXmdMeH1HPFsUjJ0lCvzOQ7buI9xAtuKVoBo2zG1p6C7O+915nIF6UzmF3xPaz5 +a0oAvMWLtw8FGxg1BtVuu/iy1U+kMsc8Gz2SHQbXo5b9LFfiOqIX5RB7+Z1EL8ReU4Azp9B6Ip1j +j44oACZx0w7U5ugw0TzxROKN4hDxQvaX27ZAK1CaniuYZZdYwU6oWAyPTNjQ50pQn5ThyYcz0qnb +8g45j0FK57mHZzrnJscwhD46Duwy2Fuwyyi8o9ojph394AxRcJ8eGaIcewmmMSZvGgUL6fY281fc +mWReBHgIheaVDR8GUA+gsdyTTkIMiD0s50RZn7n7hcEd33MGXOeZ1MSV7HaBPLrNEWrA6eoIo0Hk +JIEyr/x4VI1TXAEuf6yd5dqeJFvRkbb4D9pm1nKv5N7E2ozZef46lTzIlzR7aMQePQ6ZiSgcwPeO +Hu2oefwIDSkYA1lq+0zTkUavA19PeonViF5w+t/ogcRF9Ijlg9WDHhQyo8fyRFMsFB26dGdOFFdB +B4TOt0hlccqGpNjQ5KPYgcgsTHo/vQ7yFWL5wnudWAmYl56UZ6/4FXbI3lSdVhwZEjKLRXpAQgXO +jCBKKFgNxmH4KrfhJELbSMo0tVJOrS2jBy6wuUSPgit5hYfFS4vHXZUxRye9d6Uc8zaYDq44a8RD +J1EQxVTIWkh0oOtoj52IzTWKqSCCZBo6hPc4aETT+VOLe2wmUO2+TyAfdaHmMkzBAe2jk8bgdKh9 +2OGUFU4Phxw+bGdegWy+RcjJos2JYNRxIiRF8kQQVSNEXyM5f2L4IQLHU5jSHFGzp2i02IOBLqNI +S3BFNf/kzf/UN3InhJC2YJGJK+ZVwkP4hNZefkToXhwowRwdyB+NEfJVBTHEPEdDofxUydyiHbBa +crBixeu3CuqCMQ0L+Yixd0AgSGBX18kUXYwD9nf+HUA3IDz/CVc/j4HSJ2H2WZFpIL4CQFWkIB9m +Wj/BY1WHwbg+nnFHU/1u8CgFVEKF/99KhrT7V0cSJUVoA1OqCN4ym8eIlKUMbLeAIIgv9RHS0niA +645G9pPtE0TG7q/8pKKhau3DSkWJ90oidRPece6jLJ086XwOKsVACUt2JvJHnKWoPxpR/drAfYVc +cKhFhqMpnnRf1PBTBEdewJCixuwePb7RWBEKnNX4mlBlYZAnJXah2ATmBWgGeqfH3qkhHY+zPUXr +i7YTaYYidxglemjwpHvflHiCDPzcMIC1rT2pvTTGN3pyDeAlBqT5mQXdeK3AqnJRELy/sLFcj4a8 +unjiMVOc7MwRJnr/FYgaufPagoNCRRfn5e+HkMs81g+b4oNRu4WHw8QDXIu5AicGP3vCT6Wsvlzz +gMGw5z3x1IBa/6krMUNDW/7Kn+BXnsfypk+kl950J95i6MoYSH040cGBa095OS+gS/o/EWe8bFhw +0g62uOydT7aPnhw9kT0qLl8+PGKEX7yfJcUjHS1O1FYA1vJI2vyoAXrBY5A9NUbgONUJjIs4OxRy +PbgXFLXYb0/328D72D/Eg6uPhtyux1KMbzMQ4Qthu/tXFaweDzS+MxhoAHkb6pzPDWNLoObhnhrj +XR4skOBIR6p7VPnK1N6l8Nduja6T7dncCY7SWQ5Ax6hT0vYbIF7z84tjUgZ6vBoYxbFonAnUGIoA +88g8nErBuKfHnoPFblAqUvuobskcpkKWOAomVaGulCUi28QfAApcW3YYoBuViBMxUriPV07bUCjx +rYBujLACr+2ABIxaki6/Wit3Bau96pxelxXCU+RzTTXrVfJXwLWj4VygVmjwg53AC/Lf926TvxF9 +0DlW9OkpvCUalAlxWVfRENWvbFB9J35Bjs6UQ9lzT0QZZJoRm+rsWwaodkY8ca2Vj6r0HZPSqj0X +lA8XszuCHKB/lA6IhzqYzoHOjfQtHWQTWARUf9H5iW1S3EbE4oD8TuDpWgAD6BkE+nzTMfMPjbEY +ZfsDobGwA2BZ15L0BAd/+ivTYsxbXf8hcB3Ibs+MCiePomElRkbh3Iebe0VEOikPQs4y+kKZoYGw +zgZVkeK063JZpiS6jxFvA1JzfICzaqr2SRv3AUCIsRQvmlwD9z2oAMe2SL2IBqq0l00eVdMK1Y5Y +wKZLaGGl5yhVxSYQhkhW7QUhYuCc5SYKHTBhY7XZsSdtMCJoQ5uNxpOPwgYUz8hrKaMrXmxkA3sO +64nMcnK6+/vhDic3aAHZmSdGZyqGPJ6xDw9kkobV1c5TPOZ+dSZXZ9Hmm2FnbDPUSak8J2HarDaV +Zf+lYUPU7uf1gzagmAeo9n6osnBicoPADmKUCtUAtvbqa89FIy6xg+h56eEJEPOFiszjYB14PQ5Y +KbK3i2LykVK2SBaQGJ5sJWOyjDuJjdKCOjb621VyUH62lneqxq/ozEitVcCVMZHucPcAfjDTBgjA +9oIp0LmBmupF8ySNvF57eANIG5BZmkzN/YPDYL2Rb/EUvINCFzv0l4aF+kc9H2PhB43xIi4il4HQ +DKgC9tHd3AAapNEAGhOZlZghWn3/u0eLOGjE9u5UaJ26/f0j5IVU5Yq3eJK3Z1o/P2jAjr3U+3DP +jVhuxAw2SDpfuAodzBpD44UJco7LPR8N95snX8CbZ+P4xa9i+YylAd2oxZ1AvEcQbAASYw1C8IYw +Ha3GcY9UEWR8p+SMY5iwYaaYbIMfC3uriGYHPGNHwJW1i2iYnU99UnI/H4ez4kH2vsSmlsZjFH+l +IlpcIVAJG9qR5zFEmCTS8+pcIfNw8YQqYwks23n58QF8GIjjKL5xNbbTNFzOhX4Yc38YLFW7IQ9X +BXS/d2axZddAANiNdjrJ9dcGQs5yX9RzI3EM91qYX9jqHqgAOPG4QnG16ICiJXcqV7UbPBwq187Q +KIC19x/VaVISsYhK+p6cJHPeSwO8r+N+Ys+Ni1wtiy96a2x3py4oJ6r4SbQ5rtTxWTEKWsrl23AP +2dy9p9jU3UYaRY2pFWMRcHicZrz+leixbmeul0amQgdUnMOXvBqlGPRwIhwYvGTQ3sIkJNA9GvJG +wR/TuKpi1I9fwWOKcCM+nZq2Zqy1MQ8NwMbE0LE1rsnME0mf0xFBW3xs0Qb9zzb2DjQAWD7N85B/ +24+zXRn0Y06lYdUA0bceR4OzQWMR/9LvWejS84WGgy1L67m1zl+cNqTJYawC4742RiXfeudLRNNq +P7i2JA+fiDCyTU2N5zha75/4nFA3PBAgvRtyijxNebLSxZD88lfXHoiF9Ed7o1h2Mq5fGsgLt/4I +MH7YSKJvRyWxh0KulaQ/1J4MIrk6Nb2nvA601D5NdiV5uH6v0biTZWPEg/5K9b2JiyLrGYnQ5t9j +y88/r0e44t8MMGDAwGfKTa8HWaw6aFjFqdmCdAOMvu8CSaLZbFj3UBsldxaT8xdfACp6b8SO7izI +x7q5Rlvs/KiB1edeo54bu7CvjCjUAwXfHJuMN/Gm12iGiSTz4/IO1RMfLY8BEistA6SCFnz/XcNg +UUHNw9RHKRnhxwxgUe1EPr8qP2b+Idd+WEqnWUlSz+SRcpvFXM2qz1w9SVmeOwUxqGdzBaSEI7J5 +NHx9p25Jiy+UmuJruBvJ+Kinciqn6cc1Ynv92vDl9PvSiHziiX4XcG1qMgvZrHiuZ8wrrFwxa+K+ +MgnJ2ReQJG73lor6YKapYmKOaTc1kYgNY3pK6ZYDdq2VRpJg88oN90nIzZY2Jqm18aHsw4rM30qV +1NQEUW830uxowiHZ2u+/a66DjjhTDzMwPKz7NwQbS84pRKPJNG8MyU6UsiThaoHnwY7p2oVp2uqZ +baSybGPnb4PilYPYIhv63dCzgXyEDbsMTaPi0lhFrUOzpoNNkg3Wv2A4ponh4aujoQy3yegA06AE +bB7u1BrwlJC73q0PaZjmCQpqwuNNuej8u/o5F3nSmMgm6fH72poVlZOH01iArIur1Oih0CyPfc0a +exQcOzuKpCdKUNSVv8wpofvE38iD8G/WQ3JMSJ3ZAAnI5FNXVuJQIov6+dhJPRrd2ERjP9NZE22v +t2ygjkrSM5aRaLiACXg4yyInGgkTTZxj3niMiMERvkPDHUwkqy8hhyqHM8X44h1OrYKggqnc10zc +AS6O468rJ+PPO99SkXCM1ayxp4Wh1qn0OMeiJtrAsb8BXfb7fPr7pS70Tlc/tRWutUC1hNfaU1cz +IS4xjzZqs1q2xK4BRGihfIAbIbEFnEQZbBWtDTLeZxMz4VW3LaeInB2bRQpnnim+I6WLmTUQ8CQx +qpAsvzATcks+InOgzjJScJYZrw1s6SrNJjrl2sqUwCfrFkegho04AtgCejSqQFxKURTkSm3J6BF7 +qjPFw0dXPJy/5Iku6+8n1iuPM6n8rWZhL/tyij83fkS50xUTIbySx3X48AuAPjTEwFzJpdo6suh+ +nv3gDsAxZUlPpb0YK62pFVx1dzzReLN4yHc3gOKsLpkFfC7+w7Hsk2hIAQpku6IDJA== + + + 8DxR36B3G5u/bqKXyEeRzThxqVNA40zhgugBJV7hZYuHJ/pGW+HCOtlURnsPfHo1tIijFxKj9Mqx +I6++5ZlW8Th1jduYMe/ADfZJAajmLXbMU+OnPNzHKzAEQb0YKqP2PD29pCxvS7ItA+AW+njvDQfg +JcDyccfjBh7tRgSfLpMghHmKIxO7XhpbdNLllO4j1Lr/nQmvQyjHo89kIPKxZdEl/xmrP6EFSvyo +mu/z7rZybD+NykauKZ6uGC3Uy1PJFJTLKhKYfLOpGQ6vKIJELJbra498D+lve8b/FUxYPzjOsVVk +402NlZ6fFgkXVER1Zp97ECssHIa4nfN6f+M/7LVVbWNoVWZmROYMDM8INJD/pXxnWvDInNvZKPpO +3xBBMW/o6ne5k17xNOgF2ZNOFbFItuKpTZ9iQHRQEPzYfk1ufFYqpHffKXPTuXswpXOINsvjPLmY +x8/gnno1GvPAf6DMRQ+2OdGjM/nQQwFZ+P8sYHQg6RAdWCrTmQt1CpAER38fNeYSqMdBH7quvTOD +Y8kCjErDuXTgQp7asZd5WnY57fH3/KKf4pPHj2RIYCp1Vt3wqHZiwPDSkK+179d6f2cvvdgdXNwL +jHZNfUoq73lVpybY8t9RwumskHOrgMePYh7+oMfXu/BvCnRNaqXjg+PwgEAmxJM9YI7yWK2v+qgx +mcDDjFxmrGcxZY03CDTkvj7v8qyGwoeqplZ9l/tiMuQr82NjvDawMFJGv6Ci3BvE116ViTeCzjPz +hgtH7+00bhUC2gGDPE5yJoCTCAlRoYiYHxUVzDYdxGMWlGXsBQNYBfeVJhjYvdCjq1SoNBB4lzgO +j9cehTQ7LA/2cxCl0aOMLckiBrzPlGvYYPLPXpj+0qtrpEEPJsATOrtQlrmheXFxfWYP91xcy7HV +lJL7gSj53IHGuLL0dpJXuVLvR5fyOCiou3SE0FygUqztlr1PBBbY/jY2WC89sEOZSQMsx31PL71i +b8A3ClKLbU06LSggv32/mToL8Stb2qW9+dS876XH1zuUgTFlRF/IjL4cR41mVnDGC0s4CvKgrQch +yKgf9Thu3OJr2+yJHhrKmDdxtKo7XEDAZuIHN0gtpjlE7iFNQU1GDlr1wucej/kCpG28kkKG8vU4 +JD61k4n3wKm9TvkskIV6mospPo9HDkWmfNw9H3e5S9EWU4e92NPRSV17Jrui98RIGAcdBA+v7dbD +l+KY50TGHDE9qYKzMqSkB2nFx4ly2r3z7suMDjRW8RQeh8mFHmiMiJiBxakOB8suXHUmEHEqV2Jq +jjWLh6gb48WTyRNNjebRhVAshZvoLT0iJRedsb0kRQpESRfq2Fscmly89thq/1p7byuY117UgtLz +pxUhXvDJLr0jIJ2lp5VuvRNp93QisHJ26dJ0vnTIYdedZJCRKHIMno9STs2IGVJLG+xetxR519UY +noEkdV2fRMIC4bn3tKVvRER8JCdXSbAAZhJGP6oB7PkSqsarYMlUAktELTN5Ar9NASBJNQkAIEqP +vZNE5ySJW6cmiyzyJvVLZl3w7GE3X4zDGze29x4Hi/nUWUNM5UuPrJt3pzDAGZeiP8+9lAQnnj+A +fJSECIneBK1kNe61x7WRbRGP9X5X6J97AfBF7hqAr2bKqpXyyC8AMzVh203QIbzm03vaWukKgtqj +PPASMSCItvRVPHejsKqIzdYG1eRoiG+vbzx3op2Og6pv9si9NaNhJP5ZQkDsq46d9bSXYyPm1IcJ +hhD7Qzyox5n6g2Aetc2l0uzzKFPjIl4PyDLIgZo+0CMiM3osip03oCfCBNA+2GHPbVLlQ6OunNCb +vOsLNP6Z9OrptaBN8GEPbFvbA+vz1Ehuqanzbr3z0v2x+VLR/eGlzsM7KLsHC+1WT/5Bj3xWPWO+ +a8XcfXx4nLkJC/FMKf6pHseWdMaAzIzHuCkpw0AMVE2+WPIcezOO6KYYCzZT53jt9Yt9OXJ5L0JT +qQFXOhcMeRfpcgEpgFzM6cRD4qxgPBLjCuriBz2I/5ltl0CL97TND3phZ0iwIvqYDx89JdGqraV+ +JpiY1KaaaYKiX8Ohhw9P47XHvdUCMU7ab4nMfTnOuakvMVXFApry6gdQZWw5psjM5x7P63OGss+9 +Rk/85jT3mlFiN6GKZdZWvAYfKWCykohgTXETcDTRp8y41+aeAtu0whzzH2BcZ11GOqRh6EBv1D1j +SqD+G/s8SBNtbkTmSFAapS49thCsKMbt26Qdf9uty0IN2VByIbriZh9La0DRwN2PPBGPJ3rgqcw2 +tKfozoqwjATZ3+6yHSTcE0Na1r9CBQTyBjUu1MiG6WvqzSe6O5fhf6KZqaOSCIdR9PLnTMf3TDZM +lN35NJ5/S8YXaMAAG2Ct/Uz99VVHgmqee7AbGXsP9NJIUECBHjit8bEvQ/luC6/YbXG3sX1jkrSE +XY7bHPqQhUOKo+hkFUsrXiBxNnfVcbQ5tOXJHPePYl9ucIySfT+k1oG3psRQv2QtmkTX6QqCBXOM +ZUe8qpDzufHXu/YfnS69NtXD4btG3Yj9HocBVbOkphV7CNbGA4adBD2Ea1Jq0S5u3l5/yKY9cLlr +18iJ1ngpov0kdsTAIY1+rPQ5YT9/wRvqpBTIpsbH4zAvm+8WuxqB8hVsTyXZpRPGo2Z8oCsanZSs +o5dT1STS8yCi2EhcnzPbNetl57msmlT1xRi+59rnUZ9FZdz1fh5EQOkFtDx7JdOBDFxebr+EXlDA +zT0uumqWtano0QCeyhsRiM3COO5Kf0Q5COLFJ4vTn1SNFE6NaJlwcGBGlJVg6RxupFIFgPTEuISM +JDOEFbJtG8f7c4cfiqXNBG3Y9rquk+lxYFoTn+mVdmkkryuTKMpNGqrFt8sCODDjBFzLYoVUlxsg +UKhYaN0qyqBoGtN+REcEA0qnUTJHkEswA9GjfyVKQVANVqjQpqzLkkdyNxE/OGDf4PJ3zUe5T7jq +ZLpxv3Am6k3uEBiSQxCJDWw5hmoBwwLhYd4TT1r8y+O4xx2c2UukfTQKfqYusfLnpoQAcPLFZw/W +SzhrtovFIYCtY7cD3eXwx10FZE+WG64YZAReMdGkrxhRx+hZZFZCFmR6SZKCCA5WB2EWFRjnUvEu +KUFxrHsnTo1Ux7YI3XEU0QOrK317AfRZFoot15h9QFpMBbupieKwOK+nJfAMhM2w0IkAp7V7Jp5Z +MVZDEAE+QlH8/5AzwENlEAMCWRqpkK+LFzX8ISCcrc4V65/V4Z5ibYOr6XfldcPESS8UJo24z8pM +jqQXZXcfNUh/iIw4H+N3pi7DqJpBOcbc2EJolGJCWYQ6wWAnvKGV9GKlo9ckPUevWAbREIwdmaXo +c+OOCjFNdiB1RofRih1QrWM91ZjGE00M8ig63LVpqvli6ci2sitFMBwaKFvgs+SJtOJjXWbwRAd1 +YWJ/gDJMdgCZwiEAjdJDzDiZzHkvkz3HJN9WMa5/tkwEC2hOCBoU5Lu4qH1LoBaBP1jHZZo8VEja +jqbsW3E0fQyDM+GhfKPVqno3B4DbEGrvsajFIrb8etALhtWeiNILdV7ylgOI6aQWP2W9xD0h98fV +Hp4rz7SOXNM4thKHRq4Y7pxNdCdn4rVxJryhFAQ9yIxx1O5yDVa2owKFthM2WBSEi8Zz1FYeUE4T +rHPnlqpAqfgAmZ+BElAM04YW1cIUz3Ruj8BFAO8cuIhWPxiNJNHUBFvzeaPpLqq7MfsJ763H+JRa +a/peFpEAeFeBBABC/obzXCqkTj98a9H0kr7Fvsp7yaS3kEJBj/Vy0acDiaTs0aTUnDnBs/+kGQZu +nsXbRFH0hmHVK2OS6Yp57mu5DCgB39hBdAK4NWQBqXCQa+9pW5Y9wHcxTLuYmCMrbX2aOt3AiJIV +xkm4xFOn3Mon1OGv83G0Iznp5G8Pkj0gbK88gWQOamekbcuVNSmmClwy9p2QmqfgvnxvLjkRfyDy +Sc4IcFPLUi2ew5lNO64lSRrcrdGOJrPohUkcAwCOrtFAXXRDRjIm6jsmShUz90K4fuyYyYWVqGrM +fRTNEyOuFgT/U+HbHQ9+oN3wp/8Gfn4swvXP3v78P37/u29/83dvf/qzn/3F11//46//+rvvf0nf +H4g2JGUv0XbFeAUttDcYQVB7fr2DhQW6Ad85jA/Y3jneN/49XlmPb1nsP7c4esKS2SjOe+4rG+vW +2MRW23DDpAECMw3Q420oTnUlMQAwwtErADz5DpUue31rFP1OPWwo59mQwDEMihsNa7oW6HjnvxlN +Oea20eQkO3MmqD4/nZ4qB2r5M4sxc9eEDcYccAgbxEGTUH7uoj0xWc8d0kGV+c1X33Z4K6uMN36J +yVcTnRgtGY6VKOt6oPoTz9c3v7DygG2LUeIwJXHC3+PRe9XkCLNBM8OIV+M/aXiHhbP9Xh6FVcvO +JvoWEgqNv1PjyINQR+TohgHIQN+L8gFnk6UzYvLDF0w93WjUvT1Zf0ppkBISZvkj4+rzH3EIk5pZ +YA8vgm/W59JT13/xvyvNs+jlLvECn0oqK3pJJmNh4tpM8YjhiJE0a+5wL10nCM8zB5ROkxc21Fl6 +PppnUe/1weTJlAqz5JmVWAQO6BXzVPqnCsHiOGxK6VFZn9k4Q4toN1eSS2EGKOClwG9A3X6kkubG +dcS7Muqooqjcs89Ei9RtXMxNXFnkT0df0DwHyw7Cn4mgcK0EZnH7UJGQSahPQxB1uQdIRYiziPkv +JXf75ju4ztOwMK1YSGHF/mCY9rh6KhTDOHiIE0SvgqI2Uo2w1u1Fpgtw+Syp7JfSeSjEGu32ZHPj +b31u0xfWDXqcYLvoodZd9KjHfOfcsd+xV9sW5U1XRHLh7eEdc3UjRkPRuFD/3jRVYfLWKb2bcrXH +uDl4uPUNsES9ElcQwfgiBqxDUUDktOE14b+uJ223uMdhIk65dDHVfJqsGBEKudBHDQd5fRN+FWA2 +9YyZWekI0wC8iuXKFCyh7rIOQU6zt22XTFYS8ZiSn2a9LITcpGl089gOApUDCUYGT7/DYUI6yw+7 +MIOIzfI4UmexmT/Eo3SlzcEOxpUW19eK1A/Z0DHvM5GNNSGmqHEWiazhkg8h5cwGh3Eu1W+kM7OJ +cuZoRNrE3rCtPnU93Zs+cn0x4sa93lMdo1J6KtE7cgdV4B5HiECe2WeTecLr3KreV2rrR4+40MT1 +4XDv3vO04ZT8+CgRXirsVEMhe8V12eukRAgHlkk0ZhyI+nt3qtfyOawO0YMBw+70kGB+Um98nOAQ +iRbbXqpN7iWZ19hLNn98aKQs4L57/duuPGF1nHbt+wJiOEjS3OQttK4pcKBFDhggVki0qN/6Lgmx +/FUrPShM1WTuJrRpgf6v/hQUE2lBsCCPcjNCyCp3FKueEFwVOye7ms7wFgNOmM9Lf2lnq0HiD1hX +DLyyUjWvf3FYOTLnMJdT0sWOhAWRe45Q2d9gSs08sscx8VEUWBIXlBUgZPnW1hdUiQ== + + + PsbtcVcx8YZM8mAzXzF6OslajaJaXlOxmo+RUpHCBcQ5oByXhSsi/iMjyE5SRdmnG/UJBI7YGDVa +L2Lcsgfkebtl41RuIgi05tJ2LTAuswqS28ttPF8MS1PHsCjIEjHv+Y4vPQEYgLXuW9aokEGJz/7Q +3SuuJWGZdbiqAG1I0ZbFdqNqbCy/HAcDQryYJYyMSNXMs54PeGeVVnkri1SldckWbbRZ3Tsvyt1w +fQCXxDnmBYjFwQWnTVnsCP5FKeB9zF0Ta7R7Imy7IIs2h4gHA4yaP3eaQ30ElBhLH6NOyRe4vNGj +59/b4ws+toF1qRio2KiegmOA5be0dAyjARnnxQOXTA0aHYEvmErxTjwuFggAg1e5ea43wJXHDMgQ +Lgx+CCkeLatakgFvzhQrTrFnxiL/ckzzx9wEaP6lRTG32OUxmqo2cGL20DAeUU/oWNiIHOnaSqx9 +obA89Cj7dKjHTq4KHF8E9OROkxi7oY82ds7VSSzYaEGFhlSX6hCg+aKTJEgD++WLTflg/Luvn4/D +nWm5meg4VW72RRDg0oDGu+fp6g1c5gxtmE7TiHJs+RjguVc6KC85vRoTNa2VseclC0yM9AYsESMy +NoWxNDMHL6n+J5YfW6wI5ZYYEFB+uMJknigQ0My/YDBPGPjmZJy6BF2YLdOSNbFP7SbM0ai0xgUc +S54zykfVX8kBjoaDuJyGkzdEgxFijGWiOjFe8/1wS4gLcRB+7n4xxV9JBqbsnFCXxNnbkEIItVWD +FvIS+2M6SopiXMlggHfqfkXzca+OAjr6jFjkcFgoCrhMx3x3M15YtZMxwLZbi90szyAjgW4ITvZD +x2/IsleysDE66e8sHDCVScyuS5weuSwUzQAondKP22kIgPH1uaFthMF4VpUbgx3Tusk4cAYC6pue +DCCLTDHPDYhnOUPj4NRMnTzBJ7IGD1imZe1oqKlnYa1HnDNAL2yqkNZAcA9IF+UyDLHnF9IaVHJB +BKHurG3m9WnT5RyBMZZExR2UiClatXd6kxgCtrjXxZLa3ljtu+J5XbsP5bpO6mBkoc4EaEiAy1z0 +CdiVpWdPaGWLPfB/EfWdxUIYuBI5foyzad2sHMoD1C2EgasSqQMYDHcEQiVwJgIeiyD5B5QwWXVU +er/iQuIkunGrmdhTT4fgmO3yrEmM+HpDT9D0oxGk2qORG7oMnnFbGTVZmIx3GtyGxbshtpcR0m7Q +PNNFbTYizQNtX8kAD2eeIla15UXl8GbT3D18f6CjSzqfk7UuO19wufQW8HMn8DtQVx0qhwAonE1U +nFATjTD88WmUW+4ABWQe15V8VU5i1ZLtRotoEpm+uS+VdPepBRgch0q5635eG0V7MdBihdFYzZGx ++ZqoPCESQJ5MiiQWTJISANrGMokmQfkC1uA1LHOwVkgJb1DCbESTDM1+SiZN4HXcqbTouFO0CZEA +ue6Jk8jEzQSWOahhgFCU59C2eBM4kVh6yMwoAQBDAUdBRBRuSqp0HW57kmBL+kEyYZBeiVF4QoWS +u3IkCPzyxi4Q3f0BQD9m5pUv7QAGgFtmU3XjWaMx3JRedJnXTB38lDpEzLC/scXZzErEIjXRIm3A +SoBR0ry2F25risSLbAGtcWoNmjeGVAXiT3mUU74RpgSCvQUYkcKgQaVJtsuCX5MJTEPae6Z3DQ0C +ze7DSYQQhaUqht8hN0hsz98JAG1oNRX6T4y+4s6JiTzanVVDNRP47ZjJ9UZHD9Q3ORPg2tpepMBh +ynWf5KMVCCnQdjwGoE/PTNIxBQMk4TTVM9SCrLWkVMvSrY/sPwIl8WnnGshSez+vmQUcPAfnEkiC +nWHV7DBOj6Klflb8iqlPtfLUBKX6VS3e9xv2YaPegdQqu1I0wxcfDZUQPeZ0RKhoSFmhVXcaAUsV +RchyRboPRyGLxogpq41FEfxqBe6SvHXZoGJDNtRuAy/zxKh+fXE0Rhheikfy3dNzMoUtqHSTBJfC +N7cyo0EyLxpUDVaCbX/YbWx0G0nsiSjqJSRC05qmkgpYeJ+cnAgEMSG0XvqWk69E9WZnStDCTDMk +JvQEUphOaKqVxB8PJh0mt54Lpablh8jwhaKFicqxBctSb3SlHnxjFo1Pdel8eu6AdkLuO5kCTMXy +i+owQdIsCVSxNGzwX5wLfRH2h12lBioVmNctnAA3NmuDqmJyIvUA37K5SyG5N90E5lRS1Vp+i7/v +fQwaNeVmoeQSHg810zRU7GBOkUsHDEiG8DDY6JueEmMZKbqLnd4NhuSTUfsl9laH/IQjzTwX+JKe +gFsWsViYliaXBzxqQrEmQfktswBDnIwAg2XNde/r2B+pph+PYMgp2YqRC5hFyQSJHAoiXDOEWD3o +WuaufCZtEqTAMqxdJ8xsyVLrkK91+bGCEpDwQHi5lXZT/TE2VWQCe99RZBzg4N4AUiVcEtWp7Znx +cS9MnuzV9mFmdujH3UHz9DmnQNvN36VHAvTowaZYBY7+fiLWaUr/wLjoBf2UXkJYet/wCAqxDD17 +6JWBIh9zGj0Smc3klB1mXmtfdxTaiQSbSA/YAwI93CdPgjcgZoiptMSUgI6xh3Nk9GgI69LDjPSp +mHFNNbqit0OEv8fco6mp00yoGved/gl6ryIVq3LY3HBTGDMnZxKxJFgwnqUMoit1ShIlLZI8Ps2q +mth13YSEy2+QTlD/7JWQaBBArFpjM1NJuyzdlI4k2lrSOP1pgvel/q7HcY0oorFkvuzY2AvI0Xl1 +IitPaSRn/pqdBh1wC+xWO8gwWX3dxzf5OGG09Mf+wpjmZKVdqQyr5FhEGzBCZHVZwosdSDP//Qy+ +ZNtyup8Bzdc+ULv1nbCqATk7CVBv6V2JFDdtjUXlSpMfI3E8OND34qo5TFH5/UZipWYwug6MW+GE +sB8BaKAwICcmWS3klVfKvIIvROaVVO7bOEoqGSzdvQBRtW0zgmTIBoIPbR0tXh1Kd5r2WlN7bnai +r4AupCCgnKgmNVSvudhPTCjOK9W9Y5GCYctzfpdYUZBy7niQXikrfF2nxH96dKFOECWqPXJCpuyg +3EbPwnI5t0Y7dcYbDWCVqGdjGTaSyfJXblLiRDDzs4d/liU82XHthA5M1sXae1fVDyhEqHGWanop +dkIohgKSHGfZVTgFL1Fb5fmVjc9axGLCu2pKZ7AQyYKjFtNNNTIRbHwGknNLrUXWljRkj7iP9eoC +4+1xxLbEvAzIxB5ZrcKilfLikcYt9EB/O3uwK6LHzcih15G6nyXFu0VFGB5emA7lwLE8GQOHMMdr +EZspkyg7kAyjQy6/RbfDPP6RFBQWNlFDFf/XorLp6eKDB5vI/7JLWSRZmTQIrSGDLJJ8LeVzb+XL +qqs9AgUdHgHoWbDll76x6l2VFFFCb0XVYYwuyVBPqsZyo849WbGz5ZMBx0yGF6PFs92T3tissJ6i +OkXHVlOKwC3zTMnTaj0CnS6PtDXW844DJDoH9EA6jjIhMQLB6b6RK2F2JFCRiLzWLagwsja1JPwZ +IgyScvzzJPF6RkgDWHmRVqQ0Zb4mvn/rSzePmK2Aww2tK4fbkV/j4p6ZOc6xEcQLmZ+sWVppiuOe +VfwrsADG4ExTWIrCx719Z5MG9NXgZeSHjIkuI74SEfKuTMrGuzqUG7G6yXEKHgJDVQnWcubVYwt2 +PRaHNTKppcnsSBKk73GZJFpv2aPvHkeyX2WmsIDX9fHxk0CLmeXNtl8bhrRQPTvOzbacm21ZUvwC +C1d6DFhx9sjg60zqNUIIKnpdKvJlDxLqHONO4DEcVHw4sQ313bJxm4Sa1CFZZHKfCBzqID5m0BlW +xaCD5+064rXEhnaJRwUZSmEyHnsEIffL2QJ0EeHEXHY6xKfA2uuQi81Ns7Ci7Kt498yjxCpZJzUp +tsRCbwW1XILQj+KqgQ3DzbVsie9evIeZE2N37jg2FqKpHuCtasC1mHN4e9fU2wlqGdfELv3o73JG +qrgsiBAxttyQy9/uWeCGgqgABQS9nuz4HVkP5QKwSuRwd6AkTI6cHnP8OhM20m99QsbIqKkQkYHT +lVDFE3eK0zTYu+YKizLTAjLXK9NdLdEhcY9C+4nC4hMjNw12Rr04goKlB3Pzk9WhMKb567E00osg +DZgA7yoaLXvRwMxJg2OSWPlEMBH/bieeuUHzKKmtx9ES0Qz0qeU5jawJcNhfSiFAuwwKQVFujsSJ +rGsW4JE99hUZDESD+dlcaEuspzIH0LEsb6TCU8lm6TuGftginD2vrfwFRFlcEiLLMcjOvcl7Rwgx +hbM+XhcKGgqTqhXJDBrhXUVdBYkZkWwkLMBRgMNCg1BeO+qMLA3HTugOYsiqBiVmp7miLrSvlxgG +hLSGSYA4TkyVAk3QYBiqLLkAgmd1c0KyF8BqLPu4A+8LrykEO7cuDZGRCS8I7+yxgC2ZmgR3N688 +jrs6ym0EqagMSaGbeFuurB4ZkhPHX8etRZSe0IzxiJeLu0Mhd3E7x4ZMiaEmZT7lraN86Y1ghI1c +FDLz0rPBsFqYK/d9LAv7dMKLx17dCpZK5qnPmUJahWlg07zRyaAHWxufGKVWdiCY49gj4uMLfe7j ++AJXq5Cg3jrVXlrvcn58C+zBwkmPA1Re9MCwgx7xqlee6Ups7lR96QBuFhEDC+F53LDqkVVGvGcR +SqGEApdQ6TGV8eLVAdG7RuY1FG8aKpzFQkXycCX+KiGJNwoXzA6h9KHOmrqPW8BvbIktAMot8w1C +Ssm5KN5ZNiOOaVGO6rNNzuNMXnic6ZKTzigzisFoCRxnU+KezNDpQ6RUAVwbOVW1Cie8z7RQjDke +qBCwhB3vYyYkcpkQ+dzsSqmEsTaIrjTTwHE6mjap7DLxNIwephulCjD9AEBAFG9Cmj/eYbOQlpCK +w7E5e6WZVQfCppilCybJImlfbG7klpNC5k6G2SJKkUVZf2Iy0xB4EvYb8ZqyByhqFQHLFJiEdYji +7b5T10zWBkv47vZAxkQ8IR6urf1l6WGdvh2J7ziFnO3R1LbAaEWStSRWVPwJySMG5diKrbHIzU0R +xTgYMI4ocDB62+E1l1vle8vj8JYLyQfLFEDRRPciMVDL47hJi5ms1jM9WXIi4c73mfYVLEgd2UP6 +WkFj//1M4lxgtAu1UTsl5T8FChtApeUjDkSXErpbH/TM/mRCLr2+HvJyyYPTxrEt4Q9TaorwUoVv +ElYthRh4DhTiNvNzxA9Mxb9TXuwwiZ7T3pLGwN/EJONyY2WC8gCQSM6S+JDEnwDsTn59TTegqS/G +XhB0WUFxLtbrTK4gIKvtZpVazgnhQDPy6zQTRFlnaNCGZ7t3lCsZzLqR1p1KqkyZrRtfai8kdz3M +yl7MYvQCKP6LP0nqR80jIDRuWuJQlG9rbs+U4slfa5YKYqlvmWEpIUQ+fj7pydrUOtwMuZW76UEe +Xe9fZKwYEL3hn/U21spFHg0peLBoSKlturJQy86k3dyLOTSTWX0LozLiD2DCYGuaBQ== + + + sEqalllIIc+Ji9hppKbUdIYOZ3p+sOGDGoIrQjxakwy5NySqi5AK/NWpnu61Nz1o1sdS/KV+iJRK +4urFNjQCAaJE8D1X+n4CXQM2S8VqqXCEca50Leyhq1Ln69bEEvI11fsn1LUswsoF71OFdnQNEKyl +Nk2Hv93bOTkyVp3QG6yJGAYbTt6cIEG1MsAZp2qtF9AxyuLnnWYgF6QKdXx9Q4DosRXmvMIiByeG +U0wsolJORSdcb+DsQH2hGnkLz7DSiH6Nb4J8x652US/M+ioCr6DczqxTq3d/SQtHElM9a3WaP29E +phkOHZtREt0O5FaqSOVQqfJXPUslPwpS+WMiYf7nH/FL/Vcf6EfNEP9X//PY5uX8j+aET8aTckDq +pRrkEhd6bDPb+KJ42YnMhwPiNz2LScDnTpI8nNKYPEv2YEtsg4tlzGXFXWrdMT9ZuHI+1kLU3kD1 +YlQwFM1kBdWLzQ/NOhqqyCKjNczJsma7d8Q0RlQNYB3QZqOxZsIHnwW+whh9+OIBAKBclr9Y+xfN +XzyKeZ5L++n4sikYqkJPfA1OQnMaZN3blTX1kodTSWdhK1lVYVSrPCePbVwyE+H3xjdab5XOlT6U +i4fjVF43b5KFP44AKqjeOtxt5g6GuMXTrCzZMvWqeUHWVWXuLaIP41d2ODY9RJ0sU8iMergxtOMy +hhI3eaXnwlDk4eLjhSopMCRfzyQ8rWLwGhsufAy/nGqNRPUU69nI0Ugxy9OLKWuAkzq20jWlafJa +0TCtV6A6f0tbW7fm4sCzaruxL44G8S4ywE+lg9XoVyfy8t+PPChaKBSG4JSq/tNzEoAi7Ywaq4nl +V4qIh5iXscmDeInC+N4NHg6VxBOCG9HK9f4jk1dEcwVtLsvYGgQ8/x1phi3o+NJW9pISK4UKgqOm +gwhxLiGfwqWAmGsqxe6/eywQzOAOBl6awr/yN6igSh/vCZkiYiP9wA+E2Yxts4Qs/q0CThsUZdAs +q6YyvurcNBB0RsPCc9RRp4Dpygh+QII8bXhA1Gg0s6Jld55KCcWB+aVmC93V3QbJ2nhkEzBEA6Jo +HO1W1xvoAlFei+8J5jZV4eTlrJ3ZiRGoTSKxL1HJy9+PrJjn0Z4a2dYuQ4l0zzYWA0qG05yiwadW +ZQe1mhjOJRtuLwOAG9f736bbzZhIOhB28Ivzk2XUl4YvB8ZLI/AvRZSx7+nor6PNsqxtkxtjZDCF +MyoXGQPG9qbAMMowrKfmuyBDMpc5M1yK0YN3PLUUnxdZhp7Uvyt5HjQyEdIoiMQGyjA0UCSnSiTf +6FBjhL8PMJfkue7BSVupHmwBekeFfO1LAHYM5JIPmL+r7nzlj/l32+qDfBVV8cHaYz4YTH3CWxhe +wp3lRTU1Zhsyz/A5ZQaNZAg/GjLJklS/R2dibHf4g1RnAXZmAk/R5FMS44FeWS5jVKpYxo5btp1e +csnVGcpe5ETpBR/F41iSxMwwUxEVwMl0JZ03KfNfXJD/xTCkiRa+/nWsPCuy5hP53NBoPxKxoX4D +chIW+iaCNYIxjR9TINDC8+HXQthVlKIqmcIj6nM79mWsCAJSkcIkM6rZDYrRBuoKNJDoR002wZRl +qyyyQEmNSUno+3BZ0EfVcioBPo5UNlQLgvSbLKztwKPcphp0kzVt2nBtPQQr5RhgYXyg5Hf/5EYb +soh+bSdEyalIuwAQ2Cjpf7ZIAqXjCCts1tS3kxTjVfA5kGTZMrdgtJ6qyDWk24l6rZIL4lydDcRI +Fd8bs+ouAzFX+JGIeVHAsYF5n19dphhzqpabwtZU912U0QHi34KDwKjZt8NuQRaVRkJ9aMekL+Lv +MNX9+6kQasoWYqcEdMWGByy3b2scNgHOuDg7X44S9yWnlXn0XWKOUw3uRwbd5z/i+BahazakakBh +nV2VJgvgZQ9x0JJSSSo6AAkU6HyVA535K+vs2hrSo4y6AQdtAw4QVwF9phZpxARm0NaNWWCirO8V +/aIVHOHX3JCEM4ELgzKINf82dgPMqGiAmkdDgitQ4+z7p1TGOcF8VFC23zWynsQRUOlIhFx4hTI+ +TxAwFoVNwe6006HDaOpcA0ok0xedBM6/9Mhw9so6yEwizGsvwtQusZb3u5J8lJw6coME0oCT5cU2 +ADaXfDYNpLGobse7c4Lk1clnRjr7Gon8il7QXT2On+289V6vkbny6NGBN9MjKfNtNZXD6MHuE+7/ +dUcVxEtuc6Ba5GE2A3yglJPpV0Ll2dSyy8NQjoXeqNGVnLHLREa8nDwRdXp6xInvTHLNWYPce5X6 +tKn/RD5gPsmuyBqYhFpgTM7ESJFCgdhlFilNXzqDlPzhmSK3CCLN8b4kkQKCQziTS34kEmOIQZ1y +kGWbz8Vt7nwVbsMEWO53XnqI9jSjU9d127y89hq7Ph7jGeiFPiQp9QLr4FSBytL93Iu2i1/mgGOH +JJXoqcfXO0WbPPFRBq7mHxxno68mEXTJazFGsoGaHw0zUU5S+iYz200/fumFcqUOn1SiXcfvfDmj +QzfuelO88NEphhJqlE5K6i3ZVUYMTDtz3WfqKUjEOL7MvEJhkWFV0h2KHib2o0ffKm2XCFr8KU87 +5FOl6LstmhEZUvXovGETpBYr4wBu1Np0s5G9hl4+iqqTEtPVNjXGqOuNdkNfOoiBtZlq1FIKQLD7 +BOcesJAv9gNhgqHQoayCOzdLF12lSR+9QrTxfLouTi89WtrYWu247nTtcy84DNT/J3bk+9EPc3iZ +Po4ex5Z+nFBN0kdHodunv+fEdru5xevsQg2ff0291KwBonPK4bLGXR80UHnqlB7ig3yI8rz00gBQ +YtYSPSnNfWUaXiwQhuJN06C27SxuxuW4dYMQBiu3xtqVfAPgBoiowhv0VR8gMrL+ChDXum6qZz4P +Bmq5mck4DgIUHXpl7MUEhWq98c21gfrosJaN90tdR7070+FYOjU5BWUYa7KngWFkSiYe6yxpO++S +Cz2RCPvzDdbIFYYS8Z55lvlqprhLGJoSeBF1pH09W3vhmjHplF0Th0chK5HySnzUV39X8DP131EP +JYndqQAmXEEERkweOERmD5Rf6WGch0e0yq/xZtbcxy8qnM5HNVvYw5k/h2PJyc+1cXVpQXzsJL7E +x5UNaoHHqEq552P7n0e0dMv6y2Q9U4xLqFplxTx1KEloImpbrJXzyKI8oTi5ip+OiP6Y+wsw+hDD +IlzER74q6igmx6U4nmMy/2IUC0wHTkKScJ43LbzD0nyLxnx5+muvTfq2FDbRVLkUQ032YBEBYQ9x +/wPtx3LLbh5J2o9ex0w5MPQ87XSqzXCYESQuX6K8DKhAKOEtAVj+2vo39Oht67vUPMZ690U9tpd6 +QeQ9w8FL810eN0+kmKu8kaWCR5kF7KHxvVjUYUNvGyaYLI0qVQL7KyWU4XGCrpLDABOZWj0UM+xF +B1CW2LCcQ+J+dEBLrku9V3RirBvJQeZbuO4BRg/hqMmqJu6Wn1UJGVTakGYtgj4MFo4MFjqkMZQk +OyQkFOlmLgQJ2ywKVu7H09IEInpB9M5ezhyggUYyF9WahG12jV0UU5quIA68exAz0UNqLHk4No8M ++HdT5SZhyF59Xw+TFr1aVW2D8qjKDkP8NCsX4SVLOchOb8niXr2riuB494s+L1PXRTJF11ebgNwh +C5EQ1j5QM6MUFmRklQ9Zky896h2MUIS/7pfShVZmr+smCwABhCwwmvq9mlteWhF3PCfYYJUNCSAg +7GP/1elDPAhcqdZByd4/AOeiGoIxDKCDqdNxaykeoGx93bL167bcScMPTDPiRaUrRaLlKPnWZCqY ++L5Q3olVDE9sgnL4ZIKXI/4m0/1o8Bqf7XHuRpSTSXLDV16Tb7gcZhQuymgYkGaPmT3IMKURyK0F +8tyoCbPQZNF1ST+z0BVxtx/KENQBGDhZOHUn5yNAmG5bsmywe9wKFJLnhzrZmMHZqZ/ZSVET6sPp +HTOK6iyqIuM9gqqXwhHPPaBvVOOJdrujfdDp2OL86uTx/urWrD5iSVspu1+ZG+bWxu7GQwyyXQd5 +6XEPmyTytoj9P+pF6W5J21ROs4q9YN8F9uLU8xXKpdy+jnjY5VeRrAd58DcpcmN6oteiYKNWrXLQ +kI9JyJSV3ySVfei/U7vK5HSeFgNjskgh3JYkKrPFe/fKhVrQutihsuIALdDZJ763Q+Lkmeag8KgQ +oLaHyHoyMzUlzHP4YvrlrbQd/aDYeUueiJtJ7fzJTO1mhXR63epr6jUZQJQ0n6Dc0W+OrlbdfKaz +vfbIt9LTwwN6SMovlI3jotfMtytUH2VcHKC4UGoOxNVdf8nXHuPTNu3QgWWf6aUXRWHeLi7J8sFb +qm+hTKF4NcbB4jcxPFnJxb7cSqHXPftrj3xoyMd3dVnavD48zpEFAC7EtzxyEodg0JQkeuogX14z +CiAie0Q/d2IGhCCCksxoaXeVHusdGYGm4kTyfJAFOtKOLBV3CuJO87XH/ZGi1clH2tC8fT0O9sWy +YhbgklwMFD0BP1s/7MH2SEgEO/mbbts3aM9eZ84qypNAOWjQkYH1pWANuo1DUVCUO1COOIkVGHiI +E5A1FJr/0iMfXkk0BMkNIAGvx7k1vkBm9DuW6kfGUkWF9F2b78oqF5NfMHpO6jp3KLVyNzTTj4l/ +L9KQyK+o4E5DRVkGU66WPdJBjWDRDFZP3StFtY/34+r+chFmXnkcY3nOXmsep3v9hKsbgJV5wYj8 +Fdham1t8bZMBBZyXJl71QVkuSfugROGLGFQ7U3tDr3XkubQQuXZsDJdFjfnqZxBrFWqJu0PdHXaG +p53pxwensiGC/tJL/rAxY0UTqiiNqYZI7AbRB/6oR6rHI233CGlfO6EfqEwAuZC4ACrZxVSViZ+I +OmCueR8IM8IEOVwwUdoQShCLQHuodNWc0mnUYoUVAvtlPLRSeCDfEwIeAqMi8q8IPWiy1YYdbiEi +KOz0iOj1fBw/hToOvqhpr2Z6ryOTsk+UUemaDvvLbK1KTriG5wup+ULG1hwyy0GPm9LflDhgD1Hh +LC7ffIfrM6B2yfo9M+ZHzVEJf+jappNjOmfC+6DHKWIp3hlV0JtI+txLXbGRumLnOY0xUyANUXSF +XJ806mMeFsf1ocK9VBqkAE6ZqrvX0pCnZ61+pe4XsOQco2dupVPYoykAsdzOrJ1MRYpsbd4ZIp4s +v1a7VSNrQs9ZNhuqodh1nUfK8mYeNfqCVCNazWvD+sFCzlOPr+/Slm5To2sl/Xocin9JsosPueQO +Fa3WhBn21w4fro3PnTTDZG7Gd/skX6BmePLGgNpN8EhAEbRkgWwTC5NM0bKpgORegP1/3iWKXThQ +cVdyC7KVUGQjoiRxMNMWAp23JXEpbkTpKOqt1MQm6GTZFeCiLwlKuh9OYqPj/ML9dNZ0P2UniW48 +tUjGRYUg80wkeOnx+50cctp+boRzRqIERuvhHhKqNxsa9G6gpaBjqeNKxEULBTLJgQ== + + + sYZKDiwbpWinlp3WuDvxsuk01z6MeTBcqsbusbLHga+4PVb2AJ6XPQjh6DHvM2135KWFyNpcxUOu +4hJSpyunf9/mijHRzaQqSPuKX7L/yR7Ifc35jjg+ti70Ii985Wu5StIYRO6hi3ma6Yw9EdlbfLdF +6B/x5HjnC3DV3PaOqpXh21BvEfZb4BPf0ns/pKWOlh1ZAzCUjT+sKtL/TkOnwZYG2kM8EoWYdE3I +pCgGvjfwobWNM+dFH2mbsBCnmFRHexpxA1cmdb8JPByHDNaiELTs4XQBJOx8Py7zMr8yxxdtaiFN +KuQMmA86aPkxqbxRjOSo1t1RuJ5bDh/WF3L4687M8tFCe5pSLk4JDxW4BzsfYEKx7T8Ov9HLKh2g +Lllvpvp7xnV1Wybja8c4n4pXTT/ZfkF7OAauSDJOskYgezjlv5juEPeqMDdee8Amk1fJ3PTApa4t +nkyvriur1hmMoBRfRa2xYv0qvKynZR/FEhD/FVwsW+09HlMmAi7naunj3qoUzi1pT3RB8pV4aaD2 +dJ0uMphgNdQE5pHAO2dGNu6+2170xaHxkFB5pl1hNJzkMfRjRNqAsNALiBgKuBK/6DdBkGiw5d+k +Vl1rc+WADxWPknJJdGRM0AAKHw/FhyiN1ohl6fxXVRpOq2LWT33nEcoT/Zu7ynNHlBHl8Z3QQKD2 +4CwqTgCjAaFoG0f+qks0nRo90DAUGCIAA05Cw/Ist0iHTbjt4E2L5h5VXklfHKykcMFc6W6s7omn +J/2zEIP07EIF76clhD0eQnwKU6MRPeyPnlo+ixTgpdWojiI2JCh5nEAFri/kcl5+JSGsI7YndWf5 +1JXCh8uk6nTBAE32Z1YuFqZ1958zmb2Sy4+HTvIt8yfUM/XnLBoIb4IjWJkK9qm89sAApLQ7t//U +eF6J7SR5bon21AxJTLZsJj104kn779tqEFUqXyHUxWO9d+Y9xZaAoNiE/v737dH6eJdLJLraMdTe +ly6l5Bje+o2wW8SY8aGBGzu+eCiFvyhS3de6CyFZ47rSMIYCifrU8V3Gt+QhbgAfbdJ3KcGQnOHf +aOirTAp1d6PcbBC9TnE5bUAjVJqPC3FOjDODE+PqFyVVbma4tunjlbwrdJRImw1VTc/UE3tpyJH5 +HES8/JyRtxVcl8V2yJlDNBVY9eu1hw//cYKnRnxoxBN5WQOsrRLFCP5rjKviqWRKspl7N31tOMVE +lbY/GoXcyBDI9M2bMPNLgRWpKCeWE6oJgAGWl3+tUW/5kLoBO9BWR1plm3klMa3hHyAcLTfFuvcP +0qrPPS427esd24Oxpo3tUMNraBOO4kXKQYjQEmCk0CTMBGPFeCEiq1syy3Igb1+iWOxPvF0Q5BYr +Eg08XBqQrOJHfhw98bZLn+8ztcrujBix/hY6mwrV9zQIWEvet7hFrsCjpNzyYGCqmzZuzS3oHxoO +I1IIpNnVxNfp/BlDfZEuB1ak4+Bzg1Cr+2BPbXAB1HKEHzFE8FwprjLuJa9uEuowUXT/PWfJzBQa +4DaFW7NROYasAGI03N4IK0S1P//9ysXtLhf/oPHWdqRGqxU8rtVVFcaEtLK4pblrW9hmPRoe3126 +4uKaXd5/FTO0Sh8LoYkmw0N0F3ggcsI+k3tjeCHOsfxb8VvdcvjEj/4Y9eojG05XurH0JassL7eX +NI1GslmhUNxPla+yuSwDiQePpnBe18gE5OmID2d5TXXenpPn3EdbfHkFpsdIkwPwFhBUSbOC0VSs +4fnvK28lD1V3QMPioU7GVoe0mkSsHuMQYPcnU8GWy9XXjw0yg+puyOgsharICZ94ED1+Vc5UMKba +KC965joBRzKRF4kFNyqTCQ/hgLKkr2VjlCG468+x4NupOZYIebjxbCxJvUgfQnty7SCvbsnoiPhP +aFs9vdJFRkAejh9pRY1QjVhDaJWHKJB2lfQWWHPrw4JnyjC1qhH9/qu+RR9i14aIeCITgdM/N/TN +SsrDPTe2FBqUmZZ8u4ruiSju49qkT/WwO7wMYfT1SziPdQsufZ3ZKJId5MiVCLWqVGBq+vn3Ja2y +uyUHlP/gN9BIVQyNjJowN43VKbcgCCBrkEjqmYgKfeJ4YJjw6xP6hnzDlGhVjsTErcSyzbbvXUW6 +1wasnG7bi5fGMwVYxw0ojU8cTXees+qLoHp2A2mO9mjIw9Vc23XKSd29/atjU09GrK3CFUFbND06 +kgA0AKlTJMtn7GCj0bg1GoFyd43rN4+wgW9+s1AEAYM9JCVe9pAxiQKWr6JuXhqQ/LwN9Z4bC4xb +ETNjA7eZvycWdqi/QWa5asITcRECGH48wkYZIUwLsR7Fn/vYLKFTdxVSWcmeyQZ2RGSLkjfwEAx+ +aYzvMuVoweyYkkpbH7C/RpQsnmrEwKQcK4Vfb4m0vnUtsAGXCd7BjUyZdKoWIDXsVqZuKDFzI5Ra +JXnjatVKbeNRtXWBRjkmoncIi3jtpXo1ey+qMwSjrPw4ksgWjBkVYi+lpgJenoy2WshlS5pc1Nhj +dgVWccn9gVOrgFhs5eZ8NNxwgyzFIgoVL+1uRFUPwV7kNCK4fPxbqR/qTQA66i3MfDdyvyRQQOwh +so5AYSo2D7+M1NzRey4+l3gyaipjrMWcle4U6Nihacj8wg7988awIMMBhuVMCaw0fG+LPZPKuqMf +2tpuBwHsaIeigj8Ff/ljgm3kFP4or/BfebADs8fxJVXQ//Kr+C/z7U//7O0//6cfP1l5+/Offffd +37/96V/8/K9++f333/zuN1/9/B+++ve//PY3X33+7rf//NV3//Wrv/zVt9//299994+/zZN+/Iu/ +/ua33/zy+29+9VWc4gcXdz2u4Cfoj/+B/5QhiNd2TI4FHQsWjYicVkyraFHGikvGtaJTEKFkMvHY +FMgSh9d68UGpbHAwjaBXFaPsDSQPSeLHn/3VQIUiAhBwLNeHpMtYU1I9tUGBIHSfoNoSDEWjCKQ4 +3kK17m6kwaxXA4UIImICSr1sYHdiQ4n1DTzIFgau7DSAvwjM7ClmlOJjilhE0CVQc6icpljT1IWz +v1U4QhFZXIh0gDshLXmauyxafHh8UA3IZkYnvM3McCrADxM09ipv9uiXPSJOT6W3EpEdPQ6Sc3kM +8qNxjF52lvTax9+aaThkCACYEZcgyz3TOokfgRnMHlM84dHISNJjEc63xmQxs0fvHoN3nScYPSUB +GhRAcn4oVlAIQbECSGXF45D9ZmOzpu7Wk/JFhRiBhX2juHimGJuVUBfYnViv5D7hwfP3SS25le1e +jTJRLPExylIMNoKYoURWYv/eqohOasXguUqiHFNioZGozomqblP0mEKFzSXqEh/VWUGL4cxWc+Bp +iGFdfaUz4GSbVYdud+xMIXkD5k+EKbdJt52xoRNqgXRC6Tc7YYZIJ24E0e+atWfYm/x9rjw6Ait4 +6annq9O4gn+XFJXH4Z1wUSJRlWqc20vmQghuHwc0ZoeXtg3FqeVa5GbscgFoh0SHI6UbCIj24dOC +WPdp9K3BsBWhW8eJIl38GiIjPsdrzoTULPP7JEbE4B+Y2bX77xy1mATkTqpKQI/fnFvLYQg5Siy5 +yEX2bGV82IP75+WKfN6Hf+m0PqluO2EB6ncIKVdZ8higQtLJ9lqen2rCU5oTofDc4AkiHBKQ+vKr +Kxf9uOlVtV7EEeXiCz+mVLgr7dcE1hVB8ll1z8O2XdgsMWn27JUwmgIy8cyfp1dmPPEzBSpzngGD +6BW0RGVoZDhTHMSZacrZvc/TdHssWytISpVSHwBnh0ch3qNHw7ynZODleRRBp8eA+THQKukfSGXm +mYYYF7klqe7SMgca27NtC5gpXBSF2GknjhuxA3DcsgVee5zuOBi/ZOj2mZ57gd2d1O2RJGPOu+qG +rxZVzLVjOoETS76u6ZOJz8FFHkaw+XMPz2RsWOPAWEXz1b8cR1FngOagVpijkb3XDpZUkuaBzz0+ +GsYvnYB/FYvDLhJsqUC6A6lXAXjq2i5kQXjlQOYN3BCGU9lhqr302a+kJXRWPyUALhOpzwQEbH/d +obYQ3Nw0Uq6m4H/vU9ho8HqZCqNRxVT+XrV9Anu8sriraPDC6XgjHvRnRnGWF43u8Q7vbDwPfYmy +oIqlBDyo6DWtw57Hru33ngbY9AACAfXHonrKFtNBfRFPdJTiIcqm4GGKVixtVxSacinTS57sOqSU +IsSCj1vG2cw1XV9zPiUtZ690TQUc0tp67eEUWtJ6DqfSOT86TgRPidLEFEXf6Ng08V0SrBwZrGA8 +lrHKJq/ZxixOGyUMIpwx80fssGmAxGVMxBz3o5HUHVcnwbXdxfK4vaYkKNyTtUTrFkpZwtDxiWAQ +mgMDkccOLC2TeC840mxpEHYhCuLBAkAunqo+Lvas3RTURKDsDcpWjaFtVL7aJYEVsAdJ1Ja/BuBS +AC3y4oDAXOQ+epy6THtcsRrSo+hrRClvauSFJepGt8PJIzDxCbYc9kpBIy5IcYweOFvQY5D9swcV +x+ixPNGlWwMd2sr21R2aQ5FTz0PyiDkcyHwlw8/8AQ4DtQq+t1aTKhofqByPBEYJC4mJlYx3bLBk +VF5Eyq0m7DoNyoseQLn34kPAdS++Fw3R5KEIKI3Zo5G2U4WVC4aTl/rYA3yDnmKY1rStYR8zb3wW +IyW/d6rWxokKllFQS/qIBfqYeSnS2EOiRr/hn2Qghw06XcM86yN/ekBaYJvR5vsJsH6ilwV5sZdS +yVrCtehBToseCYKjh6OO9PiZl1CSH3ZceSUbZjqRwN2vZCVBoqBbWzI0SawoPA821ZosQhID3eb1 +nhlmTfNQbz/9kXzeH1VDuIhlp1bmZBVyUF/Nr4iSIA7sFQr1UD2Hgpg/YpDHj/B+p0GVHhqMooGb +7+WcvyGORufOQ4nGwYdPA3ofNKRnMQ2x6EZcRhqJg9wQ8ojuBJ7H3N0tR7PxAIRcVRbQOYh46a3q +nd5hDQ0Fy+6G3CCURPI02K1Hff8Vcx4q/uBUSfrWkoIGMX7iI8PhXJ+S+IVMjD114j98+R3HOIrF +hLwOYZUNDLD43nF5bqpFxsViR4xzExovGx/L31SuQ5ojwp43A5eSnXMLEB8eJQH1L2f+PWYE/l5I +NjXcaTewr6J5BUKHZCcxPz56FIsqgF/dlGtshGBYANQZbHi66ca4dd3/cBW6K5cVR3m0BT2ZJh6g +HpirR/phNUo9JNNbuky8NESEfNRdmnltFMoZ12BGrCAfHtvNrk0RtcFcE6pEEEiq5dGQV5cmSqxL +FSfux69az+mnswlAISwL5S9/P9zZ5LF+2NQF4+XDwUQDyQ0+ALiiV0qHDtL8iDs+lryWgrbq2pO8 +hwXnC0OQPX8EVWKkVKvH4qbRnDDBhgDnzsJXjTaGjVdqHaS1Cw2gmC+EvClI04BmDg1NbHrEsqjl +SpPdSIva6n77ESxQnuaGYB1UhR7Q0kbkAvWnI6uBrw0jRRdylD01TuajlveEwASXXQ== + + + oUzPMwsYbLz1sIlpoyBCdjfkZ9mS79VYnMf1/itwHmYTcFXBPaikIOtLgzIVm1f10iiTccThNDKO +xa9F6FVST6bGehBBjng+sjV4mXzeBxF22npmO9Ur5AUg0cLnB5+aYuXjzZAP5Hk0rRc03+GBeTRB +OTFVQtcvKsFneSKG/ydEga7YfIN6VrCJJEC90o8MWheQt/TDu7LmTKOb14rwaMmEP5N2JWYia8lO +WggWGz4mj+NI8gY24l2llrzqnKEPwcvR6LPchtL8GVk//qw9BQ18rjRoJgbC/kZ2I0NKWMu8o6xM +vNIz+6LwQqQFpYkGUaE2FEXKSazUh8BVTvfAhghTMCXRwDql+1gHFGCsVFxkE8bK03Mx+XAdu6NH +mF8Aq6CG9cYqA+17jG30XLaLS2G/eFJZVIEKLh5SGMhDVyIOlE3RgcLbD2oxpn8dAnw93+WZaUz7 +oggg8XB0VqZOfR7bTwd1rliGadDLxk1N03nwgLxI0FV22dhGDwI0KA9iEjseKexzIIBTG8GsB9MA +BtIF9UbPkiDHXQphRzawFqaHmfOmUDfOU4kiBgwyq3hjqmMER7clOM8jUcqU9bsrqI+bo1RF0Ft6 +jtwrgnlzDZs7gH3osrHetC98n9CMP1JLjUYrHpmoP7qJel1FZ8qv2cCegwbsagDN1P5+tDR+2iaQ +Saa75Gr1nPXGPnrC3FPpVD2s4/3dJckQpt506GVsc05tLlQvB643Vkp4vzSAAXtQCp/aQPgD06Tg +cEp90yS1iogCNAJFs3v1mF45woj7xMw89fAERn7UcTV2bh8cB+1dtCyLGsCJvVG1YUXMy1aytURt +XfAV8Ya64SeG7RRMgT/AYaYKCBYYQbrGQzPYrUitFLWvK07Fi+WvcwesTcxa0HTaBz2y6MM7L0qg +pcn6y3GgjvseB96Xym/rq/DScOPo7tHwg0bFFjDWQrhF27RYuXntrv2E731bfgF4RQflbsjof2uT +FqQOYXTcvwJ5DW8EcWvVXUpiLF8axpHme3m458YzYTWNBPSVhoMchIWTbFIxKd8eDffLn27e2OLN +8v6rkXK3mEdJ1B0UfdmejsS64LSl03lsiy19ezga+VTZduK+wJ6ZWrkNfC/8avj3dIgb28iUtBVR +3oBueXM0oPCy+y64SzXNLwWL0gApk1Cw4GNIAyOrydY9sIBWE8Hz3MZ83BJwTqwqqjrXoOrmqasY +FDqsswquAGRTnQ79NGZ+GuSC74Z8dAloe+/cFYvVpgZcOhoG5NlfGzDquznoL40bXNKU2eXcfJun +U0+uUwwCSj2x9E1SpHdD3uMQxEAymEn6i19dmag8fDZehCakLw0TV8LHI3tqRH4NXExTK439bokP +hGrtvSWT0Oj9QNitj4Z7yOYGHlG4CJwfv8KHB8XDwqKEuUGsIK9/JYKst6fhc6PK3Awp0Om+5iFq +9g1vNCrnDZDMpVj8EidyN+SdnskbPtj4uG/bv5pTy5sLrxYemAvuWG9peTe3gd6GYh33qlQFAWuV +1yElbaQtDaq7oBaTjnb7gSr2yboeY4rzix64/VQpXkMTicYI/5g590SEfeaBq47U/UpD7q/9BbFK +/AIlifZuVEuNvBMaHYR/AKrKfnLKG+MeCZEZtG+MwOUSvVJjiT0L2YG7IReoIiGC5Q5Zo/dfYX6Q +8UKC8gqpfB7USwO54Qdf6rlxIWSUsYmMsDuGXAxtbI77AAirRNzNg/aKc32m/p+NYPhoGOnsh56R +im9LihUsAje11yNUWZtZQN94qPXIDa/HQNyOg0PVh7xrFkgYItfOc0Ih8sitVd5Yz02FevWnj/1K +RYGyhRaYBNlYnwmIeW0o6YT59Q44f9DYtSbJYCJWWgMGYpd3kIue2iT2I0pDZuS95TEs5kAxGjX0 +L38HONOQDSMGfdR3fI+6q+Fi7MUJdsmZkih02RfBzwVeuAmRQcodFpM0Ki1MKXxyb+dOPzQKnFxB +LCBQnc4v0hLmoygqko8ibHv8CHNBpkhwOoCe2fcCiXtp+MG0+9yI9ot+4PBvKHnGEgHZEq1dLY1a +SXcLvB0gfOrg0fZ2qh3rzlDBdSvAi9O8+tjCFRWWBCAZdLpMgNXcbGMZQXYbzXEQfLk7m7Ku2ISp +jgmUhCK2pYG4qop1h5Kt/v33bhBbTjl8v+3RFBvQNG2Nj+kkqp5Hho/sQkW34CQvnrYrSZJb15pT +qG3XbiP1boMF/kV1Phv63dB3w5WSotddisZ0lRoiSeR+KscZy3PzVz7saKg9BZxlXtgA47QRMg4b +ClN2Hi4+HIZ8PD/M3GmU5EHDNEUAj15xT6yq+XPjHWiXcirvDvfeYxEgsOmMQTlQoWMKtDiO1aLH +Worn8eIcB7XtxGhXW0Z00/wyoQSamb+ZAwEOqK8ynrWY8hJVsQsl88SXAwwWBgnY30c+b29puigU +G8++8mjOOzTgDR4NogE9GhUR8lgwkrAAmjcoAwdvOJkEBaAAkbE1oadPbCOZVsxiuLVkPQBOVqCw +gsQ9ZAo5BX/eqRYVU+L7Listbk7AokBHZnIXIMEOyBB+oS8NV0mcZmZunhoBvyOTc8nT6N3Xl0gX +cohUrBHppISGxj9VzIrmDmFFw/eCOR1Z90K6+wTxtTMoc2WGFgy84qD1yjPBP0fyHZ0hdL1afFyW +GVlm2TwyXQMKjPvOqbUV0oUtyYriW+An7RwlrACRJkX+CoKFakmgt9uWB5FV2IpiTdlDYEZX49ke ++hDDtq46l16o3lOER6j0epwHfh290qfDiyn+fObjgADf0vi05HEdP/yClbWdG6HWedU796U58cHl +x0x8ZjVv8xgjtAJhtIZcywvnFeuG5NkVDFsde/aK9jBSMwp1+6SBjZhTQD9jn4iBs+ZubP66iWCK +BjMZkPT5rhU/gImN+AGU0Hq2LBtC/RFHwBWQR0cr57ZBt1ejSqL9TIoo5MBZEEdangm8N2dChTy1 +YfIO3FsjeN2uuUmS5UiS5Hx/00Yg8Tz196mpSVCZYEQougPAvZFaV3tvOMAvNayCZr1VrO9Gienx +cVdjO0pvyLDFxaHHBDmjUsXnc93/znRXqvLcf2N5gTFU7nKL/4Q2UvXe6oXy5F4Ksw3yNeFv3BHq +mm9k0IAyXxaEVjKxdGEhyV1PcoXMP6QEqQn5ZT71yNcw1X24YtxQCfrgOOeWSuF1Nu00y7a4QyYN +LsBLD9lfbdvbbUmaD3qVNDSBf3ZaH9rqBKmOorlUNynYMt1WIZ3PfEPKZ1KU7zvXZC9UgSrrhXrN +aE2o1zwXoQU9LJii9SXOhB5gANDdQv2YHgqG1Yyk7ZB2ZVbvHydyLa96+6y8HPLkgGRY8uxxupk+ +5dTQA0cZCFOYm9mBZEPVAiBNrC72S4AIjv4+bMwhVAepfC43ZDwoJR+qwPcFo6kjFV7PvrO0pz6K +j4Z8AU/xyeNXrJ5U0VtMUKwAMk7Ly9/ztfb9Wh+f2VOnsoMt3AWbOzKuae1rQqqhrpRgMs6nIn8g +JcrjogpFZfe5x9e75G/2U8nnDzpZ/gWSUJRPSWMwiVpa+16WVc1hogWQ/MCHwQtFWdJ018YLU+ld +FrPJjdfMio3x2pBKW20rbd1bwpdeVFQIU0umCyvmaqoC9tSfP9MKFDao3rjUlJBfiYD7eNRREKtw +/Mb6pX4XvZTllEK0PAxakFjeNG2UrVmBcsF7gVVmW3LSQ2YhPVKCCk284/1Mrl44Win60ECcKsmj +wo7HgWZGDxwJBPkkMg9w/8webrfSmSAlqHR1xQ9sbNJmvZKOEkMZxqkSBL4jNCvGrlKY5osY6HAP +SO1OCc6KyF//oAcxyRShFdPLcZepn3vhS6B2ydBvxwlTOeczpXDAYTHbxneQQlgXCsAuis89vt4R +jHqFzUi7fnCcaeLYwhUYhpSZUYKG2INC6WuP40YtvraplFO3Ug6pFEVxVOyt2OkKENxQtZjfgIzC +UKbg0kAwMAc/93hMFOBsYRc1paGejwPVFtxfZfoaqYx44PGOXiGp+GrySNcy0hVtP+6ej/u2O6NX +h9TBsCnqG/Vt+42TIFVyepDKcmCJyGErXexRHfOcyXBDFORpD0PJAV3qfjv0csa9s+1rpEpojPO1 +9hWDvriEwLZUUmIPLNKOFBI9NIIFkHWtxNIcYGQ5xq2uzrPJM52w7DhOS6NFBBwgjFbAnQSdCFlt +JKDA7IG9vDHWc4eyn8pV+thiYi+dVPgaXYUvcV1r7tD8QI5rm+gpho3a3LKiacksIsez1/bSIbcA +W0qoYdqkgsjTUUbSia6ms9oUJzipfVJAQL9LkvCR7mGJgyVwuXez5ECBQbDwYQ8E6FbkJKhe8r1s +9sSntZXvQW83BS0YFiNh3+7+m4jqKeKW7ylPkALCiNmfXZ+500CZzDv5lobNzBbAc2fHrOCWA6YS +Qp0dF7freu2RxfK1MQN8986Vz8dBoYNIHu1kZvtynxqAEiW4D3pcG84WoVjvd1n+uRfwXgV042Oe +nmmDETv2yIQmgLabSENSUaf3lLFdYXeVPcoDJdEkLnLD7hptTIt6c5j+fJnVV164bCFEUekH5d7s +kZtqkCkJfpYNcJBRqo8TqXCqApnXuTa+niCU+iiXQkwAAl8VtuiRssSH0i75dkCT8XaulsdQXo2t +LwXOG8Oj9kjfpB/FleZBLTmxNpCHgL/0OlPaWIXdmGpUwPigB+m29sD2PDUeEpWrQDZmQqyOW36c +JIgVQz68+r57xImExT/3yBOsDPTic6EK99FxUOAaJK3BH6Z2OW70CMa1zHKcNxdlZfwFjiZfqpuX +zXg4N6gCyuy4Xnv9Yl+Pe6Z+6CzsyiA4f0i3KyY7SPmTgFlOOjDBVTWG2Mos+tqDWgrzLEnH6wbb +PPeCgUacIsiYjx7sg+jUgUDe+SqLxboNIPsioIDL+KFwFjssMOPk+qZQ3BfZrbJJL9XU7JIGcABJ +HvEcplDM5x7Pa3NmSZ974Rao0q662BkfdsPA0nKV0mGJmaKuhhgOOIgM/YFJOlOkJWYGsTNLyuQl +Seaq69+YiigfcitwN0tMrggO0IGklRDMQXJmWNhSNTjmBGGobpsJGaZOuY+asUEkBuGHCkCHukh6 +V4wjz8PTIVsfC2O6DUcEAZfpkEDzt7tIp+4zeaF2bPdjsAqT1G+lzhKfScPMHMkMPpOYbRO9vERg +xmAAvPv850zpr8wwHOwCP+iUZoQA/84W29WUdkjDuzoQinztwZo75q249tS4UuhDpUENY1jxZXla +ZD1XshxiMa3AgMeWcfm80SuybxA2LiMBavjwIBjMVlopVaowcJn50H4U73IDYqQYvhLtqBzULxlu +bUv7EuuBAFaHnP2xedey8dZll/rppPnBvD1PWHSpVHKYdoeMhqdHMprAToKXa2orEEbD4ax5DL1K +ETyfDxTusQviFOhaehtsxXNcwIeFCIwYKET0BS2F4VhTRbU6yvtmusXWXekfJaTQWQ== + + + xArtbO8l4mPrWjlDTacR/ixaLX58qAbMRrOxJsTyrsgh0DtClgJkSP1PnYSmPR4aiT2tY+nV+9q9 +kshAui0vE2cUesBp90JAolC7pmYXfyjasnL54q1jC9Y3sJ8vlaWaLxVRW3kYl6rbMc1Xq4rtrvY2 +SbUKBzRdHK7lLndlxst1sTnXw5LIIYktU+wjKMi72bSUTgAFJHjFG9fMDPlwao9MnJNNrHPAcSp/ +MS9tp64D9kXZupr4XbDk4QzriXCMZKo/MOgpqdJOUfwsG1nU1D7w73CGoUNAChXBlJVXts2U4Ijh +SS4N+b+36mZPWOrBLOMG4RTf5s8Vq6zqUNhAWYYGuRcH9gQtf2HdNY573OGYvY7dmISVGF0rf276 +50DUl+yOPZbilEwQJB5UHOGltt2OaBiHv70nRKARSFHNIIlWzOyi/AOfjjqzrOllHRtzpmQyiMni +RaBVgd5bTyXFZAAVtB5uONVK8tah9ifL495rxTEmiBqqvdZm4iLxQHurKNuwswacZf0dLXswGDF8 +BhjdehSdlPMOLmvCFfwh+taUJTpzxXXoLxmjpp6WFa5ldb6J9ganXLDRnopkWkdFSOIWiUBYXwz4 +QZ6UeRsZfubt+IjbOvMNqCCMFCC+h/Dp8OmNfSF6xsvB5Q4WqL8EEuoeyW1Dp+WmvZdc1yChHmf2 +WqTeMWy3zo3PL5gi9DaazLSSkpP0GIi2oBeqomojldPyTAqRUld41J/RBqCaHZ+Dvtvqp8AaYbdf +8kzUd+nRpe8CagTWiU7euXYP9sEcg1FLQgMwJdnK+VgVS47F+KoOGMg8mpzJIyY5CULOlAa8DPzI +Y8x9R/CrwTWcM5d/5oy6+YwyPWJyoSr4KIELAI0gDUSS/DY3+4PoivGLaj1yc5e+5ckc8ycxtgaZ +yQ6IFHtlQPvuVrB5whwDi5aHcOjRtrr3GZtTkgZk8A1TYx/PVpQz8do4E1mtN/i36t4mBnU48iYo +OnQXI7gsFHzhVsGUvg0d1pUJ1GOnkOBWaQXFpAxWgFIXyxm5XvMkYAKY0SNKEZ6LPBnykHwm1d3q +lX7lnzdSjpQuSDmzM/VAnZblcV3gqaz1I0ROrV8OQUHv7xAJCL3dWjOdpGYdYkiHvcxqs0cU0Qgh +UNTMicJ1HidWjrERhTrT49ZwUgqbeRrvM0Z6uxFWgMINQGIK7XIqjpzHuZiZh0n8wakLpB3Mpkt9 +5aHTgy1K+kZzegyY9hehSxtTy8k45Wm0/G7imgY2RdyohHOSs+n9BWw2j+ve5YjTYsfBBGEoGCOH +gtMGFaVI9wWVNUWxqVSupjtIF6w0swYrWZUVCHTzteRAY5tpTIOTFjHNIR1sgq1spMqA256PwL/h +4krkozbvLDu1RHJmx0aupUZPhBQcB0bmoOA5covxL4Zpd9z3x3Cq3lQ8MXSCBeNFxwKxWvo6/HqH +Bzh7AUFsgD/ZxTnUN7D9IPkG0pG9Are4Em48k4KcH1TfADby9oc2qDGXDPvyJXp/7P7cRIqc6lnf +P5iMjsRRPiDQNJ75q4V5wtzFOhsSDFZPNl4TR1BWgbX1zdCKLjcAK53uDFpOoZUJAxazcWaSAnNN +Mh8UIgjEAOaABewzRdHEa+dWqWW1OKYV9MV88W0HsRLFGnrrVat3aCPEZMlbjOUpRvUDrp/B8dqs +wc6XPGwEP9/US4n/KUpxiv8nC5gN+F8ULcE9zzvam0328hTDMaY00+W5L2TKyPsSGXgUUtkcntAV +5OFjOWZLoqq+UIVUnOsik1vu4UvLaC9mwZnoyR8ZWJ//iGOYHAy4VBQ+uAK3oEB/lfcjd/Lr3Qsl +XTI11Qx00SHcXrgEZC5HvZx4np3JhOMgqmlAnskeUewke5jnLKE2z8KzvHEjda9JypR0eyFhQK/C +4LcHAXZ3x5DCm0rhIwqGCIaXQuW1Y86rsvRIGx0Mo9cjaXRt0MYFBDONELrFG8ourD5sPKjhIy+o +sRF0BDm6SF3hlrIquCtBCxoCoVvcbpbd2ECeYRbQuD81HyKcUWmu57Y+Fri1mKqIIFh1OQ1xWuxk +m7L0sGAyvIsF7pasgIMBryF6Ta+CXqS0wIyDwpUFB0YtevAf9ki7ykM5KHs4wdJDrnTP4szYuOjH +idjh0IlNN72aVWZsMVpe73FLtZeUasdTkIZcdytwlJ49Lt0w0dt6cLygA8G8K/oOXSPfwziQqzl3 +3rpl3tqArWf5Dtn1QgAwtp0Rya/UXJ/no0zDp2xir3fwjeUmW2CF1DaIzCyr3jcMqHmZu6wUHCRK +USaq6gHkCyTBfmtv8FHydCIKPFCVJU+3nb5Ee1hgSDGbOBjp9iKIB8tLfLDBmoDRBJxUZUjPtJVA +2YcKyS2/RV0FnJ1HTSOvrqcMFZyxSCqzofFzYqtW11aox+gHW+ue4J8JqbbFN4vmnZu8ohJAfJN3 +rh4AGRjGhsBFzR1TrBTKrDaUV3k0ZgObbnq7B1FM9Oh9JGavW6qiXmRD8p0fRcDrUuiSxTF7Dd0C +TjR//bkwhQgzj773ojwyohrKErTXdGAlxqABzvPj8IcYocqKWXLnqBhqP0XmIcWAyhsJrH31R98n +5U1x0r7visRq3NUoNysLJQkdTkvW+UfcJy+JoWDJB7UUUw1ns2hgVY3roao2KQ6dJfFJMTVg7/Ko +JsNypBKM1WOqNBBIotLAvk/khwiAGN5ASoogK0plS4Pb+CkvKW1H+hfHlfkSN5wmENRDlFQ/CNpz +hErpjhF6mmBEYtRMR1FASdCPNZ5W5/DJQFZMd9B2HHedEp3TJAWO1MHXV1NBEmi1Xe5hJ9fc2AtY +jZjGOWAYlc1pmM6uLLk6zavrtItg4NsvzWGRo0gZki1nsJDFtjKc0kzUxbMMkdU+ZLxBv8292MZl +IqzirWp77AbwfMeOngz0BkBQ6Rusjai2dXxcud5zYy4ZAiOBeKnOspjxoFMeyRpvYMKIm2vNyGjy +v/V8YDerdMlbJiRWoet0s72RZHNvuSKAMN0AdIREWHzoMUfUpFwOBTHjroUhqM+J8EPcf7vnwbkL +rg2hD5HsVT16G8RWNuRxUrPdBJjSLlDuDNVSy/3xBbc9ZHgXJVW42KHlGLiqY+Ao+aua4kjw2E97 +KNxGerO7xNc0b4keZe34kgeT3yLBqHEJyUm0KI52Sr5umWyKjfip7XM5835+MqL5Y+4B2AIbiMYT +wxNddQBS0oZNcWfxDbDx7ATvkAjVxGQrZ6jtwyOeResXJiTPnixcx3wQgdj2rr5tI/4wwP4RSOYR +CGngVaoeRX0AnnRP7h8NE6wMkpgqdvZ3PUca0Yqnsat5298vwgAXE3V8CDlPNx9QszRNAzFH2tnu +WlRpeizhSTjl6pKY/O+snd2qNDmWnq/A9/Adjn1Q1r8Uh3ZhzMAYG5/Yc1Q03W0Y8Ew34/aA7956 +niXl/mrnrikaqgqK2illRGSEQlpa6/1pXN2RUmGuBCuHtCcQQ3aFkF0bZsqyI0JlPo6GlRDidrTO +56VECYVf90UcxIAhC1cOtYE2fOySsDSkLjeqzFEfaoBrcfVC36j4Hbm9jQTM8nN8DP08sLrMNsWG +q0xKo+XkBnB7RCMpLBrEXLQc6uftAOhtCHEDUyI2vIAQ9TjVUgRHnQ0aIpsVAlQnT3a3FHVgpBL/ +ADcmH02i/BJYWLLlAiiPS2QXFRiEIXRkhKdaxTsi1hDMaqTi2wenBrBkkK2PvidkA/TFQR/pn73n +osKOH6D8OqA1MIQ4c+aLrUaVngQcmxaB8iyCgRuSLj0O0J3FDN0CZC+Y6NDmGFeigoRpF8OFpJ43 +xXqO6GUE4yqFe/KGOWDBvQnEFUR+gYEUa5dMRJIj+56wf5UZ5/DbA8m8dgNISWGqfrCVhAiwvYX3 +vuOrbyz2MWSgERGYULei1kXyaQX+QkpbnWjVVWCsrDtnNmtHwQEYzX6dyZjCo4a+B2uPyRK1H8E0 +QB9Zo11KlcTLcDvaixdOuc+pHL7ykjyQ2Qqx5mhVirs0AmDs+7FnEGRCQhaQCdtlUltPuyJFhEMA +oqYiVq9GftJj6DyH2EGJlaNEgwEi4k7Z/EK+ZlHl+LXZOH3+Med5NPtCIveaYnwjlp1nSKq/VB5X +pIMrSb7IFjwuvOJ3FnAZqvdadohvUhnQ5Xa/sFOCRH+9Hf3KGIBP5YY9wUHlNFUxyYnrysyhysyl +muWmfoYtMVyE67TBwlOZNvd8XzHDAuPs0ECmY4WcpfISYaObfZNNkyIn1MjTEBt/h13wCp5H71Pp +JIQyTBJU8tGcJ1UxDqQaRQXfdOH4yoe87CwIS9xJYKzOJWhCy2ZzHEGmqqVoIy0jtR/eATEDqddL +MpWGs48MdZhlhi8HxUWPUC0i9jSw3HgFvPvsQMi1v5DlTPOOOdKHom/R7d3vXZKt9pjNHCaRQ71w +z9tMgGxrDkGSBLRRgPFJY6Ar/+CqC3nZyDiFIoryEyV+DjepH6tCP2Ob0UTz2Ng6OYtytlk0EOYC +G4FEWBS+Id1BsqLYIDf3Hi4tjTYzukM0xttH6MZmfzesohyFTDc+X8Q3aHLP0J4uN4+GECaIWh6v +Wy0dPxAzw5SuO1mlyOiH93NiC4rTDmDqK0nYIntGFMjLst8sOTVZIQxTvgCaByod6rFTw5LdYApy +KpOSXvcrnWJN0zYXn8YfSO+bWqZUR2oZ1QW+hfCTGXgBFPt+JHQQSJBcPIeNMBYAbpdQlek++NRD +8m037JUABfsQ7qch8gYLuXelS152MjRatNqNSHzaSOaUBtX59gQHgd/zqMZjA6v/wsRKKfG6XtKc +EK80rQyuHLx1iUogYVNVAHrygVo0R3ZRqgvyjghTBdrnqlrOozuoWBc1FdEObAXD+nq/quxTye0R +DVMUCh1uEuj7FYIvXk9uhKJTE0iJxLwYCR0sitIjIkmLmUG0yFweKRFQ0icWpMRHarIf6bGQEAVO +tjd5GATsKVKnFx54xLBPUPX2i2/6tYj8Z5is5puD/Uu+WQKqIeyKG/t7shbaOO+hq43zQV0dtBQ5 +/IC3tOrGhB873PadCSRRcvi2Pz9blwI5PH9wVNjXMC5IzFCcA7panBqzDIikjsyMwxVEEJM4dS0Q +IjA5m1EgPUu6ATfr0X0FaypBtM3NCzqR1fM5BNA+rEiMuPUPfpcYAlxb1t2dstCBytlbIrKG7lgU +dJxUwnLkRILeCDublCCZyiwtiY34CBIkcIAp9emZHcBDVcTF6f5hFmJ+js0niI8jnhvyjRXmB3me +EzsG8uERIRUYyB0Ioo3gFX/ZSw9XetVzmHE6zNvBix+EGKeHoG8SDOv0YB+sA1L7OBGLM680nib0 +WvrNlaGoTpkHA2GRLrRm1fmjQzXYfS7ausVrSI8R18rnrxNRGGL/2anJAebA0Gf3AoHUpZ9GeAqr +pNnBp7Y7VKVy1/G5J50kg455hDTgIJucxhlMI5SXeVK6OaLaAE0HFVhnnedASOG/gA== + + + bmAfH87zbOy6UbV6IyxBKBWDDhcnCcDjObAMe8lDGygPZnsFynngr/d4nBo0l9zDTTQFbRY/AOq9 +pAmWCcNkrHSPaxixGxMmhlmXLdAVO7zNcXlCJosarzW+rTXugE4Y2wIXeEgJ9R7fdON+hV/TBJqv +w6l/QaYwN6Ve4A4xkCqVpBU1OwfZeAdVsllZ7mJQjBMS+EnH1mfCogauD854uaq6kiMOC23vtZCD +4nOxZmmGvyKhuTq9SeFwyzU6lqAdshCkDgPpFa7qe1yUEDGUpZKxF7pWi6AGxzg2tXAvicbEpkJi +LDX2rtjvjAPtBgToln9vDuGqyvxE5I4skeWEL4BaELBYtlYkAlGh4faY5kBdhGTIIzUTp9/6IZQS +ypInCNS6U8Hg51nS+OlxPD1jGt7vJPtDT0AROa8jtk498Vb8eRVnHA7sLI2krPyW+xGkkq370sOP +dSzdH+MSGh8PLaX2cvHSJoGBSUF/T22MJmCPwtmgpq186m0KeGCzCc42H/DVVLmGgl8P4YvcpX/K +yqsuRnulvuloeqkNQOZg+PP1U9FmC8C2xwlNnD0ZNbSBgSxYlsqPhtL0UJqRlFvPpwe5H3q86DX1 +0AZ3L8qMdgKjj/8DiAeHjIVI1nOSwFyKYEtJQdEBtYzjZRy/6CpGCPbmxva9oslLZfbIapNiiMb6 +LoUmKzLKSMT8nMwUEbW8jj2mu9ai7LgO9rdr+gnaFJfQ8J0gc4M2X6GGQuEIFaS9oI9JpYckHEU5 +1MaZ/qQNxSzVUoxy7GPJhSKFWi+jal2CV4ji5Fxv9hAAZZwpOFddIxL5oLWyjjdl1PZb3XRCfNCH +qMGPBA1/MAYl0BdM1eg84u4XmOIVZaggJHSjg86oIQFOmI+QbFfygd9AtQxJT4AQVpOuako5eANM +7pnUc4oXcT+ySYTDiQIV/CDUE9VJy0rgFQgCam7iPXDXnJHxhKV4ma7P4YcSNNV46fT9pDRPJZan +FRBTqLApEr1htLbD1qYM3opVfB+D5JuUxbsw0BhSdfuCZyhp+ST3hmKGWMXSGsUOpurTcU6d1A7n +Lxw/uLCF1El7nSiWDzYB67ohjkOczKFjoSYgPK1yCLMRdi051HQQIlg0Bj/cS7LnU0zhqbwfA8g9 +IKA4F4NMyHeEb2VKrTw7xKJ/zOOwM6CaVCNaLCFxKfiq6AJJggLOawpz4jjTEZEr9XDr9bjiNVD6 +LO4MCjnFYKfrvOBhBlYMqfkeYovDnJECyk3x1zUDU4XL8hyB1MnosBKRlmwlSEEtMQNEHVJmHzVV +pIc4aaIYIFYcmfBH08TUPvSIDHX2bkwrZ7fiZF1w3WQfDp6Q0FjCXQue+wmq+UKBLfpwuBskqcdL +Fg97kbkCJFKu0CBWZ0R35FeUyTtOrdxmitjfLMFe+RSWZN55tKpBkBJwCwbBEkS4fsWvoioCoboi +om/c3YzTBQUjpHwfSRn7dK9lMYdfCJ5nPCxSTmOGZlxR0u1A+3ZDRe+UBmYWG5ycgTXN19ECrly1 +EI1OBNW7U3EjKRAb9bHK6hwdgj7NRqFHh3NBBgL41uY7g5GxbbIBHt0dgaOGJE3SNwkFMKJdRPZC +uwsEMqPbBPN+YdfZ3n2ggXRSd65DCkP4r5qPVDISxQGe7FK/9xt41YATk0ynhgxDnYQAda50MrhV +O0GN5SFixFI3p/IljFlKHsAGVJtkq6MkxpIBkGIJRHrQXQl0BwrfEoKfi2LqgdpMR16GmAjFUWIi +nD+FVZuHTJQsRxzH7RylNSWDccYiVmNv9fTArMhBJIJ/0tUUolwq3nAkAeh7ghVhhxLgQUeJj4Yz +UcMNlew+P2Q0NRSx8w36eqVAMBXwuoqUKar4DC0Ey+nVLFfh5PWEyGboYO3f16JDRe+CDs86d4yq +KrvuCliVHigWT7w10nfYWZUAKzSs8CcFbUUvDQfswcoJMlbeC76PoHNA+xXxwCkywuhkqaKUaigt +swyudCHTKyqKeyKYVOkNzEtAsZ1G0p6dcOV+eiQ0FGHqCpSFTP4MqFUAEA/Qlhpy9Tam0GOelF3U +YFxHmI+cpwXQFrjR/dY055V++G3omnbLrJ8cb15nEqKVmGyfcM4ZRjFYKKF0NkKkHiCO95DCBJBs +EGtsF8jAwZmDbUFAD0O7Adb88QylACfvaBPVMkmQ8gLbXhZEgz4HPielvdnDCt7uYZZRHsA8NFWK +SgMCfPrAxkpD2vH9srytohw1BHKwKdQo3UrhKCaPi32NRPGadQTAuIMsUdL8J8xkIv2w7/BqF9aa +Qr+AF5zdEEjMQHAI1W0+UlfMhBx+C8F8bWLUg1gh1RYvFqrwTIQiagFzLLFlZzCNIxFKXM+WfhyF +A7fovH/raK4aGwTfs4RVmUr46J4GGOCsBpSdUs+vw5scVGL1WKSEEdFeZkI6fcT+DA3qJG32ziP7 +ydVzpnMFatpHD/loSNN/dyYhLaQ9TPXS6+h6krADLC1NjOusWQ6uZVE6EB/1HCkQXbxeInE9LD46 +7iVTpMOQdyKQVC+3vTLoZtMCiTMk8cXbqNMXcn0GnNy4O1tgIMv2gvHCPItzzQ5cnDQl7FCbDyhI +YE1Ab7sL7MfYZyC+fJcDbVIQjpsYfo6gaOLHAm49y8Y4hOaE5T0ZIAo4XQkxTEj9QbGMwZPm0qjS +mHKRqnqQpPZCMrfD1yjRi7FML4QL/u7fBKnDfBdFFfa/Sv8157fQt0OzU0bqCD6+rJZ2dIKD7JHY +rvv+IGrB+7OuKwyIfPfRBAqZgdBAf2HImWJpz0dHFf0nYOEtRT2W/cg15gSPj/nL/kmhZ8pIx1WF +/NEUS1yqBKIc+pu6T4SRujrRManlY9ax/0FFcR4P1uqLXzUeZKUlOpuY1RJOxUZndwGc/TMFEKiR +S4o9lZFF6plAG2UQF+m9hk1mREibihIyF5sd3OEswwEF03n0rGBy4ou7F/a9czxlEBasakxETgj/ +2yS+WDfVvz+bOPkvBV1XiiHloIJzGGFTOjPSAn+h2M0O6ImuAem88gtIBBudAqbXjf0IxMnAUFGJ +d+lbFneyFI5wmalmgOY3IvWrGqPFE2nHgVQ6sdupbrWzYsrXZpNpKZqMwyOzu5vtR/gEeeUfD+DS +tMY+0EDkDSWwIvQBt0hQIw1jJl2Eo0D/SyCU3xLp8u9+0YjxrzzQrzgcxr/Zf7/yGpTdUR6VHFFj +MQMg42u/TqR6A3gv5L3Z6zG7+rmX/A0nsgXn0Q5rBu3DFZLPl/vScqJ8cm55vRZA0KpgdpGX4zVT +xiFDU2y+ZhbNUDK2hoOYELv4IRj5REqVUhQU4kZhYNEYxh40gBDMVEVRL8TzHlaR35jnG8lvvCp3 +novcNbq5zCqkWs10AoUw89caeZKomuc4nFja3YCXmA3PzYG2YzeSweEirzgND0JhE83JHTip+cr8 +zRWWEKNgIjOKv+rZ44k9CxO+Z5lRnmW+VbSC6jo1kyt/D2+3RQJD6J42ywiIebi1wjorZaHT2gUg +/wOZKoYGMEoql/k8nWdZZUWc8/vZVQPax7ypbR5jybrjY3zv/FxJ6mcZStHQgZFhUvnSoH7CF5BG +YlR4C+scDSQhn5OVVuFXSX1O0/R7/piRnjCZ3z+6GP8AfFZ0/QkSK2WB1Ch37wkueW3LmZA9TaIQ +dRtchHKEeuQNdem+XzJFRT6xCqDiKQNTePt8D4V8BBjf2nIsIi1PrS6ohovdIqDl96s0SiwNaJeV +NT6P60o6MlKUMa91v4NsaZlKHrYp6ow0k2umGfonDJHAjRy1K5sQTqLyBacTnAslMhswQ9dPsikw +LayCBgJ1Gvb8YcMLdEYj2RM40siL6by0tz0Nt8pe/HzH3yrld2b5ZnYlxBP3lr55tCuG18iLJTZk +WGM9Vt+FcLQU2RtmFBndwOggrb99nr6zuf/cSEqaBF1DLQvWp6UnBdyuh/Fj5UUzlDVWNBwduCaX +4fVRw92MpNE+PObCAKkaeZy3hp+Nis+NHdwMAxefnQapWkVFqUPkXxgW0+elvpWYn3IYLa2Eb8MC +lV8MLJwKGsUO9m1PZV+qzO1kKvgXv1RldyrkSJDP/mno1l2FRNsApplsAAOENAG1p+eYtxJ23oFZ +wnKRtlGog6fwP2pmnsSgpMADpcA70UBoPnVzu2NyWrFb4B0Zi4S+IBcZXXIHkakgxc5KEJ7SIYS3 +4EcD27wNsW0P+t79zEjabTxmv/t2rBw5OhWOl3xE0iot1i3SG6xb6Yqr08vszaIIFL2wBqcXu1qP +Y8Vx9xCRzMI5FQh8vLW/vgD/q2HHX2nbHCQ7661mDEkeZV2LLAMLsxVOTx1vT6VIx5IPJFgMLT+r +yuHVqWOP0lEtknSEeO65vgsMRTUqKLi30KRMkdcGmWgDMfZuKEj8Isht/MXhLDDuBYIxm5/Qb76H +q6E2uDdt5GofUwbiEUigo4ASVlQB1UIaU824ff+xwrLucH0KKYOjmILks+rc7Qc303A/RJjxc3JT +RT3AHXMelzIWtEdwEMy/lyOPSb4dDCdXgiZHdR5h54oHBB5ROQxJFFYV9r2nGj3se8jtXgyqGwo0 +++A6YnyBQKUN4sf2t7hoFvMAMhwY9G7oMKzQFUoXgjnPJpqyEfql3SpdKOWSoNifpxJHw989oGzN +8wf2pX+Hsp3HwWbPBoZNxOtE0GTf3ICYuZmMqyWo/pcG3I+/4dgWcWsio8E5ixq7wkqWtvMZ3g/V +NiKaUMa0V+ONBGzSnqigaz3ITvMp80AJ6oESINAErEzRUDDnKaToAo5ALbp81OrxRqOXjGfBBisg +CZ0qh9X82k8DLKfdgHFHcePKVov6Szlf1QJ0n2C8CiTHm3oPk708BimOTMeDnSfLDoUXZTBTQAgi +r5SsFitHjVWjXJe9LRQE/9Yjdr3lVDlyEsTxdhggoFJkkTPqwREKcpxCu930SDBcoTHPMEvuUwwe +E/uHrYFbr0SmXvPgC+jak35Tlf94lqary4rfLpnwriZNGCoE752yJlOujryPZ8Le93WmyE0oxdqD +5R/oPlBl4eYQcfFe7jWj5jjAhncPeDXRA1IHCdhVA1doKR7Xg/nyjOkxZZAMJmLM6zD4CXpWDqeB +pKAFUgVubNMxkm5klLppIk1ZoMtkKd8r1Gj77Cwbr9XIJI9Fghx0bVEW3UBzyCeWOp4UTw3Oj2B0 +QquwZfncQxinOZs9Xb58WN569VMBr6DXSpiIKNQiLiGcfC3OY5sp1nzUm+Sl+lzee/z+5GClfKcd +pIQU59txDqxqD02q2F6L5UEb2Cci0VwDviQ9bzCxXSbxWy/gzTpwUmh2CT8JcW4+tRbRSUHXwucm +G0Uox0dhSd2/GrECs86Y90QzJIQg04UBN2wUyVI5/JukRJq333s/Rq72QvzW/YQMSg4CJKloNUKn +CHAfOkXrwiJIHaJXAbjn4Z3uhxQxwP+siHrMiewe0MKix4hxJqZlN5S8yuGc5e4J0g== + + + obpU1xLvOBuMSJei1c4NGaok7P36KU3sO1ePV6iqsQUhweerHjWcZiln9efOB597QUmgvD/wED+3 +vputAxJuESAdocbBLjF8bngmnz+PcXwc13BcKWIIP3/b6EfhpyrigBrF1NzncwO4nUZtYb+QL0Gd +t1669JEBxlEDJg6/20fZA+4DQKx65hE48Xz5k/1q/jyrriu/hhRbOGSoYBocQB92AnAR5VWpZ5Rt +Q+zy83CwKmLaIj+RLb70uz1DEdB5JszdUKTN7IIOlC9kGAG11XAhzoK7niObSIUCh6j0RP6lkON/ +wiPeNReqIWCEHy8YIxKRLEdn6pmmpJnjHiFmcrALUifANdjTC8Tcs04+Je/HWSKF3+3eNT/tQ3TP +5D420uAnBnIGM+AIgbCofUffK3rAAKPHw0KaytFprR1RjTh+VpB0fBSrgTWskDRFppyTr3kgc2ES +nE6avuHQNqNB0e7aB/DDbN5EWbE9s5QXYKip2wwd4RF9mUwSsdMRdbg3nZIiR4qaO3wu9Dl+PST6 +LTcXoO8VAWiQKRnT2FeCuQHkQUASND5cboCc82y4XbgsBMe7lSbF7ZgVt75n+3YY3Ba7Bhopj9ql +6qXB6kRshx6B6IfkcSxd6CUBvx1PZnux2tFLR0T3r9BS9v0XyXWjXs6kQHM56uz0kJcfPBSPMT/M +S+sxPGf1yxEQPlrkskFsXgJ34qJGBYYKq/Qi2TOJM+02tHptRyVgFEkQ4MNC85gkto4XJopA2UVA +QGyNnm/I26yjdgqFXIftEQoS+5Wvl2M4AqACP7WCE0bDJlC1aa/JRbKF1TSyk+e9XcDDCBeaLLAR +KxLQn1RjbQxQZlZk8vyMEXYNVE2TarrlVGqB+/TgIVoIgj4GQce6l8JyZBBuD/WAIJitqIypQzFy +QL9eZ4IARK9yrsdZCylKmIz22As9PZhaY/EixGQ1B7bpbwL5S0NUDgHp3iddzFTndrKme0Hr4m73 +oJUbiOxwLxHOsCjvVzkneZBvPcqNRybgx/tQZsAn7aXJwnG9lwiAxKhppsY9By21vglqVmDD6EES +3v4gPo56SjtcenTS1+sb5JHcr2oA0EEWDC2J91hRD0Cd+XJ05uf17snhzoGTCF7EJCwCEUdiqQQP +wUx3BXlVOKxKK/DDhCaz4o72+txL/Oxk8/pSmZHUbtS0mHpJ/DQFM8HdjtNjnB7P9ey4wh6fG/VK +FnksfC74ZArFIv0ARswiAPE59H0YNP0k4/fL3d27RJng9LgEYMnwXWVr05n2ait6qVHC5Bs+L9N6 +pjrGeahjLPPnc4dGAt+Qol4fs/c+6WjpK3fHw+tHY7pK+jFmUvGDZ6jehBER9cRT9XjrcQfNVFt+ +3775VS/KdILnK7Gf9jFPbL0wZddJHQplWAONZigKDFlCAyC3l+PPAe1ItHxirxD6zVUN0jjOE0Gi +ClV4G8lQI8NA6Q/0UojXHsgeeqDt0pLEGJCJHCqD2SsseGC7q0CQgwK3e7B5jh6i5iueBSE5HoN3 +dO3GPJNz2F5BbkLQyqVOOBBngbXqftgk9wU/E+CHEUQOpwjqHO2SbsEGGArU9d4jTjDDbaOijrNO +UXyu02vE0xWHD56Ack2W20+sUkHa1q969B+OvwY2FfdMb70gi/J0S80mnMDvIKUFRFvFaSxCBWhi +TTKDXP1I48Vzrz7vPTwTwHboYkCp2vjqOJi5a2BEELYCJ+AsDn+gKi/0uYfVO90jcIo9Y/qtF0Et +QxhpmF7DmkoPR8VhWMnLSdpAaiMqZf6jGMMGkM3Ze4/7mhbvDTnv5/niOAiSSHrBpSTHcqCOCRjZ +8mUP9goCIKwbXT7XQebZazirKDeiIwn8YpL1IUCz1ETEPSWrgo5o3nTkqTWw51lyd+894t61gD7g +sTaUkfl8nKvYBb2ttH6iqZYimsoKm0ctfs+N8MBBMSl73VnS7xKLUbbR4zFPqvCw4UMin1BPQ0H/ +AP+sGj3Mu+we+zG2I4XdjxR2+jiuXi271xBupncFyeh9dgqc9BBss3vMdlBWkRvc40W5rBQRN4do +I04UbhoLfME5Twt2B8KzPgispI6WhuKZiG0xKZAJivi4iJvcS1mPN6Fh+6EvCD3K6dHHKwYRNQLS +Au7QWy9ZwRE3cp+GKpeqguwt4Uy9ftWjBbatkya/wc5bJ52huAAzIo0AgCcCRpioT5gQ82nBFAZ6 +cyH/15TfUW1nT8q5vlS3ekzrNGqLglQkiq6lXzUBmNndHm7zwfWBL7AHSw09rrqQrHRm/fKs1wlC +e4NwhXd1PofD21A+OWeK0HT/8hJnMmuLOhOM+3gm5TyTdXqopdpQDbj8zRUb/R1sJ+yhePqNOa+T +edXcM0fkT8ZF9X1EWk0rM+tB23vvcSBKe8wp2P/7s3/6eS+VwnoohSF1VKyZoR6HKM9XIvXoqz9f +S9M7ermPDT2jfjpNa4xN7iCbY4W8EAAgs7Kv0v00AjTSD0mRuKWZJ6WKttg8vLI9hymrs850sseb +8HKWzgrfDYyo2+jnvNXcQBYP4tUnvCZJeLx3+P2tbSnmPoeGz++Hedbl0IHs7rFNNX2EIizhxluP +LxfIt157MVFsHOVphFzK018EMEHee9KWCRA+KrBq9g2UCpoP2W8KZc/fmX62MP3s8qSO0+TEvpHV +CncuRFAKruZSlDC5ILGyACMWyRipS6JQ60kmEhLjmPctUCORepnHXpRJBHQ3+oogkRkYEBrf6AJv +Pf7l5Iicut++rlMT3sxdzQNF/piLEfmTfAKyC0gbVnP4Xsr/2/OL/L98hS1TRFd2KvN04nHTacxz +GNNhmJQ9p8eMHntxOz3m6VFuD+I4eox7pmNhvHt1UzfSEZN0xD1zRFotBU3xeCFChw8+gvSuDMl8 +xA8hYKLHC1ncjsYzFkwAKeSH5SAriNSDKTM0eqw/dImcA+zeNO9IQRo77bAMwo1RATIMF8pNC17R +TkqId0+kDw52hStKAcaz6BuKaC03HU183sPmugtB2vMqWcFymEl4YaR6lUvHEW7ec+EzQ1B+3yCk +uybqAR4Hyzh64CN8jkMea04ZpOb4dXSYP1wIIJ85LyeEW0bI6as8qDIbI+arHmp8DEpwoGQ4rrX3 +HRVc1X3ZXWjaz5fLcQkHq7TD5yr3AaJK0QdiytUGvzqDU1FlkD6H3ZbRWojYrhzf334Sg9nagK+s +ljN71Z0SypBIe8KsPSFeq2AXie+ZB47AX/SANCaBktnphURNIYVsrx2oPiaWg6YTgqpVXjBerYEp +wyCOkBSDOEyqZ/sBosxBoh4hCLidOfzW1QSHIqkuPbQV3FcJmjp3oeZYZfb0ycSFj7Bou8DO5Sj3 +5RGqmzSCEqdBf8HdAE3nm57QYLuIDb0AuAiazpd2aYA1hWQuZ6AOQkRIwjaj1bk8iDJIdmRMZHZD ++9vgCm9mRa8+9vV49cHYwV5TX2iGlv7wzPFdy193l9APg1orhVwIi5RhD7cb1R+Av7FjQ9t6fKnJ +KRUKLpyFSNQG6354E7RwFn4JcdjIhsbiTvZwUwngcjLCHI5tocRxKEWcnzQQmui89/NgBO8dE6++ +bwTvrD4h2s3XGRo9eU+KFFDWcQSxIaDIE73Pb893Sjhv35L6hRmMrCymPUNnfJRGxOQQMSlv8M5Y +xVAfst/PPSqwMjn7eUjqvd9BQUOgseK/63AZAc3g4wnQ8nMPdV6uCPznRjS0xEdCNeJKsDUCwweW +ROoSFjh5xt/XqYAXNx268b7hH515UlPZHiEh9+/rrPp6mlP8uQoxFOJncJkaF3KAdvzwDHAUNZ/0 +3U3xkxCfzukWRfadakOCoTbiT+hO4zZb4hAXx0cbqzAfkafxbyTuKcQSRzwH7GYDCwQNBGXo4qBs +cy/EebHwvux4bF/9tFyda1TuS5pkAKUthWGormvFQpAR3OeGuDefI4m3r+OZo7M7kgyOthQZuT2j +wJl87+HNf53gUyOsSt6zuKwOyBadkypjK1s+YRz7+bq7anY6YiuQFthR420UfkMsB/wGx9x9zwL7 +kiNVjnHA00Mokfy8Qom9XJGQfsA7O4ZoSrQILieb2R6N+qgvsKpgXZ3K80V69XOPhzPPD5yPlpg2 +TsW5ut7eCFuEdh2Rj4CepDFwnhEw571TFlJdg0YWgyB8hXjTmSqR2RbwgWxm9kuIRKiN1n2TZoBu +TVc/NWTIbrUVeGu1L4LzdjboVc6ye+ZA6HIUkGYIpoIRByrQS32NS6tMBcYkYOYl5bbKBxw+zkGa +C4wReNO3BkTCrljB5zZIAOzpZEUYN7OFolh/Vj02tsboE+h3ezXENDkiaZiDsfrxLdKe5IxQXyBT +VvIPIQTx+fMnVrhbO/5Z4xVtrNp6syRDBVsgfkeg2cGjqGbwUG97Nbxeu7Cy3Q+Qt+F+a8/Q6nlQ +dQXNzi5GxmVpSvN6S26wVBDhmH6WfVWPyj1P0S8DBUzRYLnGTY6ieXt5WfN1FFPl+ZQq2I9Klikt +YE7uhKqHM+igQbHaLCZRpB5EmzMinnM4BOQrBQh0MQBNQ4ijavI4QH6Qxvz2+YzfEofqEdTY+AhU +U/pRzQcj9v3YiQ1A7st2V/ncpQY2yXo1xCM88KW8t61QHl/fgrej89wewsxJpFJdKZTw7ahFCgmP +mLKHRSJihhR8kDxz/sZDSdeN/eqSyG/tAOX7E/tL0vJAAdmPrXlCvX7UoIn8gWm2sDgXKPGocoVh +T7Ansf6FPYnxng3zYkD6gbww1HP9+NY8wg5YM/Ml0ImYpn36vB0KUhzsU1sN5UDpZ8Gp2xc4gwiQ +nkPsBFu2L62jFgO3/HtEj4WL3ahYUMsBkKRBd+DEZq121ckAYtow5U4Ot+MA8l/MBhqHnY3oPTzL +BoX8Gej9fbzyzjZlL5cujgl/Kf2DUB5S5lQdR2mDgWdbJX66YnNvn+PD9LKw+NS2Qk+1XjwpMtgU +r9sTWorAek7DyuRdb0P8vgPEg1rKVP3xrXp4Jmwk993A/EsSmrQWuD47HlhDaVZvsKOLxiXMaRHe +2Eja7O/OuR6nHsMMN48DtdjAOoOTF/j03rB/cR13w/apMUOpFTGzToC9t7wA9FAkw7zRWVt84p61 +F5jw9IoUg00HZ2ZPecnMjIgAJCanxmBBlYkGoBT7U01H+nfiv58bWzvqsk8Oj4xy3HnA/mZTTOME +UZ0oqoSS6xU/m0e2ouJfCtkE0DOcNYxOpoLbFG6zbiNCidnNQ5pVJ3rPBEqf1v6q2Loo77icGBpu +ot6kSlGz56pg6/ZVAcnGXuTv/02oX0rdrUgA7i/NIEJQxVWxpIJTYuOTA0sPDe8RBJEQ6s2vhos1 +iDpsJ6uzPr5Fgmr/kicRmz2vvxXzodo05VReucLTyPTPHI5BJDUNXYuYqzAzg3aoqI7OcZ28ROgj +Y46FhIoGD/hR1GQdGJ2wI+r3hMbGHvZDbauwZi97u4MH/P6cPXg4lRq64B2LrMCvYw== + + + X35LpI3swV9kEP6VB0u4M/bvSYH+zx/2/4xvf/Nvv/3P//HLJ8vf/v1//NOf/ve3v/kPf/vffveX +v/zxn//pp7/9Pz/9l9/9wz/99OOf/vz/fvrT//rpP/3hH/7yn//5T//3z3HSr7/x3//45z/+7i9/ +/MNP+xQ/u7jndQW/QnT8r/xXLqBAlKoS6TfWi8TaAXX+odJLnrWQYvZ9ZIcNBFASOB4pZEC/ATBA +7BJRLrAfzCQVr6v5+thvAUDKVIJkxH9Fr5w7okVgFOlQNnr/GJ9VrNPuZ1CIqZ7jugnmGb3YzC5t +uFth3LBrICusyvwTKv44OaGXnMNm1DkQXZt9Pdmd5yOUjcTiMvuYez0v47N+CBhORaMcrhM1mf3G +0tCeaFCylZINqTS/0U66MzaqnEHKdoWuQbF+pIbg/KNnUfRtEFl2QyVf6G54xtGV+6NhHED23k4X +oBSqRJABQiVCAVt2cyCnPotMUFyc5tatQoKtHiefPeSZq8sVDs+I/ezOHdZXnRdm903wpLiCdmQK +kKc7/qiKPB7/Y01FBypRWeaZD5VJQLs8bA3YBLGxEBwEUpOLpPUmO8jhjYPiZHdKmws9TPXu5yak +9+djhkb3PHbYYon3588LkE9lccbBwkTlIU8R3+oHWmKtk9GC2vk+SytxZWc3pp9uD50Cd4z75iHC +RpCVRw4fYFjeSjqW+2dMwzFCz0cozyseBpoWmN4g1de/b2ghJjuE93qMj7Z5DNpZtzT2+0HxDjwr +AHSj19401gB41/t7Q6AVfug6pLx9i1Wshcs2HpL6lusEAVY14F8axKH3+LIDYh9Xjg6lKBA04CD9 +oZTcQz0iXquMlAOS0OAIjkpiEtQ9ygUG/SDxSNqPghOAOwHqkEwMTEToBuYQS2OgB878ky5jhBpQ +RQIbbgZuwF7Hi9cEYuCIpYMmHSc+Pl8R47KtaXcjdtoIK1CL6BQ7qHN3VOCG5j2I/O4XPePqSTSU +pHd/bvAVBneU+ntjElkYZqBLfjIffTEoUgCEsoT/mIiO6uvQgvtbkYkTWKTz+VBthxcW/8S2zowk +iBayKkfZJ1+W53p44QIynFas9GBwAn0iC0LxmPJtubPOc8RgJy61BBZEIAc5wkDDPOWu7zSKQkLw +XiKxNQ+KTKS/TwOV7t1AyCpB5wnDE9Wb+UI+NKvMJu4JYVs5LxCp4RtYNu+naqS5NKONLRzSXfn9 +c44msKV80YhBU5+hsNub61F6rT+HasRnwJxZo/aiGeZpK9YwuAyf17kb7ATfkBkU/Rtm0HLIAGgN +65QxQmLA4YDy7dDKaQhkP3Y0baKlI7KdVDzG7SqSsjMrR78UQWQgAHd2UafDly2Qq1MSIcV2Elj1 +vFzxoroTE4SgZRTolqM788iGpmCiGe4TekXIGo2zG2GKAN7JFLEkf8wnxHZ7O27mzjDccGaYHFAF +qQ7sanNgVMkH0qG0Jzro0d6FnJdzIkhn3ER0XKfwG6DODwVERznAJFCtiOCOg29RKBBwynDWemC2 +ucbgWRWXJhyP6zvK1qKAU4jKCLHYT63WEWiY1AFHLyyagvIQTu7qcwcBLbCvzUqZ181nWgjv0ERY +262H7qmHbLgdmuX3DFaHDgd6d2DbQ2Mi8D4llUD9JwDjRHl1fJwGqAidCkLiwt7k8exoUNd65CCa +sKHSe0D8dA6jA6AV6XMN0tp+y54Vl3ogfjtAPLxmQPZIm3KqFstioPTAYbcwhBrH+dq9xEDWOm7n +v/YS/HhfGXbH+C2NPX4LDHQFq2e8JcjbJjGB+3qqy5tVB7/lcG44ikOIDQ0UGpDL4HDwT2kY7SxN +NJLZ1fuAPFFB2WJdEz4GBjDDUqIBphDy2V0wCPfJb7w8QpiosgK6e/bjVZDQDdZgaU9rGKI2FRyA +opzrxHb31eAyQoFRIaj4DOC68Nkc/HGVr0jJCXiPyQ3fVrlaOxwib6iPKzJHquyZWX4Ud0Mp48AO +weuSCN+fOWeJAiHXoEygJhkTVkXFp/MgotAGIkOFggFZdTCSQ68/RmSBnT7Vhcyvgg6G2VA7wCPi +A6J7WtLtR0H9+zeCg+WkpV+fCWNTQn7szhozUGpluiXauH97aTjAzPn6DFc4kjOC+/L6+HsvoQcX +fj9iRz/9xlRNfyLoqRENyDfV9e9CMJTcbHzWvEmI0UUf1SP5DldqjHxyhUM9Yj8zdTpAZhpG77lj +8WdV5aN/VHx9mfd95VJAPuMqqJ5/ivrD6+8eNG+/cz7D4Fd9f+CU+w3lkkiKTv3oPv52rEGWauv1 +2cNDocidQ7fx/m269pAy7mfSn5CMhMuAKAb476ZMfmrKWfzA/OSLrQDLML3nLaACx9i6t+Qh/YvL +wqGtOw8DyiGCJyJ5qrxx05WK1BaMKfHxXeb5zECCb0gtLA1TO1IYLM8eDnhE6sIjmkk+tb+JbxKw +1FmV9KAsNI5iMfx3YCU7qpsM9Xw9ymlsZK/GnmBhAF7DWBp24EnoxayXbdCftPIaEfjsMKGMsJi9 +wTuNaGM+SqPFa5WlhNIABmU3IE9Pg2AxG+CRH4WbOAoIgqb5zr65jnSFu5iWFgQyXJvIBjI1tpjk +vpxpb/QCE2QwPbZCxhfwxg/Q6oLHRKmjk2XYD3JZTT0mMBl/k4XfCcwR585wrslKROInkcGRuTd5 +YS0zgHP9rrF282JUcdUJLIE5VZ9z2KBvhWGt1tbu82go+YLTaGSeRkmF1Y9tnDBzDlem51mSPVY4 +B3sBDUkOiDA9pvwXqg7j2CV3BUD8sFDVTauhMdb1m0EYBICspkYZkI/cojCbLh8WwEVtUtBBezWO +AkyWyJFV/jNHqMTKnSJNrgkcm8iYVjLRJk1/f3N25HfIwpi/HicnajLPP6FO+Sf1UvTSQHrioPTi +6tO477KNFKXZ2er5ltR0GWYEyQMzI/Vz9IFZI6flsSCWkz6eJZqQaJaQxmAkuhjzyxGWZmgg3cdk +HRq+nxvAhtyt7ec2+ONAuMhKLgzmARXXkHymksyEofIJ0MfJgOvQEdcXPXxvFn5upK/3E3KH8HYc +kEIptEJ1cpu4RhzthDKUJdivAPuDU4p2wpngUjk7AgSPG4owb0BIxEBs/yJ1AcnDU0iaUL5aAF93 +wJWBlA4lQD73iP2R2rDgV3e8oH7qp148pBRPDzHTjuwuxNT3houquYPhZ43SsEHAATPBYBx5WHYV +ZMMABXAL8UghIiSd/2rwMpEaQBmecLc/H41Q8siu7TV2h9VrRT1qfdFAGjrfPeZb44oSu2j7sJRg +mOQwGONwrHzIKey3moXpfn4f/mBX0TlBWx9fWkoRYqVTtTfulIXYOOGxw4TTgf50S5cWxuJwPd5U +GhPT/IhKmg28Lrth789NxYm1yRq1smupgjSw8OwHvk3bnkgp4YSpB40aMizKtGxkQDcuqydWoGjY +w4tvkPzyGy8nLn5SQx+zs0rsqUEIJPuYpS4+17DHMVeN8wFUCV+NHq9Gma/P47HqkAlonTDyo5Hb +jV4ct3v6k3pIR783VCxKzsW9NZ7Ks/vS5PwSqxZWeA0iJxHSeF4N8RMJZHiccIKf8vGtRwsBUNDA +2D23roNvDQNtsnvHPjcizUStPKujRAOOoo9RbWwcpjgkd6X9u8/vyCWqffVlcDStc/2vSLn3T4nx +ynN3258aVeSViDHOs5Ul/G3vPPC1CMYCui5aWc3n1RA/Dxd5GhHrJdd5v6UHkgoXg+pQrLnQjPTL +iuJfuusPMShl6R0JFWv7EXDTMNhO4tJDwh9Ti6zzFxrYTW+twpphKfEK9VDJIterNnxID4V/4G6g +QE0DdTEa3Pr5jTFteARLfOdCmahkQyh54rVD/VtTtgTuj2Ld2tdGhp+4rRVNr4BU3r9jBWr83KoG +F3vcj849hhv0BDmPpExwynxrINn34kp8bmRaPSEIOBLOAxiTbZXRIxcFUh6H13FUn8aLEZnTWYlx +8ibX8wSGh4aOqW3DhGfYMOVZ7On0kYEOR1hNqOcjOEkxH9Eo5yfF1s6joaixGxIifCqsjX7uGD8H +YDSJ3RQbmzgcktY86x62PgX2uyzjxrYBYrkFx28G9eurhhzOd78/QefPGpt+BBFA5L2NJUhoiHK9 +at/a5spf2Q37+K+G1/gYPVDOIANerbrdEaQRA2oIfCJ8ScKEic9CzYEfxP45lvxHabf9qmTstuAR +xL6JeRnxe+blhvPIOpvqTPWLC6AUx456fbfbNmUCJYGUCYK2r2/h8EvIAthUBEcPibC3hp9NsZ8b +IcapScrC2ykct6JHM65VU96HmvYkacgbqtpf736KOknkTiD4DmCGGtSSm9ZMaoCYBgDMgmmOhrQ6 +iX7qWDi/jsDxxPaMVEw30UyqhAKzQv9kji2Dy4y+n5u7xtGAmQf/hbP19zsJeKkSq3sFH8KjDRgf +S95FMcDjl8RHeyTFR0M0oxvVcWYd/27n71MYAyW69tqi/noWTopFuX/PgJfutfxRZRW0jt/xeIPP +RGpjmOtmvGsfu/+spEKJbVacxSj3EYhu1Q3WFd+AdcizGabTHsqA47scyKLIyWemCVCow3kDiM6j +nuFAS20Cv7tpILcPAhJWO4BJ6M77b5E4fIdUN64a4xRh0JDWYBbB0Ec/20G5BxocpWCd/fbSzDXX +46aGAwRetagr75WEeOgJE0CH9P37yQFxMjtxPgMkmvC3mFhY7Rn+aVEyVvhaxMND5oYAv0XuFpVj +pTeXaj4noQD9MiNh2ATMMOY8LvRMvQD2uxw29TiRRwl3vyHI7azHWWCvNU4zqDElSw3PKSHvZeQI +rdBpz3ts5ZpZOdOM0q3Rb6f+ivcg6fkJJIU3sD5hA7l7oKdgD7aB9KC8Gid6LOutkQ7NgF6dNCUU +EJ2kvJwcrhLX7S/H4Zy86YgJGg0B4ECm4MC2RSLv1wxM69CuB25NsHtqVWEFr8JxvAotBJL/VExn +tkdTRtb2AkVrQiu1wwMPEOP6eWKGrJisjmCTYOn0qh5G/2Z6uLnfPRKoX9nB2dxO064HZkliP4ub +gOLyXAoFDOQkrvWvvaouYnsqOESgGDLYBFM2ED7FfM3La9Y28IBeJNtL9staCskhyik4ROPjYbs0 +kys1dipB232oNaQA/O93jiugFFE/GhLAgcrdHuXKvN5GTLKfYw/yJGBLMIqLfIWw+qQUSdVAuuWq +rwYvijrtnrKBQ1Qmjde3qkh7WOHLve5F7b81ALsu2tS0LM47VpDPvUDry6EqoKqrAlJgyfnV6i1O +iKO8AyBlmaj3nop8/HuPeFwsSbxO5MzL+OI4PnZenTQEuZFLDzsoNvkUIN56SJ+oxwrqyDt80SuH +AcD0fvawW0pOLsn9JEGxTPYRmap9czHtjUkHMTqKne2Wq4oGDUkvpirMH9a2yqdjsiTTI8peSJDk +mLwsqSJhU2DFUSLn4aMBNs6ZSpj7WCh9ncllcIDMQRWK64FgRsm+UbQQOkKiD+zPGQ== + + + ehQkVIDMx8CELTodhiZFFEmX6HbFi++J3HmDSyHjB/vSjUwhx89TY82tpnf3nFgcpCY2p3FHeTXE +E/i0tL++hRGX0Pqi1Bfn8QG8NcSTbefJvt7Iz72Ir6GKTe6PToVc1ozLeg4xTkETE8cSKxHn446N +8ID53OH3p2RrxhCPFufot8NQ2mMlpLSnIiF4e+kOVX53uGSQ89sbioHm9vf2CJTaojKIANESJAgc +z0re7BbqFMAhsdT72+ehX1OPfs3ZYL11Qsa2n1pfiaIikYp1yueYPxqE7tVn6lJDzEKemTjhWhVD +8XUw78hKsmA9tHEQ+cqlZcXhWRn2x655PaAqHKcfP0cyxtpBdrPp/Wi7IDaVPs4Uax75SsAG4C6n +ShcU5Y5zJDgLegjIkJcAxAfc7GjHkZI3JCWF8O1xdKTJU53xTvxBSLrvlFUukNSgTNkA9JPuN1M2 +RlgXEjCH/01BPqt90WOw4xCHUvJ1cnzvNY+7MoqO2pPAH6iWEvF8iTSIYhNkIISEZLVm3ht+f0Kf +MnUnRqH0ee+1dy4x54BzVdGBSGXv+z4a0sU/vT5SZqIcmYml/+GOm4qF9gO2od7RHfc7GmLcz0f4 +6ecerxmhASuHSNe/OAyktBV5Vw2rO+Ys7SwCIvrRWF7n/rW4f9f8h05tdjtVgnl6hfvtnsVyDtCt +lfbdI7xRsePCZAtVnBjFObLoHCMxaWN5Rolm90j13m7XpLFiTWKszx6KenvkznkueLBTnBmpoBKJ +owRCqCOtEVac4YQFEjEyS3uOyB7iKhFzQ+JEqB3y9GcN0zFYzhTIYfNmkJqD4vsIdJL+r32Ca3u+ +6nF0jbR+yHfy/9xLORxijFJz0cHyiczBhFC2rjTTOtJMgmfGM9fb5w4plDbyfGtDJYElG1wUQnek +zs28QwgQNgeU4mzmkF8WsdiP+88IBwn2IQHxwbVICjc6L11wZUFwGHDJPNbemkfz7NFWwjtgZIEy +FlBTiZi/Y9PJG8q+AUD+Gu29wf1ViiryW6PuNAI1WghWgfeAafHR8BwE0A6A2pm+X43g+ZR+3Lsy +Zd7BHhy8JPcEki9IeBKDiqR0ynCn8I03YQ785PFGTiQONXHX5bNfbUsc97I/0Z2kcEXRrkDzT5aN +Rh8Kd1G8aco61HAetyG7IRQx93RLWVzWfA0IqWI+uwGnjwtmeAKiBNrOn4hqoYiEkY9qryqOe9Hs +TIYfDVVP9wNvOJ8l6W5Cc0JTE2lkNDWRkEU/9YuP3eWSWwU6+blxambt2bAmxiWrst2e+WxLP1tO +O6xylM3fGv8uTrXX6Zg4QXBTXoDCrgNBLBuUR1X0QSGkfteAIxXzhryP/MoD2LhqSAKIHuzWf8S2 +vUmf6CyL3jd72zz71+IoLLWA5oj/u27yb8dpK6q15I2TaT3yBrDIG+4r44sen1eRSH197oUagZKK +vNIrApZmXFKPXoo+GrxHe0tZRrxxEZZGZjR01Y5wrEDZGmuLju9KOFfez/0sw6IcjlI1NgiUF+na +GUg5NJwQwOmxs9EmDzJG76/an6EM6w9gDCQSVLxgLlDLZFKg1nm9ogAtX3avdaw9SbD2358iy/4t +6PUgb3PsK3WYxwyD2XvBS9lf61BsDggi8I37aFjQJ4PGhm8LOl9vHSKvmmKbvOeZbC3181H0mOJJ +JCMGY8vwMSodObD3HtQw+7iqOp8aZ9C4FZQiVGOTiZ87YhTo2hXU/0n2t5KRN+qHpv/jgSVAKlHk +kvxQOwZVKEM29pg76qtYecFZ4y36RSDDRTpIKHmnVWRoDt/zGXJIODIsiRm6krN6daIelg+Us53q +7YCjQ914XH37ByfMFnnVKlIcRYYayrXkf9Dw8v7D5RL5sW+v8OmRwnlObc8X6K+eyiaKSCFXfbRt +9xCysgBhmQlgz1FuEbSLDbm8EqNcMgSrYTpZDlxviiIh6E6+in1mG3avEpDiGfPRAG4Xevf7dVDv +ngyjWyES51qdGt/gLD3tMdyEuVlCqkeL0I/z1Cd08/e4D1GTFKBlskhxvRZIYD+uFsM5s75RVmM/ +F7TI+B1iO/feoB0QMK9uUfSG4Y286p47DF7wU4y63Z7X2lEb7lXF7kjlE3Oy5WC3AlwjlqfqRA42 +Ol58fDhQDOg72h1PrAVBxBIrEcL/+0VFaH9fWYpdG4scBe1F7rkkZGgVyguzd2Ny+OSIYIHW9i1I +lHYXhJ/98NX2YmfxjWJVgEWgjI7Q9GUPs8eAZCCxKVFi41E8cev2j4hS7ku0NktMYEqgnNHtRWLY +rxMQtajB20DenYZpoRHRuRINj2OLEuAt8EluRwWu741gi7OHrjd57RnHMV2BM6NuvPaYapIxaeQZ +wApqSquE2wLa2p7nSo+LNsIGTMG1E0BrLLMfcYM0G6S5aeUyrTOxN/E2HG+/jU3NWXEkgd7PcHxv +FS9BgbAg1BT1Iyy2woW1CBq8AD8ALKFgwJZv312q6aFeTFld/E8K0l+tdyoupwhY2T2cCRxtU0QZ +G1qaiFyBOmlVhIa4DMqxRbwpJMOKMExIo6lwjDTa5Qcjqiz4dK+uMvP4eYWpHPHWueIB4FFINV0b +xg5hB7Qt9Sx/MwUGljfsmualODaWOBu1Ysd0N6qXLdAhyoHzDtODjA09es32yGRnmsSNcwI15siK +v2qJqv3z3PF/HPaSgMQOTT1repTHHtU6Pd7gSA72HbaseXowCJqyK3G1Wj+jZTPucpjJ+zvC2FtN +70TM4HvFWlQp84gsRJOmyr06tt5gnmF/8pANAZCoNie/jmQfatPP62m3oCxoEymgYN9DBmelrsNT +gi/B67cXelVMOohh5RRBN4KYSxoShYUHOgCUWl/INTjFrFikmqeDu0U+WsgzSK7q8/JMrKpxj1Az +5B41V2NQjS0AatP6NG6EtzheIo3XTu6CHy4NOVAanpDtAKV2BfQo6AIGSykQllBpx6HCarTcdP09 +ObCHGihF7OcIhPDWqv64f03I4AGrIGOhKMSyIF1Lsu4NazGKhQ+FAFJxmJuWUwVX2XzvnkYO9xJ9 +gfftU1fEHtVfts7dBSnK3R0tDhC/c4/yenMMWKAQaYCJi3edi8HgEJHQOIz1YzxSRhTpTeli5SWf +kA7KBQNAb3EEKz+Iq7SbYdCCZ4hj8EVpBOTsIPD3QZllr4WY6PnBMXahZB4nkEjRUVrSKyppBsf7 +v5/gRcWxE6m4tKSgw6GsAuWcXFxofwK7LdKcCIiCXoHDPBY3IREMNOsxoYC6LfFPaqeUHxFOOO5E +4gO69wl9XCANjkrkI1Q93j3go3771SjshnW/hcHoofCIdsJLALQT4lU19Ln/8Sz6WFHx8hbgeu57 +R8zL4JEJmsizA6vmJ5Z00aEzLHnCC+ZAEmZgjkhVkc6kDZwZDU8SBcrQLzZkATAzmBXA4MiI6lZ6 +338aVzDllVi18xBBPnydKJo3kJ9kPx8bGEjxZV2LNIssins8gddkyCxK+Rq87w/IF8xSD89IjtCo +pLGg2I9TAibIsqgJRxOenY++njBV5gk+U+HP2wxMUlCe9puAhtYLZx2xXArmEcgHip809kPOU5pn +N4yShW7XGEjMJWiSEoCI2n6BciXtzWp4t5dQAdq6xttgSEr99PE0SF7H0ahVERCu0A25ayz7v954 +ttjmZJ/VULUfA3KiNtIfFGv0vBkR1345wH78DccyaIOnxl7z2VtStZnIaPxjNI5pKkA7VxsXLCn5 +SSrPt7BQMKg2o9LUn6BGVz0UOYt1GQyR0ciSikjGY581/ZbkZKRmWFInXmld+ASSBjZobIC3zry5 +mHKgAEVoivto1LyBIOzFMCrIlCsWOiPpKGxqxACD53CxRAem4GkFb3gHF4jNTXbZMxZxkB1I+9WI +n1LET1HV8JfhGEcdkEbSP2SUkUF0ljNcbMf8i2mZd88Zzs/148AqMI0XoyajnExjRQWMlx5sDlDe +1Y+6bQ51W8AEAxNwSHKCIDQQW+Oo/WNfhLIhU7x3qSO3AsmGPCf5NnAnWN2gSEtuyx9sdFFDBXSv +bevm459y8lnY2pO6xCCiBpAmEn5wJ2eYGmPth1wVkji7YZ4brE70qXKkEXsjDpUhl5IGDOcTC/um +kCO7voMb5MizTk1dSiQDzDxVA7e3A9c0WzifFMQOMEC/eiTkztU02BH0YJU101/N+e4xRfWZEJ/5 +DnSoKsLzKFog1ltbQD0QWQUysZ9+7FO0q9hvaH8tkxRKwW9N3ERdJp89ZbLWNcqvoV9mzmyiVdhP +D5SoOtYkPfBKjVG2p+9avRbGqT0W1kIfJRzchSnhFJ8K0Av1k8GQLI9jyXkqFDXPjo27R3QgfCMF +LgBdG+dxtm7J6Xq/RHdiRW5OsEg72u3ysYrHYXzTTvqJ9nZ+0YHHCz7m/Kp380vhrJEoy5emgkVo +ZVONagLrPa/sdEef4VUqriigc9aUjFhWNXVtWcULy+T1ul9VMr43NH9uFYkMQbKMOMwjoxBPhLZn +5JZMkRXy0p3KfhY6sqcXIR/MLjCgHU6RmmzfHVYSAIl39WYRiC4xaGVeTpw7NE5JIXwukqirexj1 +AUwQwjitAiyIl2wEFSqsxqTBJ4xtgICAUwre71DGcUatApov4xAZjANjYyOk7kG/pOH9lqPAWA+R +vNdTrcEAe5/6GSdF3I+5o1ug9ULFLfePYPxIDGDzJCo2f/C1g8w/CbQFmDTF9YECIAIlmKCsC2XD +ZNTbu98kPQBE+Tyxr6AeP4tPbL/KRTpYt0Sc4bIxXnHtvLOSJa8nxECCg82D9W8zNvL+d/QgWVu2 +ZXlVBYKwHaqzJTgZRe4rf6+qEl9VURMPlyM5onL8VKsy4qJ1sHhceEHkBjF1uI2DMHSdCnSg+75c +b3/LAJU6HBz7crKgrOXw6hBLrUdmC6ovsG2yeEPaXTsczJdmJ5+1rFG2WXhYj7qct2ACIeVGfbm1 +D90nXCjMs7bXca3WcQwktCjSMWuHt92xnka5YP8/iUjYT9CQyPDWRyQkWwYU9rSvOBlaqPtT7eA4 +NaGZJotDp2te0qF/8t6Pnd0F1O+izFjjQvaf+414/JuUFX+TPW8lpMPOV+ZciqI0khLD0q8CXuJa +FfYaIV12668DNhQO8zNCT/w7kxKuoX8F7DfpTfvDC03OkiEchtouCZP9ygTTAbMsfHjwWUQtT0js +Eyn9vVNvKk8jttk+EO4Arg7ncW/fp5lyVXVBLyzZfXulR895lMN4ML2mMCew4+Cw5huilxIZFNWA +R0hPlsAfBH+R2KsEsaUYkGETisD4szecWTKt/sYXztW7qBBA+0V9FhLy4ih5i5GIosRcszhFchzU +qbA5vKxqCmcUSBAWh4bL/EuCl2JjbEmWMsP1g0Qw3LZUg0Eev4LGlCRIHSzrwQ1LOWatZ3wI8MAp +XtkKBDkxJOYty++fRQKIaRqn18u4pPTCTCRvfu8nFoJxSR9yQOQWq8mxI/7xnH0GEA== + + + WTbL9zPWJmIseUdILGtW4r4pX3MFHU4IMGu8zX5nSWRqKB6vFKNOsdEDfMRcgdoDzG9m7qXLl4OY +b5SgKROA3XG5DkeXXwjZihuB6BL3f8RZB5BPgMBXU3oCYSuCg33hIWZjHxQmcSEpu+PE/Zq0/FFU +5agUeuDb4g6LWAN17SdQ5MBHoW2/5JdJ4uHHpWsaUUs62hUos5egwUo9FR/HKKWy14IE/kF/Ai6+ +BL3hyLsvPen4mw74HZdVpE4XerB7YC0m8yWnr120J8qDPFFy+ORmMTp9iqMlsfNuT4gKEW4eyk67 +tOt+vOTBAu/xqgolQppecpf63I97Dp8BixUAAO2XBGqWHi1prCtPJfFZPN/5TlrBbHYwUjFDDNTz +FeeFdb5yt/ethGgQ915JbdhN2FmboZcyy64Ib6jxXFtuJkfZWKLDpU83Z/qj9MzM5GqR7q/RIoAZ +v0Fqj2mbwgQrCvrrrEp1H4up/9Z/+Ux+00Lwy5WrAEzAdk7V1hW7IP5+aYjreORHUm7Rn2jKe8qi +9e/yTZHEqyO1UBm1TljBvlcTJ006xQiJIkzGmbZksEVOJFAg7C+1lEbT1x8cCNslfQhJk3o92DK/ +azHkFRaGIw5WmjWKFwkjLQZYl+UbfAEFq6awC0W2W6zxVKlImLjelBZA+7MV2YfRpCcM83IJw7yA +KwTygOx9NZpiLy6R1hFOBBthFiKrR75GYHO8SyAwWoDWZ+QHAkZvmDnExSbXiBRY5UHpYz/YJ4Wy +rAsLIMwkmrplMSHsIpKQtGkeEOxVy2KmyHh7vv00WCd3D+GMJVJV7BzyAYpaxQONvm4oPI5eVz7S +SdjEmRlN6dBFGrgRafEQt8Hc7Dh+HE5JCXTkvgJz0CLowQiDLQzsLCcgrMEWOgVQMiSSKo7cEZjG +T93b1+coiQVWp+ypbh3+zJe9dMgqsW3JV4dmhto/nwtDvIym/c2ljp099KtFIql9HJ9kwu41Djxi +6eBR9rb3Ocd/hHyAepzRA+UeeugWRFAceDzgWCH2gg4BPQRN3BMN2AF7oEZmB+zG8jjk47skHoOK +HaI0FYvaCoPvQZrFQF8DUX4SfiZxDCtXO9bYW9pxzsS6jSfKg37vcaIGs82km9S4Eu0k0rkFAvc6 +0z8tMS3KDBmipWuYjetun4+7/Sl+2ot1iF6rh6FpYOKG3CaPUwPzXPeJroFpsWEPYyKlPWWMci1P +X8eVaz7MWWlZkPU8tVoP4LSFy+kKJjPck4jlLNGARJXJN49fDhW2OwEQCmKb8qBvPdh2iKQi24PX +qkSUdBLnewoQM/MZjESoqRekhEpRcJ9E2HwQTPOAZwb7vxYabs9B7MYU0M9Y7RFOaf3L/mL/Pl4/ +9535whhih9tUtlItg41EmFSiIBHSRKKT90XnJmAXO4Kq74yWX2aKstUIhJZCfCecWBfuK+tkoNFh +SGJ8m/JFPBBqFjic5tq/wkOwtQU8vNdI+QWLXSx15IaPQuz2Ho2JH6/v1E/yEYs6MYoIaWXucBN4 +InkRmArUqdJBSDsNp/1oZRmnU8vBnkNWzDr6l+T3TwGOXpG5bgQ2cSattEmAOPEDjBRy0Kr7Pnv4 +sVL1CMKOOD/3Rdz0etG8SXdQONoHRDwXBBKMCRBI3OnIg8uFJiwfTrwiHiYqAcLVV7CJO9SdGiBa +rpepfr7yW+jgSLikuuSPVbea5YqyR/Y4oTIAISU6RGoZBwfx70v9JRu68koBoLjHJ1S1EQwowrpa +VDJyoipAbjtWIuvhU0h4dIB5zNCqcYR6X2iRjBhK7/m9uonDWzabpYEODb6sEDHxzkRCGmZLvX6S +4OgB0B5rqjv/GP+Ai9wB7yKLiJ4vUi+odJq3Ad6CiAQwna5TUokSNYUlZSaAjMcMZW7NS0uUGQce +5leHUjSA8H6kBHIwLiMTAlgpzmSpG8bxkL1GcGPEjKlGE03DXEoilEI7EQFIz1Pn64FTQVCIAPiZ +h1yKKympwoHO8eFt4tlu0mwda2KsmDFB7oqEphE1SJPRl0xGpJvE6e4I5CDhfR/BMl7TeUvx+mmO +4GSZnp6odM9YYy26DgBJ4TQ2I7HTc7olIqyncjgal2A/rfBTomCmnly9uC7dv05OSvOKvNflFPir +CScRMjJqSVBYXqsD1kWCvjCIZDqNWiAEjjDbjh7NBoHMk4LC/IXjBi1Km9/2OkGsI3smZsWXPzMO +fyYHE7iT2sVlMM3DsIkQawXtDm14oBHgPU3AJ9E4xWPcXEoON51savyCw6FeEKqVeazLJOliKOYE +jhZkM2fP5i3WkrgWZoTu3cahiLvdZrqMtKO/MzqEzJOO4G/SEWEiq9YA90W3dWJ6jgIvy7BWeVuG +DxIzZocp+rhwIJt7uT5PACQZmc1gN0fKWMouKwoRh9SpR046wXSL+ZENs4kbFPnDwqZ96DnIZ99X +MsiQu3GUqEfKAqQ6RZ/2TfJFi+LYCaMfJJtWY+zXV3jUkTYawKmm9Nyo1l6ppj0TaH7GFt5wKVyv +2PJ/kM5ZjJeJnxo1WBwiRd6H9BRiOFOfvJQs3uKF9DAWqZPc5Y9eVLjp5WyXRjyYiZL7jJJM6ZTP +gAuM6OE4nLqxZ3tUFzbgqz3OFJjTqhrnPVHgAbWpiuqBYfTuVNjUBRb3kcOxVGCkR7DoDj+IHl5s +X1P4EamCJyoQEuTiTCSckHVVYaciCn3I/WrGUDsLOPreV4XgiUZD4AJYPXYct8727aMwDxKJVXFo +06PmmvpZawK8G9BDZd0DHQEZFri9ithzD8oi+gTT2PkcV4cW8D17iq5nmZzoU86MYCDuqNQWUe5q +yhRIo9ZNOtdYCZvcjxFoYwBg+MBc5zXQcRU5sRZM/UhbmvKH4zbFuz28bihrlB6HcSdH3l/1f5A+ +6ArgtxYRQQvaClH889J/BWIs9GcP+Cd2oIJdKMkd6IJARLDDxY3oIjPL78B1/mnDWmLQ7rqVR5JP +d1sOJ4kHAPvBDW4lz8Thl+It6lgZCFsnnHEcKNN+b5071tzwCg6MHlq41R20pO+AawoqgXHpcaZC +BYSaZKoHlsYKCuRKEZ2EX/bjcXoReocIU/EY7XRILDKshit9eKMKO2js6LK65RCHQ4uF6QQgJrHU +0yMXoZxFV+klrDGeGbCHiCwPyK3jTnOMqJa/jgz5CA/XkDViSbSu0gLDhRShU8ySzaHyxQya9icd +89eZxEtQtZJkWBhkav4OcuF6/Br84QjLZEDQkcqttreotj+xQu2lmsp/hTZ5YGTrIAOxID3id12G +S5vqbRezC0uZHHCK9tghD0vqNKMm4pb5CD1TRHYkKy1ebeiQ6QOwVqC6sTcRDqBGD/wAdqQp1L3c +YwGr7Om4ecsarFmlX9CPLaTJI/ew15d1Of9ojIgwQw8mh+5t1IGFzTWfqQtnYzquIYSrMDmG0W2F ++k28WTvcMDkAPMg68BL6cV705+ir7QUF0UuhWlausRicIvlCsG6Aszls1jCDUPIWbTgx2qQQXXT3 +gEmH6h76dCXiQMXnM3Zq06+7SSPFsFpoFcf8geLKOUGceM/j6p7QQ+4HZsPfncB6+O7Vx1E0TkcV +jYR6g3xX43PtgobdowOZ4iYCNy5RNzR9Eq7uDtmnLIhrx88zhI7xcKfGCsnrwLwQ2mHV6oHPt7AP +/6yOeC8BASiFZBGTO3inDeYSKuU7vKp1xe1dakRC3l4HNww2CYel4i+JgjXYSveEe4FiufLaNEne +ofS8SrPFFBziPELHIhaqKJcP/HsFi0JxYgxTKOh65IIJ8Ke5tO3wUYNLekifH/K1noNRn3oU0MZk +Rhu6yH/3bwI/rVwbHgmq4KlUyAYZRQH1i+rRDlKzvsdxYHUKKW9HfTGg1ruz1wkyhR+w15mrqg5Q +1o12Q9R+RhRd9ZEHkApmvtUIACpUAcUJGMHQspkyZng6W4LDTcUS9fywSAJBW1Dzb6CV8YppISLn +C5IIXwb7asl4sUsEO6TaGRnQ8K7MZ309ztApnKH3azePF5ZgDbeUDQVnhcSmM9XssU9i3weY6Gck +8lkiFAcvRVF9KGxnZkz48P7VpuEhWCmIgZLjDjvQfJ1XOoWKIz9kVJ0rgqOYgmM1zShpAlKjHDcO +e4kqAHj0UVU7ISseuD6yewojFzOGlFQN1dSDZQNUYaAUygvrlYloKZQ7R0Nrhk2eTjeA1UO/A22l +fUmW5F3JBmY5aAcfyYGlnMv6lk+5ZtYovuUVpUVSEI9FDeUqfwx8FrcVzXm9+Si9AHJuUXf4XHz/ +LQv7/+4XHW7+ygP9inVM/Jv99ysTFwHWaPACsK7G4SWYFGFAdVhPAKx5W3evZWL1cy8R1CIpE2W8 +k9CfAVeLBXE3jEgwRJxP4u0SkNUdTpJR8oxgerpfWwhrEKVUA2aeqnUmCTEm6si6F+u09bUVxoBp +Kby11+QmmlH7XhuapXHhNUOLmaDXhBjjgKnQlXu6JS5PZQyO+O4QPPCY96R6ahpw7DUytKfWzHG4 +Edso5Nn9/Ln50BU64oeeEPpgyPQvdm6aGbPGi6Xb8cyOgqwB634b026JnQrwTI49o7TIhFpjQd9b +BwqqRz4YfpxcSlyDoRn2Hq5fHq2IWgbPj96zlUrFouEuOC7aXp3whGCvzRNhPuwx4ZIHQaTwZ3Nl +BJxA6fDsS9aGZSFIasmYDKlsqKwnDbI4IcYhMdPQoTtgEhulAqKgWzxaXBsNFSoMdLqiTqLixJwm +pmqMsPz8vrcF625qP61AJJgULH3n4RU6I+JTwH0UioChGAQ3aq2nwaOoJo5ZDbHJ+Ggs5qkg7IBB +jPsYushvDXBCrt/JW2OO1aDAa8b7vTKAKvVISj9FyTaWsh1vwUo4n8elUQPe0TphrgXf+50cLFOs +SeAgIDxMtoEv7GHBF8LxgGL2leWlDULfbiM9rQAwBTIbCC5p4LXDIYBSPw1G6rthv3Oqm78wPjSa +R9mNT4lTqZVVIO2SvMC11dIyNF9inFbMhXGUK59UdEgcAUQC7V5P2sbApytADmTo/fP0YRX61liP +X3ARC5VZH8IKjkeLWEF1HavRcHWZQfA+r48KUFmcSWtWFpkqeCNz89bws6f/ubEDjCFEBdNO3Wmv +xyhSjqLoVNFVYd/0Gog5LWUPiJyRZPReB4rNgqDi7QfLAxNk/6YC4gnZON7+f/FbIxhUsFHB2QCH +J41rA2b08HlJFQ5RKX6uF2CFK9UjdXUHoKq32YM5a4Hvn+cS9jzul1YJ03DhLzQQtPB3XdfrCL5a +0Q5qJZX9hYUxhODPEsVZu2W+D2e+o39EmbrN/GqIPfMhzDQdVL/7Vkpn146yJcX2fHJzlJiXTKD9 +Q5/QytKjivUqXbQzvbo0G1RWYj3UEnaClKQaB/iQIuNeMUukFwqoiuGKOS616V9def/VeOOvNMI7 +TJf8nGThniLY0oNmBQzhIk+ehjIeOzPIV7yDy9pRvcVkhG+6MVQu4apjfm5aTtMq4g== + + + I6TTcgdwZaopeH8BHrMBpxa+1bwTB9XG4dRDg/ORPJzKl/dwUZrHV40k7RMpgnwEoFm4ZSwcmwEx +AqEU1IrZCoxYL1dYSGi2Pr6HpTGfu2dgB/qk7EdFVV/BWbVBZYRRCd/TulZiUpw/7AxM60XyeQru +UVA6HVlMxAApV2iUVY59uMDiCvBXL1nlFS+K0M3AbpTq3U0MR27JSZ5vcdk60KbQ4AEEinhGumJQ +CIEVzbCpaKkchjg1CpdXb6yFZhmesTa8tGfS0fmfaB0xULJO4AwF9wqsf3DOWagCvv0LI+vH33IQ +g4fsEs/3pqWGVpBiIdZ/8hnHhcmKzAqw3sPubrx6HencJ0rlegURBYYR6gFKixMwgwQSSCVBaMZR +tg+sASXn8lGUh1ZLr6wjIUiCFXiDLm9bY2Y2Q8BtjtJSkE3N14eontHlAM2fzjGSuvORsL41F9Ea +JIPWkQkjqaGfz9miV/jOA3YoadFx8sdkjhAwAQ4Q+HeEmQl6P/eI8LSfgga0d2sgn3rJeJaRtpY4 +WPUBRvD6H8A3JD4OsywPtd2eY8Mb7vAfYtDyv+jVDkdTQ2noleDa6eFL2q4YH9wUst27RwNCSo+g +ma49MmswMFWpgcj5vHJF/eQaSIORlZLuKW2SmTd4pxEG75VEQQCOAxaUxRQFQXv0pQlrMzPO1XJX +oHLOl7r+ikkC2NMUB3D4skQ1Er7ZnkoPJ19umV6wzA7J4HKY9VGzXpaDNnUrBAj3dZXRP9YfCmes +P036ERt+QBVEAGLgkZM7WbtVSd2kve+WgnoaxBu6Td8TzRWlfzX2U8/e0z1obMXSRRmg+TpUW7HQ +jsuVmpDPuJna/WaaP/3U4/cnfyqZEs1yFR8/95KVmMLC1qDHvwMzJEFnIHp32e63EQ8B7bCoDFul +OKlrjJRVwgBMFOwMtLSyAYD6b8Cr+flUml3nmUfGvCdIIbGxh2NWUA+k5ZBRkY9PRbo59vCltmJN +xQxpGzyk0sFn7BMtVTS7TPeijsdK43UihOjoNQTIkYvo0QvOpccRiYGjs9xfeoxjMswutOFEMS7Z +BI3mfYL0chduZ9wtmPphj5apt1A8B0JHBjzKCCDlqS1xy1X527e8jeerHjXM3ig99ee+1597Afhm +z8B9mufew6DinlUpbRRERxREn6vorxZpz2b53zrEVHUsZ5DoFqj0dhjKm27rOxv+YV1BPaC3BsBv +jXoAcJ2riPTWS5cicrR5/w5xYSO0bkkDzOPEKTwHh0pLEcqTWUQ5vKl+FTHQr7yCRcpXdIE4zcI7 +MbOPH+23EfXSzPxDzRW5yLcBQi7wJB1qICPa5fHsuYf745nYTMywaAsRMGSvbp5clETG6i8UykLX +i/ICsYyZPBAbOw4WogkhiXUVQhKJwx8vkMK8oGn+8IbjAamwhRmcuT6RH6QqXLuACwChBLV3StfP +c1QfTY7DVeo6wFH7PEtijxQ9cDQyIB4XVATHDffefnATWLjkAKqp1EePR7W3Hkp9A2twpjFOlJWo +Gx9laMAKlAwAKyBCYC+Mz4aqFwfOQFJksHrUIFdFsh3JwR7CmiHT6nZkXJtexHoU97vIoNblaifU +ZINkL/qssHSGN2hgDDupshEYSLXDnoY8xLdfj5F+y21Fu9Tdz47gEpXIky1XsMMEbcgWhPuH0VI+ +patBhcLEs45lpuPM+qFvdhTusUGZz2lkRaMRYRD3pDNSgiqicjhDahV2Z6gblPjGvFAIzVtK3B7m +f45ipSIQneI2ede1X5GPKAa027C/WV5gfqUN3QgXWQyyAeHdDJiDMxgQ+ZJqR9Cs9yt71kRt0QD1 +QGwJNOueqHFwqVSyylnCUyzh4GAgozdhluWgILPiaXFF6KKtsPeNGiiAmh68++vIKeoH0ZjnNKzj +5VkjMdLzNRKkUXfu7rzB9GCx12/1g9IlaGNhJVDm4kLfs9y6G0jXc9MJxFJ4DwxFWwsqLJMhUcVU +MXvMgGGRMfpoKHf9n6AC49bZKKiP3XzJgYoPUk7HC5tlpH+TS4tqt39ZKwDqPG+7hA+w7vAN9or6 +PMeMWYndciR2Z3mJ/Rvqp4v+Ir1SBIaQ2SF3S2iKa1KOKn2+bKcrv38/w7sg3GlZENVbg0k2omEc +tfJD/z4faUYoelbslywc0b6mrIk091gBRbvWIZ9HLvs0nHBAhmgLEWMMXGzs+aAgQr0egaqrFsnG +jh3Ter7o0cg0u3bW61vyRad05H6VO4r7FIKbA/o6k3SfcKp5JuGk/qnhPLg5zzz4s8al2msU9qti +eBTyQ1Nd5Vy8l4XRA7G8HgSCRFZoByp8Sc5nNb/kICZxqY8zUv5TFphuvCY0WdPIg56t02rHR55U +qI4Ae5+dlrLPwUSmIcxfd6xRFEB1jHi48GLdl3jCG7EVNV6JTIZqBBHMAqemrA0touDVXQXjnzX4 +oMmNH+BEAHloHN7m2vR4JQe91IYGwftdQ//hSG/vSzvi8x+NlN/1z62ZBAQIjpgP8sHoAcecsiRR +fnpv8Dey1a1ffAtT0LML2EetYsUr3Kvxsj7Y70sslPOAJ26bCX3lEHc4UXWfaEelMSgY7FyTvhwa +r7w13AFcUGoB66PF7edepJAU0YGbGV4I0tXBN5Yv2omVrUuzQbua+/mgqezTQrRVejlI8DpuoU0N +AgBly9C1Ab/ZM/9iacFkQ2zv5wbvCWHtV42hb/KcRbOlWDTDTLYf23TFPzF6uKLouMrOHtyDEn5q +M4gYFFN0H+64dqqIEp7JLXRAlP9Mr6MQLccpiLk5RSl+q3lNkH7N1yxJT3whjNnbka9eVsI9GBoS +1uLmuXEdcrSUvMZmQ2yRkUmJDTUauo45G8ppOBvrfuxf3hp7PRrGsLKgjO+ofLJR+GhogQTaC88r +xni1MaeRYLNozabf3XVv+3aFy11oSULDZN/Y1bWLYc31OhfRqGw4ilbk9VaQY5XlEfgBth565UKL +LNy6G2nMbt5n3cOF6PKU3UfmAYJ7HM7AAWGHHXcocgEwzBuWw4LcHaN7t0NflUFi8EXuNnn/0c2x +0uHaDFnV1Fpjf1u/a4D2R56rUOI5PLfbqDJKD2WUtUwnFmFKn0Vp8bkTGvqVpq3o/3Elcae4LXXK +9IHn3Uc0VxtxMDePtYgZ0d48KSJS1TO2aXMEnfOgOHqgOGphIg/B8CedpBDg//0okB2LC/jU8Pub +jQeaz+5Ez/vPveAVBOsHsw+1RFnO9BMfZWrI9LnHV9P2ey+4nTAo9yRZtGUsRwR09+ohor+A+kBm +NLGmRHgOiXBpS/mwlHbMAuPwO6OneoyeHqH2iNORg+8WCODlFWGlkx3OXlSbWfwKRlJIIJFRDm19 +cDWYaLK7i71lOj5SHM1oCOHlGYD1osZyAJzfGv7l7H1jt772qp2fL74+FDUhbC8m9VQaIrJEaUiI +PLCSkUVII5QXZCV5a3vxyVcLq4aTjp3y7cTGk05jnsOIUEAndZ4eM3ooNGKPeXqYu2ih4mOPcc90 +3Ot2L6VlpU4lqVOUV8wbmLwl2eyIatf1Z8fXIxDUslF2h0JB1B562I8P3OM88o+wWHKAqkUGIdHm +nayU54j290415GnwdgmTIQVVUF4uV0f1insxvZ/B1xR8n4FhV7XS44NqNRK+eTdiuFCwDoNitjGH +yBK5n/2Y0vVp0cRkmkhaSgWBAkhVugvpYI8Da1MMulOwx2HHvaehaSHvOaCCR3ZOUGbWxwkWO1hd +WntI55IJ5OuPVKGveijbDWyl1ZjRdFXiBFejF+IJ2rbzpqLwHdMLOYWiETBvWWSoqzyWX6jMqcht +YnhPxqEUwZ08t72ewY3vi0omgPuBXKc+pbisGklRdNyu7Eolwbc3jkUi71sPWCwSuZiOXii3eoQS +6YVrmnmz4BcESqhTGlARISAvo0e4RZ5lfwuUHSj+k7MK8jeJjLCQPVq0QOuBcBJI9MOJLN0sBOqx +nX2UuB8varSoSnRwscndVxiujnZNZwFWVxryyqHLTgKDjte8nc/kKesqgfoIp1gnA6LP6sIe3D1c +iGjwjQDo7hB3/ySMX+4OVhMZsOFgC3cQpEmcoFe/HqLRE5M6ZS5mCNNL7EPkn+Sp8vJXk2M3hl3Q +HiDw32zs8a0mUSHrOqwdaX6iwXo32jw8Is5zSfc2dr1Lp1wTjiL9dR9lR0cvZ2HPq8cJRrvZBhFL +95aF2+7epqAwNo+JqJmpx7yMmW12VwqB2xCwRqalSaj+Eox4+5YcFUiDE9NepjQDyfCpms/JayQz +3VnR9/g8cIf1MIb3zilIXfEdSPkrzNmDgyWbSgOMPbZyfu+BaGeuNzf5qXE9gSdj42IZCZ4B8ySR +A6wJFe/z0ChiT/0RUuRrVkM52adXiqIkr2+FJ4IPpENOmadY/enz6wT2eqjft81Qd8gaj0tpfIBO +y7hoKXYugoG4RwBdH43CPu6fpmHwCfcuFf1R/SBbvfDQhcuyxKgVu9knOAoXbMRHLsu79/6R0TaO +LwhcoedAdPybapXj/wkzRozE7pU4Q46KZjZXP81qiW723inzFDV0xPhm3SftAQCP9G7GJq6994jb +diKLt6+jTwq+jsQv1qiKH3SxIBBLnvcePo573M+N4gPTOJfV4rJGaLPo2UTqo4b8ysuGG71FyfwJ +GaPxagzAgHZhk4DRgNQ6fguYPPlQeVOAPx75wc/sd8VI68ANQPTkyIgtLa5KCPYKKtDWCXdp5szP +abG3HtdG/UIUMjudecypyZCZYYeBH3JJSsV301TrVPqc/R5nHvaGr6P1YzjAOgk7z23oCD46iWQa +9qKsAE9fUTcUFLg/106lBizxHsyJfsg8gzE3LO+lUAreX6GkLAirjKO1BkhmN1RynIj89CtPAwbd +uLjCEHeLBj6MZ8kEy4VL5jh/16mtSUwl8RGg5Kgs9BMp1xrKDv0sfuwipcIhJCixIRpilD1HFxiN +bem351tQwAnhmEpDOln5qffPn1jnbmHsZ41XvIsaVJLqswfsHIIQhd4dUc4Ropzj9fnrzdJqLUGt +bB9fgnOh4MC+NyWJzROhksMMFk2BXESEcnNuqIQovzNpypRdbVQvvIc6LoRJHaI4ikvfns9JocKp +XteskEY2rNjdsLXDCGRdHxzR8mm/uvBVCJeP94sINeziVpynjHoPV87hMjZ1Fcj5seC1MlrcbH8T +LVK++HzGT4ixtCLIsXFPLy8zdXP1yvWaXbQgqMDuvgoyYLchHuHRsrmdVwthRTTK2SH2cZaF9Ryy +ZykhiiRCNQJKRpzgBjBUgl5jolZ0Gt1OpulH0KvIXeq67iI7cuRdwCumN4dcdSQuCUx66APJwn2c ++CwGo9BuiWEc7X196fbeDOMhP5+33r1OfZ8Bf4omfikf3jkwQjLeQqhWfW9oh+0QQMLPjTWEs2TB +SPJB5nwvL4JUn0M5e/yF5Xu8wtTHm4JqVycvYLWpHJttfUNCtAiYmA1TMtd02w1C+A== + + + Bbem0YrowtoxLFGApHmeGjJ8A8z2Z/obYO5ULzoGrx3ROhWXCgkbOQWMZwb8JuXzm0MX6q2B6vVL +4vpz4woZvnIRb2ymYBVhgI2uGACGaMAFpPVXQ2x8Vizf8N2QQriNAE6CsQv1b6g1WOYxTDhMhOS6 +uX+PNznG2Dwl/UCH2Igz+d+dcz3hpjOJUy0llEgt8WhZeAOdcP7mLl9jyvOZhrNa+OWDI4X2vp/k +h/k4rxz4KSQ3AKymV8gIDj25t5OMgPVt1/wjAPvR8EQDdPQ77fr9z437nQt4FuasLplK9BchiAaP +wJeNjCDE5Bmyf0dpSdkocC0gVZgUOymuYbhoPnyUADKyU39C603686mRIWZI4Q0svmKd1ToIZXbp +Q0QBlHxJ2wK3XqF9QG0XfO7e8aEH//r7FErdjJyPyBjppsui35/X32qALK1Hn1zO3Xk1MimjRA0u +DU1TrZKZctHg0MqlwwJTaQwUmuvtvm8W3BCh8AcirlaOGR0Fuj1S0BuJJUXn5b1k9IDQfl0f/y2L +8HKJfpFP9FceLGGL1L+nCPk/fyCb+u1v/u23//k/fvlk+du//49/+tP//vY3/+Fv/9vv/vKXP/7z +P/30t//np//yu3/4p59+/NOf/99Pf/pfP/2nP/zDX/7zP//p//45Tvr1N/77H//8x9/95Y9/+Gmf +4mcX97yu4FdoT/+V/0oIwk4R21MiAabmhHUOS8JDaY5grsBF3hNggYzMr1ddOmP1QWD+jdosInOo +8lDLHt8AVJB/fX3st3TZyDPIcl+SrRqLxSh6RyIM9q0QVoKNwZKcI//j6bXff40fF6H4Wy96kGXS +GpL0WFGJH9R8DfQdPbpawxga7VewGPKeFylZ1O+BPQHSSQXhkflb2SbuICagZQ+YdWjrHdlYtF+z +Vt7rQch8v081aZSzbwF2S7FWtlo0oaQT4uUVgBo26ua4WMPoIO8/YWzR7IERJj0Q54geBPwcAlQG +PcpzDg8UOT5qssxr4FCbtKDFl/bXECSlB4D63cOJremGMgWIMldGDziP9FgndGglCMH4uZCG37fh +lBZw6AA5ux8zLjvulveeFTHXGrx3SvFInjagqzh87KVJlaKyTgFuTxsPVRunEcCDrYMpmmvJMVkB +Xy1NP5o9sRBJ7ecBlRWv+8qjR1MVOWKFWUka7/Cz5sO0JgGzDi69QmuAMgLlharvDsrCi6wwHaK1 +iGkWwjjJk6Aq3MJ3Z78De0jsDszMIIogJu8tWi09iuV7qM908ET02lvMQi9m3eiFsxB0vnaOM07D +QgOKryNQQYPg4DTAi1R7iMTcT0ra6T0B9BF6qcxHL1GF7F/ZgkjG68PDgOmmA4RyOgwy9V4BHJnd +A5qKPc5ub4dUO5RlTwesagftFeFeECqZFz1xw4FbwkDQqGofji30Pg1ipyB4MSyrqmS266Vbe/Mt +3JvLxhry+g75HKpbCKgjolFZ4skR7hBEm573HoXfzwfUIc6L/EWvFs6pxBxAeCooIAZqviO+jDBm +zvu9Jn1R4Rb4XD41xA+gtFi++Ba6N4y2/QZXV0CdrdBoWFTzUPlNgQpP6LCzFUT6hJwulKp07xC9 +uM0AAlH8pZcYiSxZrMZxQFPQAyRJRZFthelQXl5LioJ/QuOPuI0eqKvsHnUdyA+9pCeRvYBiSi/h +kbCvZlxwo1alvVqOdjTdZGdN23vF8Zypj5tCB9Tz8tNuhZz7sqMjJ6BOgr6iOk9yknQBQJRqsppU +F3YEq3rnyFYTQLiZ/aJHD6vkzMp19F3fe6FBhjEuMH1SFTw8gXLo+Xc+UE9pIB7yIKlWFVZoDJ/9 +BjFaPnWIMVbCwXY/hEkN5e0oxlaMrCeM1PJgPV3fNXw1dG9jgku0x3tzSXhAVXc+AK/sMAZDxvyB +vIIvJBqjKMsiXxA99nJxjFgrdeIWa47oShYHNaiRInfUFKJjplql5rHlAMlTrRDaC/ohEas+nB37 +oh5fJ5mXGWit2ENFK/JJGJnUpk/bogdlU3tgYUQP4pBzN2cAh3avjOxNCdy8vVZmHodqGbNoiTSC +avWz2WOsbg8MD+ix94pxLXsTZW5r1kNFqDACZW2gKNViFdOKtSgKMRwfVCX2+ABYlGMxx/MMI3dc +yPY4CluyNGtVlP1zD8+0hFKyPabE/sVxmhI9e21+uNM7oGEnwDq6F7MUUUpeuhcapSQjndwOXsRe +tYiSmRSLjXZw5SPaQZmdHvxWcTQw54yYmDKImNAg+vXI6wbkQZRrlCL2ZS8dvVkPqAvs12+/+mSg +W0RqqDcRyEzXVNacGhYNewVe1LsbOQ0G4dyrC0KVvD1DPWRYrJNEALDd6Qg7i5Ft+z+07QWr2NZR +dN9hqgBkeywT3RjGVXuAKqJHBtRED+IMelTYmPSYqAWi5bNOIq+t4XCkFzkteykTu3utrOAyFnOd +M2WUVqIHJUF67JfLHvtdHEtcQo13RTfffS3pmnPuacF5HZJcpRLivILUpN6lhEx6ZyIyxSrCKgnT +HGwGtUegTw3DC8RnSbwz84SYFjP4Hi4Hf950jANId0AvhDxa8/G+oRDQkAvCCmc2FWtclTUBLkls +ze6heg0SVysbWdV696Bs85991r1KL7Xtc1TLy54GNCp4zpKZ4wcTj1Gtb1asByyXVeCXGLABiy4K +Gr0Or/7XJB7lylKIvGKUqwA/LzFSH4QasMXswYijx4587MFzWADXqIx7HsCFhSRruidqAur3rcwR +YGPwuCKqX2pxIwQA6oHkExFJ7hGA4QmSfO6/9or8eF6phmgDtbnFBfXgg6l9BC0BqZx/PL1aAg+F +itUxyxMyinKEW3KOw+gkCFf97DmKMLC0yPQgUf+U48NXgpt1Cy00Zp4ZsB6JdrDSSB0Q3QI6atoM +7CVKesY4HYIm9pCPb0jhj0P9CjPBeaWb9iwC/ndPCXvgaPDApmZYHNuzAQMcT9kVnomYwDza8pBw +I3/GdkJVHzNin3p4gqxrMGIJ2F/OL44jRagkthM59LlQVSQDXHhCpOMx15sqriXLdJZ2qVqTELnB +8KMge7bXOOh2dLTpRTGEDr7MD6ISBxvvYko0pF7B/CHMhVD9VANyL6uHNVkjByfTUhMOe1Xh/sQI +2a+zbdk9rit3Cs0+4kA03OlQodTy09JzSJNZWiVz4jlRd7549rqcLcWzaTJdU8MXFDFgM2vMg1IU +0NXr7LCR3GTNodpbQpPjFj0bHkZ5itcuQELIeQqkgGCIyWoD14ncvoTSFT6PygHt/Wg4Arz3wHF4 +ohInSuE888+92JsCqASyucwH82hyXYfIE8IdUzU+pDZbLH2lujgiPv7eI35T/QHmzyKhAazgi+Nw +aqYIKozZSzH+wlUcaNRbh4ys0k05fG7rqsN4n5/QyFNCtBFGJM5G5oypjxi9nrw9oQEZ+DnvYZFM +IU+AaBI+imiyInq6x3sxMijuS+kQx1Cb2OID6yhn8e5hYTPtUPBp53Wh0H5PQj2LffsefFEpYJnS +FVVIo5RYROQXxgBP9CChQQ+eW1NWl9zEDukwOPFMDZbcnn0B+saAfRyXCA/kPK53riKFaKTw5lGW +IbB9GJ7hlyyiGBid7gFvPYrOGjxI7Lzvmd56PaFeRk14ngeABAm3RqpmkSuV1VpHS80syA7b0BxG +qK2894hsCuUpFR0oRLcvjgOgymRPQdSSQb5Qy8TRvSAN9t5BFzAkXWHjnhrrF73QFYcxCQHFXL+C +rITk7Ie6byWi62hANLAbDXnYFq6bFS38RtyWT7YGbBdLtwucEpLpjoM9aIkbKJI6LeF/ozvy55FS +rUQPlSotsuA17NPpKLDHotlQOdy/YrG9rOwlmPsLqn9tIXi31xLqFoiesl4VDyP8zYReohqSI8fG +PpRqp7916FW7J5kjmU4vkhe7FxonIbrmytzwCyMTR5y8l4q1rJMWh5POiHsXAQ+mYcNCpoykkk6/ +iPD6m8veCN+Hg0vMXmPplXqJXmE3XHaEtzeC9NjR0X5H9peLo2Ccqa4s7e3poUc5DYBHG80Hh0wj +smp8vUjY1t9j+fUR9SGc0QuXQNRX7JFqtQfy29EDcQeOkZxte2j4kyGc9f+z9m671izpmdYVcA/r +EDgwGbuMyEMoIdSSEYgT6COrVW2klnC71RhL3D3xPG/k/GvNMe1FS9Ulu8v/+GbmGLmJ+Dbv5v0p +gJH2U4RifFx+ZySpMVrlXadq4i3eB0FoOPOyeoQAtXj6w4TorUaGFgcLJG+TguTMD0ddviVYfFKn +wUiJjZ9HW4QTW+xlYrTPuMBPwJV9vCPhrocQd01s6X8b6vvsZXLv9vpGEyHrZ0e8VicEFarSHbSE +bbq/whGAQbqfnmENjMcpteyTE8U1+Jq0JXfEnbJENcYW0n84gJd2DOdM95tnWWMDegRM6fHpy98o +dV/5mjuZU4SXtcIIdHD4jvNJhqiSC2aZr/TpUNjt4kugK9WPWIvGzr3ikTJEeZAT4XWsqMhkVubc +cMlLg7FyHyAqfd0u/ellETQ5hPvPmZUlVTPLh0uBqjonqI8R7Cr3Z4IwgIywNeH7UaNXC2eQHfJp +66UfNs07CVpK1xWVQ9SaZd7rYbAoJ8LBtRFPdlqWKAOowQmY95G9RcNDqu34dZ6rvA7rLQ7rc+av +9z3yryELuGONfIELkKm/g/92Q2yn41E0Rfp6pJxEoNPh1Fy3QPZvtFzxzYEFuW/TitpvNy/RE7Sn +tv8hQjnH+XUnfv8hPE/EUNt5ovaNpjMBPBnASgUOvVMlZCr4Sr8NzNF8NXYSJN7je4TnsTpCw2x/ +a1Bcn8e5tJjEsPbugllY8JAkoPfWVUzhl92w83lW+a4rbw+1xnPMgzjOPghYFER1bWRIkWp0QypU +035KxP1uYuFTsVbAKbTB0bn5SWQn2KevS+bYR4Q/CQt6GrYAjvk2H4cB4pd7v3TBqri3sbc1+qR1 +/hABsGkxpt+/Z8xfD9fvo/AaMp3eLz8iVqNBPmgo84KZDmSAIZQa04A7wL/dC2Dlgpr7/XNPg+73 +jbjzXnjsQn0/CLi9DgKoRVJQNQ9aHVgU8TU+AhAsQlQaHPt8/b0+ohgzTN+mK7xkhkP732Fqw3Xt +8uvRBmIMdkNT5Jeuz4j3UbspvvRS4J3/PA5GWjt5oN3l5ajQMKgt9vO1lP/c2R4Jxo2KN/m3hirs +qbwX6+X2PGcJWgAAi1GdhxVMMe+yEb7cNESobeuRyGYNpiQnwlElYjaAR4kAPUkEZilfZ3LkybRu +/3mieNh2Wl0Y3hBRIX/h1NKVNWxxENkRupMTYTqKhkw7vylJk3O89zdhC8azvzcApAVcT2gJ7vXE +zsdgFgN/8ubN9HEEQHFZd8/zsO1Ldd51E5LfB+Q8lCvthz8mL6PUpxbqSc8p6BlVMFz6KeKYGO3X +++XBfgYhg6XqM5YD/AqWXfmkUFuyMCcJ2e/d7a/Er2nRzGI5/va5J8FvwX0Svnr7OA== + + + BEMhdkhkMeudL9rdOY707g8RM7NDAEfzvSUfUY1Eg8zvugQ98WUfmSGPTavfaj+tG3k3e9keyEFX +rsd+XBvl6/eI99VMb7DdWsB9D6Jdu5foQrsWXIBfZfzwz9RU+72xpurtbXF+j0LD3pdhAhm/XUB8 ++HZORddVoFzkAIr65/uX3ljXrqVygC2ubxG5YkO+OJjupivXx3EazbTB4q0Pw8nExsnEuGLtSc0K +HuVeUdq5DsthKKB+C1a57iOgnmIfVehW/XNEmhBi/tLt8Z4p5lkMsDSHV8x39BB001Qd+NpkHnlm +RGHo4qKctZ/uikdBwofP8YY+YDEVeUJwyRGWEVAojHgNVIceGKySuswdeXZuCfqFuNeORvKOlE8v +Aa5LI0a9WVlvEqSuLBW0jkvk//eIbGLL8Q+ZzH6rfjzOc96mworW4ry9lLueWhx8RqxySK0qnbav +7PVbVD8KUa3rvUhWxfx3UbvCdKG9FRpuper2J+2NlZyvPf7oHaAcPt7npb77cn8zN/RjTxQZy8A9 +FTE7MGYgPXZEV+JPy/nmB5CB+L8facf73SyjfR03W0KlYhqSmNJ9q5P8IsfFxYMzK2a2ZtpDSKVw +df1uXoQKHbElgo4L6k7juJ6SpNsSuPmSJbf/kWlF/QiqbcSKjsrpSicQLeilPhWlzw8RyJ01lboZ +N7955kdUiVPMuEHopAJjREAmeouVvh0YWhIxYN0/BSey8vXB1wO8UzQe4Iqq9ddfNbUvcCi47Abz +tSyoIVKgT7h/gHCHhXuOx2VaZZu1oiAaJNv+U8U5F4kBcygd2+mt4B6KVSz76iUHnpNxqUF/22sd +N7pse1mb+ZJM8Vq7PyP+/I7UmGlOGHrz+Yyivc48ehdYe3+5s6g496Krrpb4R8QPe+NnENg+GhiM +F3jcO8a0zNx3Wo0l+N4I9K3qKPwv+Jkdxja26Pux0S4V5RIUgdvIyNHuCZCQTBTQ7QDxDWJ0l0eg +/Gm1dsVk6CUUpv/K2uI0zngGn5nfOhqw9AUXVasZsmQboGTX3g5Pl4bJxV5V9k9QtoSkAoBTd1aM +xgTm6rN/ffDPNpGurOFsijdD7fevdGdCbmRfWWtPKInURLg+0cijjwVehdKsiN0Fc/X2jPiQTYwP +1Xf1Q9WdY1+WCBplRFD+tndRB/3e3oieCBuvRlyaXlh1vmeidCdqZwvsxjXup51d/slxWsATo3G5 +jPCJ2e9a1+AbmbthS24/5cUIzVc6Rg71be3tdQGuObNGEHBE7Q/Rnq4KKBBx2+yEjcPVBP2LpzlO +utxiSFOcUUeC9eJEm6N63EXvGA085HrAfxtTWpRVPerAZGP5gORBXLvcZOZ1nSkbbRaocBUG2ZSG +jbb5r+79oqHJh02xZ2Xv+HcyIrr6cPATAL212W4qRrhK0Pe3Idkw5pnh3gBPfo9vnwHlMmx8iVIv +DZpwBvwu2CqbkQ7orFr9PB7Cl7TFnKe+6s0QvNuT/D3ngRczljZ2S+7GOGU00o3cT6qfm92uI9Q5 +fXXZpB50VPW9BwjtdKbtt585GQssf9FgWJZzYy7ljOhKYyXlq6uAYqMZyqtLaWNrsNmIqMj20RED +yFC0LP8esGKEAaDgpSR9BMF93A8eVkFgVnh6guTE83kAjbgz5qjIwvIAtJWcdR8iRZgCOUxq7xiY ++HtaP6M/3OpWUCOeaGf/lYFD13GNsvBRYUqIjKsiuwFt1F00ZYdCXbsLorkPcJMGyikKiHKEuKM6 +3XmiBGhBg2KSQQREdSIKO4gRgg73zjftgjMLZ92ieAFUwJkEoPL2zf51puE4VsWPcr5P8c+tbTBH +Ib/ZF1OHef+CxzBipMMPxGPvJQ4s+znuVKmFK/pQGoFXkRNfX+F4SIoeH+oznX4mvnS16mhsWDtC +0jY1dqMfacSjcSeqCqf7RBSo0nxIoU3/2RM8aYPCae88F8y69wUigrLytz6uQGN2RGE47VcA4VGZ +UZ7XkqCdGBvEo0BQnh6UKcqTE2ElzImA5BMBJsOvRuNrfzDsL/JBEcJKbre+boGJ4mJlfPgluqHs +K92Eb+1cLNWrbaL5Fx9gmsBPbntjmy+y9v1QphLYToQlS+4oMCSuOEwQBfAHnJeG3+3FwKNkMvP9 +g7TkLzGMn391P3oWoW1C0YCJBF4477/z/5HsYTc+j6LM+9mc6Q5VNwba+jQCWUyrhEp/u75EoCgw +xehIO1La4Qaphvz3iNw0+qt7R9r/U/QJ+jzOJWLD26q4/lxBwsAIY2r6GYBiDuJtF83i/uvp+F3U +vWLj08Sk7MPcSfCXLhSAom7Tdq9n8GdTV0PuZpbQQi9+/rrq+2IQxRZJkHMZ9FlRASJAZNAOKOgC +EwAiDi3V4cfdmw5Ua53P2UQ4wFj311mSxoBqZGueWtYb9YhWJ4JyeunM1IzARIlvW4UoEUHrb0ew +ye8IEGqI+ysH277OZOMOiEkTM3+f9gD8GEZIOOOQTKBmj+pNvaslPzqmF082j2nGUNTO7TMgy8L3 +tO3jMKQBqKOAJgEAwVdhePOgvae9wkeEj0DPI1De9/cjaiVltekzxvm+83zfnX/gXUR2vjenwniA +mdjOHslgH9yoPyP+fIBwjl0mRH/m8B/HARYFiG9CtCdCjr+P1K0FPYgjRyITUCZSyJgUASPktj4H +4AlwabgOTJk3AqKmLR3GhvP0w0dPP7z/FDEDNHuQP5qHFf8ZxYR8XyAsoxkgBP0fnD3VFBNYy5l9 +shUqBAkhCH/cFPq7QktRvBnkqsZnFKK6FTYbufZQttVRL05XiRA3ihJAb4ko3FM1o5oRLmda0bVf +Z8puiZJXS9RDKllb7EeNYIVd+NUAGsSHsMh+SPXkmaiq+S6UaEasSA5fryXBvuyBZqwWMZaGTiJ0 +jp1dFYuamYb+QhuzdpFheuBVWOROlb9HVFmCQJz3Uvj+pI+oXiKBlcRmueIyyAf2+wQIv287byod +DvI7us5c5o+IP5+sCY9dK6G9RP5wnOosie1P4X+BymqQFa0r5w8RO704nc0fPivB4GL4I2QLYSYA +qE+5WGVE2h+sN2/zbyQrk3nKsr3fPwK+FhQYKwtCBhyE70eBpwaec8mbb/mSNNH2SktBKgZtxCKw +a8uUa91zrds7ZYcMN/Va7dTNBE0Q0dj6WtgRQKeWADk4mhoXI7wRnsjERipBM4LUlQh5zO+JsmKf +qRtwUbuHJUgmj8NaQwRpf3DqIzh1+pkETNYTUZxPEKcXM1wO0Q9Muo93a1DTeQddMSsVUkU2Cz+i +AZHY5Tk0UhC80JsoXfeu1n+IQKvUq0IX98gVf0YVcBID1e5SRUn3lloADjAjDrg+tDb3e1UBM4oe +EQ0AeuSGLfE9Ik9dd4nZ7yOqPu2H48BcYIq8nykUcUXhM/bvRbstOrT7KrKICEC7eHPpmZ1qmTmA +8Ly9XqHwDX0l1INdwzMy6eUFfB95TjgA4lOKqFuxQ/ZXkK++AdnypU9Pir/mlheGhWDuH5VeAjii +U6bg7ZwWBLbJgcLADUZYnD7VfsYxjPsICPSpu3yBCnyKC+Xvg9pzlM0usIclCFopEKRN/JjPgDuw +77qzqVdn5TOqyv6uUmQe3ZuC7Ie2sl/fGuYTYGLuCv1efhCSHPygfecSUb4wdfS+4FjxwKzzodwZ +Rog11yNPAqJ6hxMlFnhHICZhQPoDPAcjBKKQu6iZ1teJpk8FPHu/Zw9NDWxGEV5/KVwokc3SEdEF +uhTIoAjv0f+9iWIs2MgbQauizGj2v8hTpLPE49QaQtNVvWZ0wAMNzY9+gOYur6pQ//2zboS0f4ig +Vdq+sKe//7BEaqMJ+Yaw91wTxT7uaaNG2fd0tivwxkQs3SM/I3KtIgMJyWjvJj8e5z6kv1nVhOb7 +iagqyplXyYOH3jnEZgPF9L4uvvrLHRwH7qZm2viM+tvzdeBm7Kh1yHVnFFxmsL22jqqsqF2L8zJj +asIkp+wXFr2qHyJaMEh7y4Ru8KsF9bso1JnV7y7hLAAck+zRWkDCO6eVVnmxE1A7Ihg+UM+YyFb/ +EPHWZxDxaJkytf3hOOuwR/ca1YabEL0mVINAuNJB+Ij4vjEnq/0ehTiKzIalHgnJYbelzZDDJatL +HJBJAMUQpFcqhr0uCuC8HhlGyWVboCWToUWfrrYi0sijaP6AWWgIIk5ABvCQaLRJVWjpBjHnvbRZ +vULYsEJv8EDvnX4c4UpAI6aQk54+FQcypg+kIiymQQRcQKMB3pdHqbYKdRQobCX13yvzvz1TbYTZ +F4pxg34i8zTYj0xzwawMyF7k9UAuoQxTCYQMtB8YSo6xky565d//PWOUnoaGJgfAiT7++pimkU+T +rpjN6yeJEid/8hnBzqtn3T78od5/BmlbsL+/GrPkyN6ZITAWwQ2+GlDkpW+DwIErWyOWWe2MBIbG +qwATdWe+A3ReUgrBgO7jNyt1/f64DNfKYAGdFwCXf4z4e7GB0v4/ye8FMvrvWOeqz/JWQWdkSXIK +P1gDcN4Zh8t0QEGoIRY5nzNORTT5LaQ4Dh1+ZiJ0bYiQ+IQc7T3y4klRYNgGJNwIeqI7or3lwzMP +yoXMDiK3QHKx/wsoA+Mk4NfYkoN1s76g3HhQd/e1KIdhjjAWzypSzprK4t95v0gPWOaVZ9XhmVEu +bLt23Hv/8DBCk+norzsREECtWpGHJKKS6cCzn+dMCHamrr1+nak9znQQkTxR4RbCy81xsMYhovlU +aWx++8FgbMwHQk6fHk7T/im0fM4JEJlCvWWXQ1NmO6/FfujQLCd3HECRg3+QQWnJBaQYC3qMtkWX +hY3JjtrcJvpxDwQUs/cM8RX7708aQNVN+nI/QMbgHe2HiN47coR7+fkb2lHKCIB6HaijQBphb+sS +GZX7gLSG4uQZN+KLwS5xo2zCJoqSN6PvdaBG+x/zryLJ9ldEJo5BbmACdKssPNBSJuOk3/S+1JiU +sXrfrE6WFkPEsH9OV4c/99ujKw6KAV8Gih4kVenD8sH+xXxpdFp/jZGlgPMhA44igClfy84TkH7W +hESwu1adVYwQrUeuW8eJAFLMCd4ES/htqrNp+671YwVYACWh8QTKgT7NjQpZCeEPONUgUjxTBa1P +CTtDw92v1HxLdsblsF8Zl3PevWemTgMgONcVdIJjLNsU8q6fVOQXzQIeIDQehT1d+8qwW+Go/IIS +kIsCckBPlwZxA/DNMO/ab7Hj74kFLN00xBaLLGcH2bKiKItwBuUBvYujdB6S+eZtO/0PRQohW5x7 ++ZmVZR+5OrwCvdKw5u54LUls378XatT+j7CIlSIYBQHZmkxsQi3vL2yr6xLdJUPRAyQGkzgVIy4R +r+tADZm1zwTQQ94BU1hUh3R1iQTZL9/KadDNdjj0vtLgRUTuMpekfgVB8Hh5dj3bciKKKSKkZirV +NTkRXaYTAHyLQ9DtJiK0JhkJ6+tEj09gaU7ZuS5Z1y8daoEi2zgir6FZAHPYX7STtQ== + + + jkQwd97sYd95h5KoCoRSyVDuBW0rIG7ndr9avKOajCOpWvRfHGjAIaqLIu/SerWHXrx/r0C6AQAf +e/odaibcVBna3/VatKhOkjCv7Gf0K8BZNQ2ai8IO6Ix6Jm4aZ2LT/A0dDBXX94VtwvAGG1NHThlt +uX0MzKSAT1yOW37h0G3U3m8Dat2xc7sEzpDMrDCP95WSJ64X3m2SIyviRmhKKvVCZgz9iv3AlrPu +IqfMoHwvfWWphYHlJvM5pjggxvQhBJ8MN4KVeU408PZxOujd5aifKBnSyo3eBtFZJ4hWh8v3IxwM +ee37RMBVIqKyF+LGDs/jFjJUciJ/6o4fr9o7LCGSk9sNc52vgzZD92d4nKBOwJdSozNHoal/0aDi +0hPB7eZJZWEhwuHfjqDHf4AvJWPP23ErUdd5ixgy8n60KzowNHwvH3h6FB5fciIiCKNnRSSpfBDr +OZaA+7n5GzAjUEO4c+44BbgWIB46FoOBNWXGrtHutN3EYrNC0xol1+kzLtxFCjYK6iAJCxTzg3VK +RtRPRmRMmlTs0ydjcl8lp6L55VEUS6ADsFKq/OvZ25sP/jXc5MN+D3i1mK4UNK+wXi6g0IVvrMM6 +KfgRg3lnDIsKEXWhD//hHvHwMU+V0AX+QCtcaRphTwBdLi84k16iMNBG76PmQxpkyHyYr9EphCF8 +I3FegqAupqf7aZzC+UvQEgi1dL2g0V2z0bUsKd8zZTfct7eJST7zyI46wjxnCjgS6/lmhDzZLsU0 +ZxJxwQeAmLo2QefZvVGaBrSFe8AhO8lZAF7XQypQqgjemeB6GjNTrHLhFNZ17Drid2mg8EukuvSC +a+CbuF0ZpGOAtyRf8YA1aFUIvpYk08JJeL6esKeWHEiyWLYRuClKFFRyu+eTmhXobD9KAWT6PUHs +v/wkjO54Xx4F/QUL5Efz5hJRXRqIAAsFLgRJOZ3p5c7QhD/a4UStmRPopEcVKxBP4V1+CbVmM0AQ +9g7ooHk9PoNVvgFZNxF6RnUaLS+ijoLLtvEuy688guDluK6NDtOQFOiVT96697IoDfWLBKn99sev +x5/+iq8knSnwL3SmcHC3Mn/YUqnE6Cj9w4mi409Uw3KAKGnglXk49HyFCYbHudGY9DiAhncEGjJG +gPYgwpXSyTSIQXUC+kvffk5LiTxjZX7NxJco2hI5DnhAjiMlkDWMlINEFUBEe2UU+C4obK1jPcaC +/GIfbZSJndk3lESKpoXgqIqa8aFZO2pG6BNgCSAGh3NUPzxqKgOsgFRMAICytFfnqx5IV6sMJq1p +IimFE9OThrPtDtBtF2svqRF5Ceehhbc36WHjB7plkta9cb/iRtDsBjnw3lhvEhWi6PRd6n0Nj0MO +TsQD7pCIqCaJIr+NYB8kQhdGInxdrkPd+DrTLuCMou1AFOWnj3EfOdP5nuTAjw2akl+yMwe64Rjo +9kSgAk36vcovnvVF2vLgBUSGcR+c2oWopJMDGvpdLWWKLI/DXNNarzEVxEDpySROHwsyv3eAxUpg +x7NC8mCaE8DZzs7qdR8cX3rQJO/TKQzFQWcaU3ysVaJSdejcRM0ZzzjpSoEL0BIUIC1MPQkBRiDj +318aHFRE5npNRBVSLrgyIMmqQjtF+iRvL6YMruqs4PN5z7Sv521PkC5gBmCTgXYJLi/gIoW6aQsh +EYXpzRXJQeZFwTfRJ1iiBE8dW1QfQlvpC8WE5B4xuIxYEdI1pPZkruelSaMU88vnREC7wd2O+Qnz +TzIIq+nlB7+MghyOPqr0kTeemhsTTsbhwBl7VO6BPLfCCpx6e6gAd9OqMoLHhXr7Unzm/sIDowAl +ZvBCtHCmNGZdozSGI2yEgnlSdbo/AKSA5+XF5bzz/LCi3ufOoV5MJDpVjHco+wBGMDPT1l4rOmC7 +SLsplHU5VHHoKHxsQiCq/qmeXmbnL6qGVo7lh92SSEPRaUEaChsrYTVCJlAR4El6ArkaND5BztlU +Wzad3wSOw0oPXNzSjDWEYZZ9FBTXeECVhgG0TOuVyYXkALRRdtkj9CrTL1J2R8VXTI/pwdd3hNuu +l6PebMBg7EMaxPUAfMSrSBP+0Z+nqmlEjgaWdTqyY/J9JSXuaRLtyuJ6MbvADJENAOnml6ivJNJO +VAAX1XnUH0lrnTmdPM9RgUDEswPv//tuaunM5I/7p979i46/kzaQFU+JVhRjTnMfBFjw8eC7BH27 +n/c5A4pU8o3WudrEsKDIKB9tWtnLHhMzq7LrpeNDNZO0f8TJ2IhkbgghZQRcTznpzaADqB+h1bks +An4S7b+lhBMJJW5eTn/hko+vW+MsGmUvgB7qcrLPtets3dxGYHg4e9ndg8/BpM/s0H9/WyZdhsDF +VYRwGZXPejQI7OPyBOxLlQ+gFgOjnyURiMYSwfaf4+J6Rgr/vHyn+oKXm75y/mjE2J6qneBQnET2 +zqNnclEF083hD3Oav2ZRQ21PhstyEXHm5zTlURa6d8ZiBoW92UAsoVcdODQNw0sJQoV96KmAPA8/ +2n5FYj91OAo8ijFxW8BQMgup6jYc10uYyteX1uSOwqgNvy2klYgKPwFnQBIR7rtalh0ZEMh55fCu +6cixFk99i4jYjyR3qJwOB2CS+uqJzEf0EVEBJEobtF7bD9+VM5FUE8GTmO/Cq7i/8RV5zsemqhFC +xMyPl0IS/TqrSsPSye6Vg7jqXOMeqIqTAzARXhyYsfvOT7oe7bcA+kYhDQKT3j5aPqrpNAcedDPO +4BaRuV3w0nm5lVyVTsYPDnheUR/6WNDOST0jOK5YEC1mHzb9AfcH8ArQF5kU479Ej9T82lHWgESp +3Ciw5o54kgoVD7Om60TQD7azwUpPxJGTWPTRjeCWEdG/9I8Qeb2MokucKN5mos5hVgzpanemdx1e +CV+4MFchIhJKFR+ERNAW2hG11JcVUCLy9YQlpAxBira9q1G4kGLbXtqvBXtAdA5oYqBz0JCzh/0D +s4uRBqkSIgVfiElQRDJtdDMfMQsg+cIsAEmgMbHxcK4DAE6lhQKKedeTEcgmTQR/X36x9vrdj3ZJ +BZVwh+XTqc87qcFvINCW+hlo5ziLew7zdF8DXLu6nfmh2MwEl4ASHcalrufjTmcVcEl4JSQATThZ +CL3tsD/aoNh1R2d0zF7Mes9UD1UepnqIgX4Be4U47Ih69Lky2luOPAKwH7gq0GtQYGwFt15LcOKS +JOwq8SS/ZdAIkxhuhAJIs7tlNDwqD/3YF2m/AEw5IEY+tzPNY3dOJ/Klpws6oTnxPLH5qeRHPOdN +Mum+uuqKiRlAMJABKl1J+NAK53bhPZKH9auHHwS+jCLJgX/7Cx1lhaf4HwDTNNfBVOqlQUcGvdPM +Xnmu2RDaY4pQj7xXY6Rwy+DqCrFEJfY9fHZLcBYlnB1k8mD2aPzK7g4JCGWWm/PTDAL05qlBRAJ3 +ok+M12paH89LVOKlORQOslAgetzMtj6CuBqPxcvoYl1DyL9LCPlvhAXxfjLIT33gWI1w01r1PRE9 +SeakrJstrYlsQDx7clKasmr2gnBcpheEKjTfMe8x7Y+er2B9BsDrftk1+6l1MvGMUt6ekmMmv7dX +TJMjOLwgBbu8LHW61I02UWJEQKfPwomMjk5cDv/qI/FWeEPuI49wxU2RL+DUHTmWBmC/AWyHMvRM +n2l+ISMZniw2vNCEJN7RvjujXfIKgeUYJGNzRpS7lgMWysLrkPjR+1QOqK1I3jQYJ5zpug8DaFqY +2eb5BWbpRyF9OkcICmBMFxj477+hod4oInjT+ooeQXqI+wZfUCRQdmJx3JdsmkTVkslchyPU3qd4 +pKqUWqLk13MEoUAMkHe3o/UJdApHAnqFivvgZecLSyHKQsDQQcED2jf1V+kbc5tjZc0AT2BjOyRI +5fHoplqf0MVitg2OBoQDiftzSld4FJ3p6F6j6hdKhn3cl2hWSTeg2SvWF+zn1enLNNt7VCi7At62 +48/5C2DT1Y78NgLbsLGKPOLs/JEZI3HQ7YL3PEpWELbpN5HfNRa+FtSY2nVKULV2OwJY5wpxT4Cl +Ayl5fbv9kIqPHoyEDOF89HQHxJCWP1ckvUSfnojIXAyxuUYoaH7B7ayJiDzFXonGGZERJekJn8oj +/pUVa/ACFK8UKBwCHnH0RCiFhqGjcypUrDoGRhfuXTnRlS+73toddXhR8jyUZjpow9AdwQSR6oJR +zAwnFH6rKubVrk+MqFEck2VhSXq/GtrFdrPdo+foAUnzkzlHKa1cmGro+3E/kntT/8t9/US7MZtD +Du6C4HZFCU+qAApkXxKUd6asjMtuTDDJD/BpIHO9MsHaaSgJ815JSjKIGpQIG5MKrPCA1c5nYl2D +xenm2Tu3bu9+SBSKzBei5D3ShJoh7CiLLSIqkH1kQqEAVDmIbAAI19K1m/U00Xj9VcoYJ2EZSG9+ +nUjP8gvpbJZHhVyaX4eOLQEM2B/5rE8Cogk1gNG+EbUb4UOGXbXif+Kg/+I8vC8AkK8jY6NLgCtd +dzYPrg2kIwOw8KwhzHB1ZNpB7UExlyeRsYkmQaqU4Lt79hPmt5EGVzd3mdIDomp6pylyB7cw90Zi +1s7DfYeZICOqgC69vrQ1BqY8b4yVn3OCYUNamNU4YCx1QPddfUTDqwm3P71Y591zykm6yqBX73AR +tDY+CeAEHBvshMGxQTuiwbEGYLaOqIL73vFZVoWIuet+IFNDYlQnU7el29BWBoZNdhMP9o0AXRij +DQH5vZ6OdgihDl5Bu8NDi1DUDKcZVt998KEH2LmfUTygYOSzb6RVVuzEZF3eV6bYJ7jTTNiVswT8 +JOcnPeThZEsECABFlLEceGTZXmB9efGtBkY/LLx96dBvYp3GNPOh8keYIdlzGkaAZrqDGB8n+u8K +4qWPRoHLIzkLBS7vGFO4hqbDldak07M5gmNqNrTPCUh7EF8TOSRB7tWCR4pSp48eThjVIJ17tM1Z +G+DoaJn0z6cBKKUH8Gvc1Y7K3s7O6ZiyNdofspQ6HhoRdQdzyc7aT320//7C/7YJfYenue8Qvh5+ +4R+j2AF3FLTtc5w7EShwJILOsyo+9URIWNlfU9wwEfSqiLieX2fSMx6Z5TuyzWgLGKXIcD8wLCAf +6oES0RStZNSf73LIIlU5eQLufFl25K8T0bZnTDaFAyCmuXIYoeXQrluQa6DwDHDlr2DUVDWemRMt +bUpqFKRFOF/OOc/T1HRgoWgaSvsi40SixkaKsYc0QfvlDaH2EVDhI4S5qtUwnuimydsYclvUhCgU +w28aRJCE3Z0AVlZ1iDWSNCCqWOQdpQCUBaYjhhm9hPHoJbAcEvJDtGecX8c1y6ODahebvrwAr84F +TLEq3psHJC4LMyAPFE2KVLInGVRwHucETgS6+8xXVWzGuUhEZgwfVMhlhSbfJkKowIIkWMsnJJxq +e1mPgzJunx4W3hJ2aDnA1Cqvn0YJmzbrA1sdV7qcgm7G3nzxpS+9UaYGQsF7xgiEgQ== + + + Fk+tKGep9vjjggOCexeOHdnpjHsDsGem0qh1/jbgqpMlz6Y3wn7hAS0xz7uxu2wH5Xzbflt2XpdM +eXcL7J7b/QNsFAIq/LfbRj3KeQ9F6f3gRhLTHpU9GUFfryoWbwJl/v3m44jxs85XPHKr+mACTwnQ +K2KN0+tFD+49EWv/OqlGBZB1LCL40AE4HzIAp6FBM5EPLGcRFxn9RPjPKivcVPSnxwp/v4KmeIE7 +2GzAW+ONIMnBuhH1/arlbc3wXHl6mIBcvHUgoHsZKUUAaY2kFNtS6Lwrasq4sr+ZJ1Hq0hCl9CW6 +NCTC2O+iNkKEALq9JO+0bBmR+fHe8ZCvQ0qKF2bCE24ngJqYgJccSNQVjf6iH49RUIxqNs48NOIN +GnzMmq9C+2tHXKjoGkF/mohsxjzQ5z7IWME4fi/pS647S0jRhmC570D1R45FQwEexj41PEDqRlEd +ZDR4UxFmP7syWyFagetK+gGiH7YLjbxLhQsGvOg3omMWI5EngL2a6jqsx9CQa0SzsJd25rIfuZ3C +fBHOQlDtRzFvXW+bv+hww5lCGW27uJCHTBKG/QbteiDfmiqh/nvZn7ohjBcJ0Sgenl/0BNLLcAOp +9Hr3o2HCNeIXrZHp8Zw66ZAwKDa41yckR3CQGCgM7eviXL8i1Q8Yq5X9vV4xhRXcExykboN2Ht3d +Cl2PdWSNw3LgMTmwAmfBVZV/vgm4I8YNx46vMtq931tzhy+vc/PIi70zFF4Sipup/JCTk4XGDBAl +WvmqDSp0orAQ2zpr7HXURL92iv2ZXV1IibahZ8993dvmUg3GiH4irtD6Zc01JWd+OrqyAIjLrLcL +Mw/2cQfVfq1DDL8PMZzsabLqVCO0ajIiWViUS4iIxuiT9dcIBl4NoPMpzHk4lOfBDMT+2ryj0gUi +gPlVv1NZg8G8TKvXdRIsiWHuKH6VtQsF4e+LFhWGF9Nl8ZzoqPEuEKkUp5hTiOTfv35e58qwxWLK +oTtPO4cZIm55IW+R/qLoHlkyV3H/6AjAnJ2qhX0yuQl3VkneZyU9Bfw0BVT8pSGZX+A5oLfTUuYt +UQs8lP7rpX6yWYFRmBC1eLBsbyx7IjgVu3MLRYElrQ6QJGL6cBeU6qpex8m6B3rmsuMZVT24GyK7 +8mZTmHTYgnYz6CMYBY3r7jCmlYpemmcdHR6z9wdtiOzyAqlX0WPANp7KN/1S7fDXrr40zUM8M83V +aOsXcansOEvqEtmcmo0z5KaGvr5qiMubhPLG/rD52nc7KDgSvdstUUAFZzu1iCtNBHVZjvlAuDLD +WZwC+KApitFeZhCv6Pg6XJgYgDZbTmquDhYQ5XS5UozzpgTfOxHKUiAGDUKMiPOVzC+ai/Ur/AlH +TIoUCTkiIyOCaoqhcALYslNja4QzmprEFte7KtbXXraFyMo7gn11vMUmRIW/AEwmXWFDpi2MMiDN +ouaRj+o3a/eNI8t9ZMwgpjTkIwm4w6tgScesXIkQquO2S6D20h8gB6sufu/lMFv6XmJVaYAg9hvo +fDok+zB7aRZ8to8rjnJmCwaz35yvr4DywePNL6HBGtuD+9U3exhdO4W/IYBILrE1DrRYT286aVSU +tHBVmxzhE++MZSFMLfxNz0aS0kP2RhJvDoHKCCoWC1Mz7J2KwAsKrFOmCOOlOxogi4IFg6sxIq4I +7BZxxeHwHJ9Rbh5r3MGeqMAomq1wBxNlK7yRCpcorke2ErDZOnoYDJrRw6jROpcMuQP2O9YTQM+x +YfbX/oJGoHZyYTmqRu0Xlkdt6opmBFs4ESiHEGEfvOFVisQ2Z3pCRbg1lpmAZsldRLq/FJIRDMJe +JZZKVZYJlUcFXtKIJKgCvA2U0uMamPcDuVVUzwXYqUq6X0hbxT05bgN1P1+Q+UtIWM6UzBcU7YRW +AI1MCWSVKaFqtLRIRNczkmqKAR8iMcv1lEj4zaHz60z+pn0mtHd1+rxNtXbeJu+p6ZpFm2zJKmGo +B20FoK0ayzdE+SJJTYl3Jp+g2P90HrhwOPZvRH9UrrlmTPulF2ZuJ4TjdJTIIrqlFGeterPKmKLT +BYk/Erl0Vn8RCCB7IvOKB1aiCilLJVGJ1rfbOC0w2bJUX9HiYOaCSO+w94WYbNEprNa0SaDKXl83 +ZUbr8OahHQGqBw0moeHx5rqXs0GJ/IFTWyLoTGtZrdW8fkdaskk6ABa2j/pqTCAHHkn2ijh+CWje +afGkluUlHUc8Hzvuw6z3lWlBlaKGX1fqU9MA1BPrm9eriF+jiC9jqqx4WRZxHpHEt468VRuNFaSr +zY6QtUnE+QYAY08EnVkirtcGgBYhg1Q0QIToERVNfjm7N0BOrhTfk5cN2AytYCNW/oCigg/ou3wt +l5TjdEpY58FNTUl6ourVJGPZaVFdENen4nBoZLgWK8q71BOoDkayOk75XPyb5IyCtDH6nkyKQF7z +mARYFuAaLBe7sOX1ISWxe5VL+/GC2JlA2j8o798S4VnLfRxQjeDRr7etKqaKvH3XFC3BD8o+CCUZ +DhTjQZpDOwIg+uEUlnjt3h5mJooVjqidRvztfxUGXM0B8ODhI4D1Ln6RiI1IWv6YmcyOEEWnF4TM +ONIv3x8dCvb7Awbs0IlnSv7BsAJYLTkI4HckcRqs5F2smDOsqNCr7+dNmwcAQdXE3WyClM6zeg/t +LEkYlXins73GeQUuyBIKbmUi67rPK0t1wQJlb/G+2eCTUlouIT55f4nJr1gNUjyqntwZLSsvuS95 +C0k21e6FJ8NtSmljkoHb0rfgOeWb8NT+s3CTVHaqhUmpTarRfFp/Q9FJ0tf+7WD7nZPaY+0t8xaq +ttBf9wPp4AREJzS/XZejD27qS1LCFYGxaOOB2dd1OfvihZCLr+cRIrUaAECFcHwSUPi/PdWsdETn +mWyX5Tl8Cf31qoQcZxFMgDNWAbZI+fbkdZ8Cwh7BLgdmVu8XNIcvhBn6fvwuPclm1FPHMH3osuaK +hMi+1AleQdUNiI6UAlw4JS/tnyE13cLDHvsLXq86iDa5bIjw8rvnceZK5a2e3XW2fW42FDCkjwWY +7JW8k5dqWvWo+4GGdnxSjt/ePs/hoIAgt3P0PDZedhTeREQVnEbPcJRWGal9jlMyHoM8KE/8DxF6 +f0084H/7L9jX/xcf6A9M6POf4n9+soOX3FcfNZynLmg0WMFj7LtyXSW+iJL7XKFuHHs+g6TuuTzf +SigZQdfBD9z70VemFXA/pyICb3squaFvVrHGmD23SGMG1gbFgOJtnbXB7Ki5zXeNLCSM6DF6RvPy +OIA0lC9DDKaUGPNhJCamYz8gEYonS50eR4Gxic4Yg0SgPHcEg0fakyMGER6j5RiZGhfWof51JkcO +O6rcz5Em1rAChDDUNMBUen/iY9SeA3ApnKmDzDVCPbZJilajfRzDHByM3j24HLfHOwJGYC/MpCLW +vSsbYZtq4FtbU98tc6QQ7cmQ2A4skEiRZ7uPaDApoRXkjdF5Da4jqIULOa/4LCmvREfdCdl3oypU +JFQmgf5pTs9GT82WEfQ50xh6Ku+l5gZeEBsxvdkGXYOq+rmPKLBK7Wb2xuZTsh+InaaGazvc+iZc +jaHrQUxCUHE5QoRyf8n8BzlcP1HUQVQR8sJ3vQzN1A90S5lZG4hQQmVH3ECDiRj6nUwWvPvrBBHe +gIBw5wT5KQjror9PhOg8xUtW7BnE0Uz6Bj3fRTDlPJod+2L3V+H9Zle6mfZe5qogElzmOgU1mfp9 +VBr2Xn/wBnuHcAfCs4mdEvVfue49TLKPCM+0qqdfyOGX54fD2AklDS+IRgYkQlYENgOqymfAfoQL +OJMb6sJ7mm9BdEbY+TtlAfnZ6s5pcC+IuSLFC5MAxdHhVdWI3b8feNgJQGXvToPZMmvC+1eIriug +0g8aFcsre1z7PqFYyZ8KGBzHmFczqdfJiQ+R4gBkp5MT4L0gbLhaNX9OeTGwDbpjaRLQFhAtFsQ5 +U7QNoGsrEYEaDwgHv36B3T7UYub5GgMZvB0FQn0f584ofUcADk9Elc8E3r8YYSt3CDPIiWBBcKJ3 +ojdo79K6HdiC6fFVD4bspl/EYU5HciBkeiwHwTR/fsDj7opJw/qVQPmMqkddHtQXhQzylncxeadJ +6BYvMWrgyEC3Csq7+qykgLOciHYiDitmHOLdx4c31t8U3ft7qUkGxtWhW7ezMX6I+Olp/YyqIAU1 +1hmkfb8NTF3xYxnsPDNgEaQoeFzZXnmfpv0rCBCv9InOEtwoRC1WACRZSkvXs+VJ5wZMBP0326F2 +v9ip7oM1MGqSSe/XWu4pdf1RlrgLuykRqOsQMejp0dNCFoFmF4ieodfck97v+zbxIfKAdCz7iIOW +lr57vYbw5p+zm8MCuO441gRaypKxbwkB1zquOvJlGfC8uhoriHAGE3vdHO41gdVfsjl9ZyT0SDNu +EdBveh2CGaDsnkd/d0Td4zMiXcTQ9T//nDPawoIkRNe9r9Mdn6xMPV4XS22CC7nS5DGUT+Qx9VVp +IUqNGCYmd6KYPBBFy8TjiAEQQrZOKqVKfdEJ4rc/zsj+1Ty0yZp5/svI9iIg7MizXuh0Ow8aa4h8 +jTyTVLSuBwf4PcuPFC/3M+koRlVY5Adw25ZsXU7hxfzolBaKWcuqju3xYSHSUn/nhiXmQjSFyb00 +dbk1TcGf7Q64XgprKLsxhjGf3y/ZpWhmOdLOZBY9Z9LJg+bferGvoxz8DYLad+xjxpU/VyJKA9Ey +8oF2lCSQemkXkZSCkAaWI84QhxGQjQ729VbVjWRu6BKDCz2jZpwrCsrQQM/BcC20Fe74CwX4Be2x +Rkk2puOTqv14IGqVNmBP/3JstdPOmwSXUAyplmsYyaxInMfpAwkDXlRK73i6kgx0pV6XDL/9fXBe +0GqVOm//rbDTl3NhPU4hr+oCbn4MS3X0eCIZ6w7McdydyP1ilcaVToTyBiB75U0jooiGBtkhpMac +KT0tWahKxFdn+7EkIDdSg/s+f75U48M4NRFILNPCB+mWiOB+FAM/t+eYklIML1OqpT83j7K1PG0J +BiK8Ekstgf5MqKx//NL86a/4okpIURy36lEnQCeik32SAPmG3gzySWRAcxyEEVkyQX2KZOr6kRuB +AU+QSi1IJVV4geeqyL5TP8mr7cU6MVfsv5BAutaC8xELS2N1iXiiQTw9jmox7dVwkxYWEfuAshAe +7+dPgdQAg/piIgBlFCKGosoTZrxm4GjDAIfsDHIvESVBKKUdDNToPndov2qyXXeQLLePiNRRT+am +d3itn1FUQ11JD270DJdYinwB4GZLM2IbjZ7RI5QZGxuKVtTWzubwROTi5k0GoncfACpTv1nih+Za +cR/NeyLc5y+F+HKmaPogIjSjTqQMKhHlbfriQWG5DnMyhznyNK3TYXNMQtF1g+Y6EQDlicDELBE0 +bW99DHIiID7PoXj8mpo5qqrYtUJjfsWJoJejNdjpNaGRQVosw3oGowdKXhO310oSkg== + + + kKpuIzr/u95iav+1sdKW3Rs0uKMo0AjgKlOspHImspbuXUmNt4XcAPGxZ/3wufh5m6wXdN3TiPiI +OhS/nRGC2oqfYFToyHCWaprB/OCZPs4GnrHMrsolBX+L+PMZm0S5ZiBhOn46zgFs3hRAJd/FZNIP +gAfwwR1gpNz8ejk0Oif4iMIiy0nEXutKy6V3hNUxvCjBPYasDcV0mhcps34Law1P2qzHlt31nqlH +LJHJ4eMsBMopa4qek8mvMnTr8DaiN6vXkjrSV8SqcllRz1YjsESNRqpa+9XQR4trMTko8zDHR6IA +EHuc2DTSUZ7RS2V2z48NZK4DNZqHdA7CHLDi8z5n6zyucBHPFbnVsYKallHYGTBiUjdz7RXT39f+ +1u34I+KQVfeujfvPeXO+R8G7EycEWfJc+2HzfJd3gN8qusE+IBA+6eejf1M+/z2L2uumjXC68OTv +f23ypsRlEbrEWNER2ccHoAHpMgPf/dIL/IzCqZaRzROrU0VsZiZjDlhJlKGuD5W5UbN8tRPqK2q4 +l70vj+EnfDV3pRUJgNxpRZEC3XCsBIKv/PQsOMa0jXZdpDu88nLvy4OJyUmbnkPCQk6+HIywAtUg +9kgJwXQpjEJnyh3o4f+BYrpPzxDrTr9CPdvtrovul7oPpiubC9jss/Ioi+OEu4td1d5uv5etO2Ni +nATE+xiECXt9IscOnZYF67pfzv4dPV8+lKGNDfnyb4Rq4dBURzTY5WLWGpYLEdGvL04RcviiSnv/ +cjAUILXy54glPIx1nxjYyHG55hmqVd2G84FmKKU5PGk22hRPpSgcXyjEjnYajBghdBdFUtOwLnBm +9MnYJ+uhAEC1mswn/igX+mtWSPCYGM/s1Acpqqo4tcC9ctsgOMx9XB3ZyxGngYeP11XUXSqIrd8a +tifcuku3zaPd4mwa6gwjTMpo2f9F8JMRjq0LLLB2CCnPdcR3MNCJTmlzn4O/zXSQen2/eOT4MzIy +yYQ9kWq3z3W0+XCoa0d5ruYYq/X2dSLyNGuF1ZMI8th7gpsrUuypv2B08eZBa/MdIdwLXx9+MEb/ +C66bXCb6SwlSnlDbsVtChQ8Yl1DBM3QymPLtsynAsyMQue1K6CgfVQYD3MMQW+2IdwLuRb8INT4T +WKB6M2TA6FMyGhXOT65wnVwBihuy2B2GKunbnY1AsHehuV1fGf8Wx6wdhWRLotS2hyeyIgigcDZ8 +6GecMXXPFnuVN8KM6VLyyAjnF+UJgvTrTGhCEdXP92HVIqr35zCvhyJNI5yLR3Ccezn523Nko/j3 +zPmbgIBcssf5SytpxrOZkaH50EKepxB1IkyW4hQYtDAUke8ByF8lF9kP8n06Z4maJ+p5GUc0GFGv +gpBg0w6y7LN0Za6SJZTXMnNg9EjPPv/sAgJjXfpr2+8cBLHzJ/TcbClorCRI6BYSChgTdOF+auQF +asJTjwnPM3/ZMF6tBhX5xKBLfG3cGUJ9cu4ClI7UkhNEeg3GA1NYrOCpwnaNz5zlM8Lv/2FY+D0K +mwhmLAiUTOyKuWz0RR77Q4owEHEnQiNMvdXeleLbhySQTdZDiWyaBGSHxUiSdmssgFr0wAoyirDg +HRaBn7KyeWdeRrztGsVyhrkcFqkG9ZUgkaOsz7HjGwW6cEwgOAA45NJ/iCgjU6l6mQ9/NR5+H6Wt +yIytiITieuw5duWl18C+yJU1pCo3NNQW0jvwOVO8j4j32Yo+Bm/XT1HMtqfKArTNKaQBFyBIi7/J +6of6L7ubqb2UkufQqfZFeZ3YykHp0YJh7Kg4P4y4CsTuenIYX9wr5Gm88Ir/vByM43Su7n8Awnwu +mfydwDu4Ra+XwThRcUpEHxSdHXE/kLM6MOacR8IOEWiDEZGnmTY3v6NcJ0Ha36S+8mai3eIRdLuc +a4cezbXoAiAAaZKx4rqFWBweUHmR7/Mi3+0zIrekx9YMxHW0ltZBaBJFQoLaY5eDoEmdX5TxEpn3 +mPo/fETUAHdF0ryqYJ9RSBJwa69CIqUMFVgctYju5L7JUJA1uJqSJZKAWcfxk/+IyDUj4+42P5uC +15/HuTKe4Xt4k2tWeX4ySdlHgONnfhDCmfPFYfw+CA0qhlx7jd55La9NOUbsIH0Ls6J1ujmwuMhZ +WRajrbc3LRfP7xHv+wm7cgmBrP2H46BUJteO96Blv1DfDKhh/ynC+qnE+mbV8qut+oTfyTgsK0qk +yCa9kym/84jTITs9FDRX6hNWF8Czrug/dtl7bSvjh4hcvBJ4ErgVIDWfx3lFP6FJ9zff6lfyLfbi +Z77wFCSKQ5vTLgSM3KvTS5T1Uou/Jf/3pIGJ1pp2NXxQ4Sbv2lqhXmo6DW3JKHkztRAZsRB5i2ai +tL17UPZ7chzzfYHBI8fp/gAoXAc2mToGxvyTXxAhieeYKcFxlm5zsyK+Eo0lcsjI7nsvqlDEqHFO +XYboU9kmMoW+IHdoqVN9Ex5nzPcJqCdg1a8spalMzc+jX/E9SpUHU8uKAGRR3lvRMLRpKV1/iChB +q0LdfhH6n1FdQ06+AR2Tx6SFNAxCgWmhovbNH4Kw9P4h0ZNFmk/UTIE69aXKWbOm86FmctVppH9+ +9HNyq/ptE4CAgWuoAewyBLy6g3CyHid0LyveKJB6+NEofninuV545b0j9U1d5+2jf9vPVbkRW+vc +kZo7Mo7GYFohFcbOSTHgHVprcFzaGChU4kFb0G1E6n0XRtYGuzBaWhahTW/DGRkTdryPiBFg4YP0 +1nzLno8oZURHZEQVQXSO2DXSQwbh05Sn4Uvz/AuWPjL14LYtWfEnSm0bXuNbsJoynw8tRx/SkXq7 +AEVjIkQHhbJHNU2v9pLz9aezCFsYjqwnPHB70Znurw3Z872/7sIuvgJptT6wpbsZbb4bJFtEXL9H +/Pkd4mm0Ca5KldPvx7nHS9/tTfXQK4MmsraLXON7wI/b47cgdpOm4/AAKUVbocYnl4fjviSlyjmK +/xxUvrFzNMllh2RM+5gf9qczxDijBU0DZMpB/KGmshfdMUWF/b5oqelHjTsYYtKAmhw+wDiQrjWp +xqQ/6igNDRF0Ujoz/ZjaX+ipd1OK4dR1P38wqT8oRh8R/3xaSK7c3z8culsurJpYtI4GMHUPGsB4 +LKONTXtvKXdDQQXvuDNHQEWpvN5JM8kVUXO8UbRymozlcxzbZTc84RMxT0SZJ2Imgt5UIkjjkKt+ +3rYbCWMIUWg5Hx70FR60ZA790f33GFZbjtT8O6xSJOHXk+9YaVuwQO814+v44jnnLtnnkxvzyINd +QcYycF82RK+/GSou7CpFAg6lJ3d9giS8j2c2+qR4Zh/Fa5jIoclhNv8WRLoHjjbtRdfDUL/n8Gfz +8Nit3g9PjaHCGewhSAX8FUOc9E73I1WP9TBRoYgwbb3iEzURDwKphAcpETANqNQOJZDjPGqB7sNV +I0R74Si76tdxNce9bWL4mdqEFZUqHpkfAtQ8IydgROtRxRgM9u9j6COJlK3qbeAiJ8VI7pZRteQz +Vc0LMNRkBoKiJG8p8Bth2Hc4tI4EerK7Y2ZPv9kn/XZ0cPvSKl1SEcjjXUBA1VlCpAki6GlfnMIC +GN9nBHbXFMfI3rwjGqM8U4UdoCKUjef9uIPm9FGKSrvWPb/Vfh8I5C6ilXPAaJc0dYJFEVVa/oYG +DjvmGq9P0BWxHGjkGouCXvELd3CI8guPdQ9JyLiD5DTd6PiloO72LPckXmU1qmudB3e6v/b1ysg9 +K/NDXviMqsFRANVCdRxgBfTurpoJhUiOYzOWCPQbSDH9sjurFdnGIQRJVgSBznnmMQzgSyCFQ+9M +f+J5WL2AyUoOH/VB9FTIcflTHjoi1GUBsqvIDYX/fH21nnC1cViucWOA5IBMVpXMzcMM/GIOgONe +0hvUPVQsNERhWJvSzgPIIwIINxe9vPQsohRfgRGlT7NRI1EAr4jo0upvjbOMUJ4Fdb8pUzvmIkbM +fBPwI/tzFYre89BBIUZ6NFFTLusD6bXnPCXqLTe1a1VZAwIkbK7zTexsTUAn+aqB26psVb7ujLSZ +fXknI3C94Fj9ZNj3WCSoWze5Z0+M5hUlgraoYQQRYTfwaNH4OmJvDVraO7L9OA6MV9uEDCTOrdaj +CHEAygwo7LqN3GdsM0ub4/3n9PJn5E+AX0hKP3+CYpH27GWmRScRHLQT+m+Y9X5EqA4GT7VFMjgp +x/co5DNpRjQV65q0eOfV60LPNASQKB9hbCMvfv0Nqu354M4HXz71rFY+LvDAr/nDn/MowOgdPTmT +nTUMX78+WGlF7UUVYaVfD9AMs0YJsl03IT8ueGHG7d7q1z47z9MLMZ2qHN9Rsrv+4jIX/0mpcdJT +HaLnfCdM6PwlQjgPIFFvpWKnOVr5orQna/HfADPswwFL9q90UZqUlaopHMgmanpCn4iQkPOMSEmj +3SbTHcDcNb6+rjsMCHml7/avDc+5Ihe/vArDnAG0yhWOahjzEBjB+ayjPPr9g7w13wngH3+Od+NR +wp8AHRSKosPZyAeQgfqI8D6O3Mfx9gM/ouDCu1xg3OfbMY7a6xP7B0mwyCTRxRshuaOe9aD/+wWj +oa6MuC/K//0zSiSV7Kn0z7zUASitMPgWlmUqxUASIMVFY6W/ulD1ALH297jV6TqsFvSDo8FIPXYL +5qp19B8a3h8RY8WIiGb1C1lOVHcXhYohuHTYE7k0Roy6UZR/RAAGXKYkG+DT/RP2aVPCzH1HQ+a4 +XrG1/Yvenuk6/pg7FV4klvqnqCtXZqNhRwS3iQjlIDmMLK4eAD1J9JDkcR2kP9zf+uv469U+JTGE +czFa/lyDqjnVAAmKV/w9S8U6J45NxpDdosoqQ2mkDta7KkDEo8LhMexupkOlhi6R+3b0OZ2TACkL +7Hs/i+pzfI9AJvTVQv7+oSQnFaf1mJjyw6yLqHMv1ZJrMpahbwy5UT3SA0MB24+AbCIt/lbUNQg/ +fEQp9nPrfkFnvu2Ipbjy5wc0I5+sUHvlfSUSvkV9SG0z3DcLQ4ArnI/7RZ9TgN1mefdQWWdONV++ +R3ytIZiFIQ3lFObjOHvfU3IKguvdwqkTSDiuoLvAmTFKyOXeiTWXe9+0cwJ0o2Y+pLcrUf+g00RA +UofkuCXaE6TtQ5Wf4myQCBXPiEB+g4hRvtamkunLzIiMIO07be6uHCa0xIFKUU4UOl9xSmyEAOv9 +QpU680scdwxb/K+R2H1ONFlwiiy7EXcwOA+oHtDgR8C7HZbi7z7gWfUSoHfyvE1Do3Q4Rkxt+swr +4N2hNc9oHVkyjipjciSF6MjYrQPzsIhVkLF9RqRsCNgODikKzz8cB0rno7YVk9nA+6Mbustk6KtD +G4qhFnhoKuAo5iGXYuWDxBk7ESIeqqLOwG+BR1l5xiJvAsePoGj4QbuGRH0ERI8NElqIgmLpKEjm +3EUIg+k/HZBaON37dl0tYqBqxDDbQuti/3mfx5+K9h5Qazy9QvW/REExYD7+VFgsOw== + + + Qr1fnYV6CrGq7ckPx+lHLil4n3HwvUtwLT33HyLKy3RFevK9K59RV9SYsRacz+Ffhy5eb4Wnr+Pn +i68jNC5/0zPkcJNreNGqnlv7rbnGW1bfmejxy1GwMkpE8gTEnOOAaQPlWa/YIkfKGAvQFkCe/lYE +2L6CrhSaGdq2v5zXZFlz68Roz52NlPz5JCNAT0R9HjVcwmM77rW/k2GQ53apyY8I/Xt4KFJiTRFX +usMBVqEbSY4ZcOcMivRu7zWNQu6tQ/dPEXi93irkXkhKvijSb1HjOAmwg0CLe9Hi9GdknJT7ODfw +kl9Bd54IkGPtMyJnClxW2YZXUPjbca7DR2S+qupvC0KKrKDYSimHgYqurjyj572/cIBfMYwS1BpR +TQeIHUWHkyhYAn97vs8T1phJbXfYl4bOgKlEy4fxHEQiJzKwpEsZnxEYeEw58equ/0Xr6HdRC7mL +fRw0WunqD1V1WQjYpllqFTitbs9CkTE1BWNe7l8lksw/1toBIUJZykNZlT3OFkOPHEDxUFaxngh6 +GJ05UvncaNNa/h5VSjwaOloU6keuWO+tmJDKLCAp6mqC0rNtuceL9HbMY3AwYnAwX23Ro5G1pqYS +8vDFljFOa/oxlQgXARu1xQDB2LeUVkd0/R+nwqtIkVTYX41cORdfIA/zQCBBRVsARGDLfky45EyK +SQzppzC+pf6iINRKeu/YTGzC1Cdvu5XzQ6oeLm0P6msvhdqzAAVZYRgiPFwVgZd71LA2QKN9X/BH +L7v9roU99S3iBTUFy0Fpw6P3PQp14EsO9aQQWQrmCnB4P0Cc0Cn2I3Aox30/ZMOnI7ur06pzLjaw ++rYM14CIBCrGiMy00B8UmzUkaDG4K0f1ucIFafPIGt/KgQGfWxHsnCJU9pr6NwH37kwZWlOrrwcZ +AGxgxH+IvPtr4vxk5P+LrPz/woNdv9Ga/kuivf/l3+//cv/2X/83v/0f//u/fLLy23/3P/zjP/5f +v/3X//2/+V//3T/909//5//4d//m//67//nf/Yf/+Hd/+sf/9P/+3T/+n3/3P/77//BP/9N//sf/ +5z/lpD//xf/29//p7//dP/39v/+7fYrffbnn6xv8gXjA/8L/BowGO0heAI0xsARITO5NSd7B+g1p +vGo7pdewzhWAip1cFfb5mypHuN8CLAGQ/hvFFbI0X//sXw2bhfuJnru4/lGyAAkAlfARC9S4FMF3 +8LQt/WwBmQoFLNtsdVYr/29RyoxQ5O4IoL9GBLOBGRxELHwLyuUxgKYZMU7eysIiJE+weI8QY5RU +YTRVLUvMFp+zuIMLUvjv7kLMwHlNGQSXXRoGJfeZLoAFUzN8xwAldpqiGh8OMwiOGNEfI3ZaFsXa +MvHSPFStHINZzD4GlmVOZJ5z/Mi/8k8KcFcF2KKcqfvY/qPHSTERtwsyPP51elnz9LKAVRPRu8eg +F5MTjB7ZoAYVnfECulaqoXWFAF0rkSvdZ8Xz7/nUx2KNAwxIq3TniNGVFXoBV3CdKZ6WvzoY0JMg +69XcaD+blfRhxIJAFf59V8e96gtIdvdn1wILOoKQK9FhqggtHDHiquC2mv10v3uA4IidkCwpwAYz +I1pOjQvjWqaTOqTOJ65HtGEQZYFZFMg71x2O4XUqOaJQPSYKG4dEVbCIc5ek5zi6HNZIDfjnz8wH +Q78X1FVn/jRMDZp6Bw5mFIsximWiTxHe0qlSvdIchh0dv6DhojwEjwiraff5Bs4U0Kx8At4/S7EJ +LRYakA6FjwIfBE+Krp5C8GDI2U/7/kGB+eGzpNaKrKCBQOjd3n/nqMVm/0Vhrcrg199g2gUAYIhw +DMElgOpHJtYPEfj16Gxt72ic439E9XTWGT7u505VGjyGHnSVyHawHcRRQ7N6KNF0NzSZ/P6BJ6BM +Bij/8VdP0of9q2c2XUyHyLxQ7qX3WJ4YHwr3LXJ32v16u/ohrXL62KMnKlrbj29z/pzJ1KAJuaK1 +7VKjMZBfoQUKpvv7HRUxF6cik3J8nanhu0QvfBytscOk6Aw5CCAtJaDVFbyb+R8BzzSAhqu4ttU/ +Vb9zmiGuDsWdHhm4K7MJbOShu9laIA0al02bkEs0q1hQg++fIoZVG0/wrl7fW/I9irzyBihEI9Fe +Tg2sniaEyElLZ2YMHWCxqTR0q4d8TwLMtwDPM0fsKTTP4L3/fhTz+r3EDRrjrNFgPRjaFAQMk8d/ +j/jpIf6IooNWIrnELgEUGqk9WD4xMpBwzu+YwXyjySTE6GpvRFe+8U++JC2IftZ6qRwN4V60o55w +d/YTjQYhaBDlPfc6t6ht/tnLEIYKH9LfBSpimeAH7AEDJA7NH3prqvOOQi20v95l4SNmceijqaDK +eXWvIxfV1aYxyllGdeTe/XOxRDsHn9o/EkECL41sDSNggBMRcbHnuNnsiL0ornMmOjNEoZ5esp3B +1WQ7Y0P2gWEYzLv26C/Cto4EWRXwEDPHpXsZeM82PyNcREu8rZFaue+fjkNjXVh417FiqJPuNoTZ +WvIVlXySrlymPNqT/vkkRoHeA3tk8knaM26jMAE6VuLLw0A1TeoEvYbUCRLnH6dgb2YefYFmPe/C +hERkOFY03CEaYA0UDg0PNs+qrVaQwpSI8W2Fcz9DAjO/Qcl15p0LQnfZI3TVYqIvLO6QD46+nEtR +JaPpRwgAH9RFAuZahG2xHb0VXB4WgXiT3v1dN9tZN68cH1FOgH9MNM6ZnkCwvbgt4DyNL3YUY7iz +jg/ZF0ypEgGmgIi2wttABuBxvJeA2W/xgwq7e6LvpgpgUkvQYcPXEg5zOD9TfloAm4LVblqly92I +Nj8phNwZv9tyTeceHVcauDN4f++36tbxgTYeX153qCdYUVJUV84VO5AB6qrqyBPito5B+73d786I +xUk7SEs+vB/9zt2ypL6JGtrv/91CJnD33B8cXPrhPdU8tpBmRbGSu1F7VzVQvw6PAS1BzcSJXhg5 +fqXdQ5GJEFhX9uMKNpcIHjoihHS26DPoZJTvcdDvHcrQuSGHl1dQ6i/JXwJhv4YcYI3eIbcihe+3 +HUnF6nmJ//gd+dN5p2QasDXVysIdpTrVUpkYoiL1DycKX2H5CPeInB3zaSZJgIA8DE/9PgxymEYc +aT1mPwaA7OLfTfkGQ7qT1PAhYqz8dee6EaX6CmnunP343c/jd9/GiSDV3hFLcsb4mydfX8tJjr/O +ZJT1tWhtSWWhIlY5qSPLgSswi//JSO2vQOO94qDgpgLoQcnp7xEpUEpgi+1WSvCH48AuG3oHLr+v +WR7CNxhqtRldNvxfHo2KyU/mFcqalOs3Ld5RGo7SQWCiQdTNUBCAIjtOO4/2fiALcoswINlDtffO +EJHWt//ORse/j4OH4sP01eHSlpIoU61bdqx/nvplf3SNBDBUxSOtxQkSq0s+12bDX8EOyKDwVciu +iHnKV60CfHfU7SCa4QAYFAaaBQwPe6Uv4gDz7+i720neF1LDdE1HX1ADE+8oK3N+0AZQGDS9Qste +PdAR+9/G5JVhIEMCTcmAqFH9fEbgCuvsBQLSOdNHVD1w+a7K/K2hFhaTIKm6FnQstFB+cfGDeurO +V+XnIR5QPiPym2LWyg5dEX77PA7O9iy2jJ48TEnStY/ZkZz7CAD29t6Kj8/G3wTD1IWVq1kG4w0S +ZFXnaTjQ0YLW0RZmaBq53tU1OYeNgwFRgjro503V5Zzf+3nLUbTnq0dt/96bDrMkzsLV68q4jFMW +TyPkr71nsW3YIXw776vHKfFWAMzjwEZ5sHoRPUMEnQ0inpUzNblGe4+xpaI0AqOUGzvek0m1eh5M +wOgKtHAXpiJqyv/TPJ6as6LWRIOHqyySYGgU+UOEbHYaYXCP3pztM+qJ6jFo43nuANxSvdLBMHux +nP1d+NZV2yF6TO4f4FDxIyKrVgtHuAEGHc8Px7kvxT8ebQcV1lmR5O/wwscPAQ4+eT2RBjgUgh+i +oOwxA6SFwoKM7RQI1MZOenThgFejz1x4fsYMDhyCOO5eZODsqH86x5e30Pppe8M7y2OwH1qeC1BH +LEtYWImS+HhQ7ibMQ2eUdaw1vTcjaaknAuSNxgdaMZQEtbxzvY7E0YjHStXliDcmo8oM5pA/p9n+ +xA0arnHRHUBT9UcD8sq8wDMBxNV+DA37coZdigQPZahS3VypboB7BgHjuJMGd1qBIRHuK6phDhNh +f3NViOrsvZd0GqDRT6a8Vb0oOF9XgNEoRfP5eN4IF7qKkMwwIr7NMMGqYJT95vavw9Oq58+dpPEd +aHf1GoyjASL+m3RdI/TViO94voGlDodgzvShDpo9HtBq17SoWXmUow/d9YG0yFIGvDLypLV3kaI4 +cAN/Ean6fz0XeisRCNDghiFI9wY88top2aXHOyyBkawJDIbeiIVGxbKfYME+dhUKZgGaurr2F9Cd +mbRG8vzema+lP+ql9gZG9L0Jwzls1x3Rvpgz13FBhaY38sU1QSEIbWz97LXI1Hb1SYT79sUUHubM +k6qEiFWSqdkB07j4dXwlKse3skaatCp4fCkDzTd4sJMkot8KHqNqX41Q9f5CXPTkkChGE1HKeMnd +1B4oXjVQStFvFJePbG6YOU3zHKx1O8mvFu90K7F4X7AVVndoTolsg3dX1LXN9wT3of4g5tmTqZX0 +IHmcuieoGha1WAV+ZAjOktib9gXt3EYGyJNeKYKm7WWYMazaSRRRqOoaleki5vJUOzPUE8dZ1b22 +HWlesuyaAGpwArRphxxI0x4Y9vh1mmNdK4GIVwDHED9wwY1RaXaskfOj1JPfIQMt5gGRIL3m1zMV +lQDI9nfeJzN6Ohu+uaRm9DDhSHdRMD3mPD21/Q8RAKPr/LoTv/8QvSfcE1oeqRnfBGZ6Q/NflE3A +ALL4Mq6Gk2SL+4KLKvz4W4Tn6Uu64UMOOlr74Tgg9lGDL4BOZoCdQt0aKcORPgOTjCbIo1Ptd9Si +9W0v2kw9SJVoBXwfHYVGO6RGsCoFYtUiT38awfkwXEH9wwNzVI91hZYu3yMyaaXSL8rVarDweRyE +Yrz7+7UYM1Y5+xpRbjfNUD8jvqPN38fr91GqLWkjC8TqiQWzbtUY01yRHBR2SpXODtKP9zHMlgww +fh+Q4vqJj8B+FxVl/DgK8P8uXx4xrHYgNcomN8ctHwEMh7VrH3KJznm+Rwnd8oXaK58SdYvBVkzv +Obz+ayGiOiEpTtHaZ8T7tN12U+i53OWH44y4WsDZu1FUY8NzyrG3nFtS8Ahs8lHW50j/B/7Dq3Gk +VI1iFZIPylNLh0sEEUo3rC9E8H47BktAXL7RJKYo3wFOLdlwqmi3vfbBbmGhRjP9PZHTz6Kt1kqU +jJKGXvXwOEg/UBDh3J2IKDTeF1KBRJiQUpqW85OSOLUoPOVMRUYHvns73+lZUayJaR7S+hgI1uAy +WvbC6OOIraOyuWWeh03Tad52zai+BeQmHSD4xx93PSa05rxLEvTYRO93RhroZ8QVcw== + + + VjBb611xvgd9QyHaErQRxrq0sjQnFRkYfPAr0Y7ZP2InsKt+/zzXaogwY7jUx1F1/t0xnsw/Lq95 +vml389hPeuk/RszMETvZyNc9+R6F7q7Ay/2EPne+7WPzbCd9Ipn66d40taxWOorVC4JISf2MeF/N +tAfRDq7jh+PwhCPuXcg0KBMg4vzwz9RVVS4YFhtvn/N71HVsmNBLL7bv2nn8hhydnUFckQRCDXG5 +UwDIZ/XY/5A217eIXLIVZRUITSTen8fRqlq5cQZj/aRj46Rj/FRdz+/jrv6Clq83tahSlp4jppoP +g3VhOYxXvAp6KPKplowJaeCyKkEbYYGuWWM5x8i4lpHD83Umabd2HklBoDanoWJrfH+O4ygbxgPZ +jc/tDHbkha64zUOq9ghQlFWkfRt/N6BH8hEKHdDE+KlxT3axTgK7//zSKRcX8odRTTFpmYAIG0ru +OqJH+bIr3/kZkWyjyEUlnaE1+MNxMNdM6hkgfaH1B2wVXnc3F/8esUq0CbRfa+0rhf0W1SNCOTDh +vpMK01qht2UlNeKKxy8Bgc4vmf7WdbyzBmveK0nF703WdmMnmiiB+RW3j+VxRjzisWyOmLBIAsza +nzTVHjLjoXBr+zqumwF/RfsRYSs7bxWCXf6a19cTT7/eTGto6Ct1boU/nVuB+joRNFt2xJcGHPm5 +3QB9xFZuOh27HYXh65RbH9UtK6HHobnISsSHpyoY3yMApNGY2DsfyO2c6TOqxOdy4NBwpwBjNkAS +SrL8hY2k0HHYShMD/4X3g6/H9h448zAJ/ou/cnRF7bArBfrAfC3L6YGuPhMBBaQog3YKTauCH58O +617M0P4xk7wvDXfBRF32gldJW2W8VmOjKvPHosxa8xvT4fRZQYOCtgCSxJfcKcJjK/dbwJ/fYZqg +EAqX0X84zK6SHU3b5KDxddVMvChaVGj6iPhpT/wIQlKFsoe5QpnHYopu/t76Ue/QSyS+uxMIX+Qx +MUVELGxokYz9I7zRNjJt9Npd8x0m8EoU6VXtkX7HfhV5TIXUoBIJMAWjLgmORqjjhpqeIBZUzjWx +oxJ/TzlWT4vmlvHvbFcte0CHEhaZE4Mscu7zfH3wz7aQWtZu1rT26zNqDjJ+WDzLsrPOlEMAWycz +hftAIhtksx7Hqa9+ER9GoVOQ0/nw1nIGfnf+3CYZ2kx0etu7lBeJNiein4jneAdAIiGCgvM9k8op +LXr2sa5p3O5dP7Unx/FO7ojaj43Ooe62aXuPiCK/ZxcwIxGaOPYjUpkzcXrWnsb8fRoVJnHZi4Fe +pEXlUyKeFqV+DGX498YdBiRWVuzEruNHkzrzSZ1px1/5cJk0ykZJ8k77dKoY7QOSR3Hh1Rw7BAds +XX3FQHHV89wnvPpftO5D/lrpBPNt4M2B3t8Xi5b+Xpp6Am69zDQqNMJlAqrOCnpt0gbZ13e9uqyS +4ugwdBGTiVJcdUfdhzTHgs3n8woaOP4Az60UvqeJh8J+aa9QBpW2aE8S98w6ivQoxpYXeRiJWSpo +3A5LLA5uoPL7kVjVKzgj9b7XVlAEUl0xRwLCBx4n15hdsaFjW86daREi3OsfgBJfXZWZmQaLoqSk +CZsV/ZjhcW2HAWJQqP4zYoXjAZrgOWzPzyisbCCt7IUKnApPUACdPJNqVN2ZcmB057xulqSrMDKs +v/AJK5f4bWRSzzM8M/eDx2gXCGdlTsQsR2OfvZkMaOJtLxb0g4HFuDKyIdBHxdXVTYofCP7Vaaj4 +zSr7ID8JM2+hlOgHGRNxtl1VMsXgcyU6WqEreidiZOo6JAipohr3WBynch5RqPtn1MOXJwqtCqLi +Vum3OeazuSCltXVGsgxX+QueQ/6CzsP+9yi17GNCtc1hr8NeBtKwAlWJKEhH+6p7ixAuwY57DaU0 +Rkaf+7lhxwpTHH1HbZO82CAjmfPbYT5nwo9o3udDtDpwMdfMt6YFSlJWKXQZcyNshJ6YjaHVAorB +FwKUnF+BcWxlPnleyxWXmqfqwhpZsjw6o+2b++REsNg4kSZRT0hXfjV6XtgCuZSqOGL93iT2vHfA +PHH/arn5T0S+oESLv1+nalXWY/7FBxOArr7NXUBUhjPnw/HErKdhMFhyPx8RHDvF0BZpALyGS4aM ++xWskMvI9w/SkD/KmN8/ZHNlW/7OcX///T4smv3yrZep9H4GaV007nNYv4hNiPDo2pT52zUurbBa +EOyAGUmnfO8550X+FpF7diu79pDroo77eRxvPVANXLnZ1HdqJwhGXb/5UwD6BC1G9a84wGcUDtV0 +/JtYlHjBk95HmTCOzbZHRWj6tO80+M7dzApaaMPPX1d9VQHiTQ453geaamIU4kPdAgpCJWDUEwEa +rin9wOcK+taUU36sXXjRWPPrNGYxO4jxU76MO9hOdr0RHwDsCSqSxR0V45UTxTpU67c4QsPWIGK8 +RFGibNjRl/KWI9hkV6AG3ssVi0ewdLoM+6z0yWPyQvQzhNolqPvt94jcmu9p28dx5gjksEEvHn4V +Rmn7qyAtMz8DfAR6HoHy9fp+C6I+NGHdRcMY59vO8235ByaG4zoTQ+VBcQXg2tKDfdpnxJ8PBC4+ +wxCbfwgSDSUeG6pBdBHEGWE2iLycbrqMQuCbHyGLDyNU4Eq258fh4gCCmqK8GBjW0wVXOoTp7k8R +iue2I557/I8+o/D/GQczhT5XiQmhKK8ngH5rmUrJvFxPJmgMiCBXf2/yCBVpBz1I8hql5j7yH1eU +xlB6hxfQqvtkDdS64oqhoOUINH1HqGlBRJRjm0q+X2dyn8RbUrE2yFkkkdX19fE4aA8QMZzBSYWX +/JDKyTM9qp7hFBfpWAafRFxzvfCmUGwflDBWdMW8bShSW81c6eHvzAzpaAup45mNVuXzQ0RdoWeW +fW3q+UWfURg0KznocrJcbPVpoSWogfLOBOyVz+jXKs6mvNn3iD+fZEk58mYVUn84zi6MIX+CJND6 +R3lItSMBdolA/R6BJHj/wiF8+6wEeIsIZBxFuzIjKMb4zIBsPIhvXmTfEefLDYwfD/O3gK+VBL4K +eDu+9sdRkIiRpcPKN6J6Tp31QOTEOcfdZUgAovHVzrXuudavtzhRUJeJksNPFErCREVnigias0RI +wem0QIoR3eedM5nTPND1lhGmrLqvvrfG3W6e3Y63op92YWmqGHocDABAyj0Kc8qWBH3e7KcaMX0u +6XTOIE0vRrccox90NNcmZ9KcYdjIWAqcIjpLJgt0ztQWh/eg6eU37US82KT8HlDXuSpQc46A1UeQ +wryABC/kL7kw9ykBLhunRyB6RSBabMd9YAD74Vy9ts+I1BpHAJTFYan79/04I3xjZKD0owBwj2Ul +ZRRJ8gNqZVxx65ZOgg5Mfetk7KXA5O3i+hJGW+YhIDxP4Ij9oLzJ+vp9nNRvPVOm5CXsxHWgk5p0 +y1uZpxvFX9dQYhauWKBk9M9kIkaPDFG2fmSrLUhBwGit16LC37FMf56PgOCd5sGT8dJf6/MoGl+X +GF9XrWVKzkvGJEDqI+AO1nvXtOOeL67qe1SNj+JzOm0CrYTzgzRAJ0veE9klTb6mSy9CdIDlCjVc +IsoXkq4p2sCvXWTzfugsEKXumuthc60zsS7lSJdL7WJRSkAaA6D/wx4Ks4tiaX2dR+cCgoZfs4ej +BiCjtHSr1ImFxYZ0MhFxG5mPZDDvDEBr7szTcgxbFAUB/tM/tf+DK24/lFrVUCFDyM5ob5sPWOQd +x5I4Z+zyDBvDHyJ2hvEmdh8f8nzNWCELiyBd14QCjxMqEzxOdMzFzsaIi+S8f0bkBDN5YXty8X44 +zn7NwAXvGh/fPb+fECr9LZ60dQ6vc5qLfaDlfUHaOvg2SBXj+Yz62/N9MkzcuaTL3zv43Rfgir8y +Y/2YbE5XHBR/1PC+2dqfnyJagEcYP/XygoS/R40rso4ocYGuRG1WcsdAYGN9ytiyYUNoguC9EDf4 +UeiWlKbQ98GWRGedD5nccnij1Ub6dIR23Q5o137xyg8R3zflNKq/R6EsKZeBVm4WhW725xjgDnfA +Cm5fnv6ka5I6QauLEnn8o4oqn67lXtDviFkXMDRyKPo9IBQaMt3oUhGA5YLchJ0rBOdwxwlkLwi3 +wodK41iYBN31gkRMHgtFBVUGsm7QTXYNgbGIJ3qGkt9w46diXOqq7C1LDuq/PTPs+LmQJF/Z9ARG +MbrFqha9arAe6FU3/DIpAEL+GcwVkSXGxevz3zOlmeliXFSPP0UhNuCw9sEJrkUOLHbsCL1g//cR +AbqFQTgIhVcP4iOoR3BOnXANJpkuB2CLViDfTL7ghbOI0OujXti7/bpcZ5R+NJbZNU8ZB9isC/YA +86lLCOU5LiG9tkioRIVy4sP6/PbHKL8XDyjf/5P1XmCh/yXdvB0zD9JCuDTaEVGFYz13o9D7DydK +DBBR8UB7bQ95m3sSeHGDppcq1s+wiAvSxccJKULKKCrUHMM2KK29dyjD8mJayiy5xeDsYP0Xoqyk +XsCtmSH1yVgaVm6NT0LzreiHW05HHslz9WGBeKMAcR3MpFFHtNb1bOdEFyN+zQ+BIGN+yDDJIpWb +QJGqivmOoPrhOZ9Dkf/jV2oZe/06ATKaRHUBz0SFOjiLPkV9aBZLhIo8fJU79ouDwfD+d+Rp8gN0 +AhgQvM9wlBSICgPPhiGTnbehOc+6yRZbby/GoSlxoY6SOpjoU/Wk+Fc5+2hzb+jHtRngC9YoAF8s +SgWmdOUr9iodE8iqhxCDbhZaZGWQjeLF6a7gj3a5Ox5PoSOcr+md1JUzWJzAbhgr7p/2lLg1gQXZ +S0wgjU0pKP9duJiyt1NQZYAAVNdCITD8Yzmstq6/RruyIi4WpZqrDvTKP1eLvir45QeMvfhApuNV +VQXwA4f9BSjh/DUy9jD9NXcTpZSvZZdp38FdtvUTMdWef3RfQgZQbTluajsRagLvE7w5lTBbEi9G +OoDuKU00Si4gj+C8qWEyxVzg0xpWIG0G2tJM3vBKEuk6Zli3+02ab43OaFyy9E4zSvbTkcLsQgXq +Cv7AmdX+kpcQELQTqcEv6O08QYwgwDbtx2cIWbix6/plu6QNAGs687pr4oCnfdYEunjxhqpk3zOr +lvIEh4b2OiX5/U7LF8TM97CH/7RvWsxrxtRhe/+6OYAfeIF1K6u6sAphXDcP3k4x9JpgeO1vh/Ah +yJF52Dh24l/4DHfBCwrVSsxkFHAxZdJoqwRGiOQYWl1G0Chm7CTkaSFacYnxuDS55DzI7zn+eV9l +kCDichuM3GKUhEHT+pYzUTYR0YNvW8HIX7J7TgQVM8cQ07fCDokT2Po60RNVw4HvkBcmy/hV6oEy +2yG66LDz4LT8INQ7wf1xw80VLnOMwOhCmGTu9mKy0ewDH78vN6hBEYZ2BYpM/X2nmU0CSOM55WXe +mYF/UfCIvtANurxlUtOsa3B53WWpLq97Qzk7dTvmPXvlAkHVmCeQ0e7s9YZsx5m4aQ== + + + nIl8JRdquLvgClV86m6wtkiqj4CtwUcAtp79F8jcRuz19pnW6wQLXVcEdgmDmoZy5TjAP1jN7xnO +A/q7Kr8DjKWovfDfLWe5vW89EIDPponDy60bCHMadlx8A2A9XJgSFZEtyjTyZvL2/7OHaWE/XwLf +R/A1euH1eyhMgL6qOK8FMDfHActohF9cO11+2mI4d+dM/tb97o+XRYFhrpnIXkPlKvt9WMcxgblz +nOBKEFwZweLYtr+QOuPKE8GthcXPUG9/gDzBOUHPMJPQxSWHVuirw/CQlwI7aPZRurnx/3U03hQQ +vhQ73/t+lr8kjg/964OIiw8P/1aFuCLwegn3tUEQ8rViawhDcIuhgYCw3qtYjVPU0E7XDbUdWjKv +PllR+TK+Me/pyXu03qjrdKEYpp7MyK3U3MnSd8UMq1Dkr1Qk/3qW9uZ9P8o7od+5993/v/JOh9Uu +JFUo777Rax7iPG1QsBnrZIajaPQLdrj102GR138fUtG+K3upeELUQs8Doha2afu5iZRgHIXPi9YP +tpMxAA1+PqQHhqCH+dmkAcHSPVTxSIRpKNKTwvR7kBAXDOTrAKfhdaByBEPrPVO2P5BgIo3PtNF2 +8jxnCuBxF8x8F3hw0F+73NGcab00OrsoGDGe+eAd12yznxVMdagIIOd6uAJKESFEVGskO/UERnaT +4XGY/I/k+P1SRZBXCkvfyfh1n6Wjt8zI97V1qu7jhUo/FBPdfa4gL0v06vwqSubR5Ij5+DzCA3tT +XFRu3zlXyc3n4f8DGlSE/87Gy09SfUNTKlJAlfoPeVZXeZSyWBSIwHAPGww7pzsilJgaR6GcCUpM +vobeuhSrguwUw3z8opodEhG4yM6yZcC3MzblKwCeV9xTucydZc8XLtfRYkBXRXjI0ViGa4nGclO5 +oKVhUbgZPSxftYT6hQNq++2P348//RXfSXFEj88whXqxBIe/oB42raN/OFG3VFLg6pL/9nk041Wd +PYClCPZhhQTwmeOABN4RUx1MIE3C4ArJzRlgN43IQjH88zlTWkeKoAWqwDyXKHKDHIeKoVsBBQsh +uLQq5h6IlfPqbnt7GSH5GCbeC220JSYwBkpjiXub0Kc6seUOdptJMiuvjq1gFJy/ddRERfRUEH7h +7N+Hs/8qeY0D2Br2QK1jIho10ENOU9m+xt6092O4khU9edPO848HQTFfvZKvruvVMfJ9RBVrR91+ +C6Jo6cH/FjTotoHCSzwpjFDn5UK0yEbD2TKIMIcoxyUXc46n/joRJVsXt5mvo8InfjF95ET1es2l +SsylaskvMZnoyB9SZgs2oqOx78QqvxjUsEwhuocBcx8Q2q4B4/9h076laU8WChqOySUCt7EROD6t +tP9iE9Vfy2TgHuls9r3cDV9Bu+57Ybvug9GzzaxbZ8/LTlkAQMPr3piQcQv7ewsV2T7zopbLs1Pb +nRoNG5XHw3iy5jteiSDeBe4gx1Eso+y7TCZBDxK9JNAe7AGh5rCqI+Ywn/dM5N7gIp47FsXMwGiO +lEDuAhzi8jaqzzqPp1YkBRkIBbo0BMbszPw5dSvrGKp04z3RpS0S8ARfIF3MJgkILbEStXvboU2T +8BPhCB6XHqeT/KT0PeR0o1ZXn/Vr/Pk8CrmzySdKJZDKS9P8c9EddBz7qa7taezMjkeOz2uaGkDz +9It8kSdglEVhVXb7kkKYNY1CWCAIERCXG3in8/VFS8wDh+Ss/fwskgA6ne1do/aPVyKUZYAm6l46 +6QtpCuK4C8G1cUg8QvWYKfKNmCne7Ix9BQOGfth4ATNDJW1G4BjYe3LUIFC5GdV17Mm0Y1+kOnxQ +n4Omor3JiIebNGKV+KZvHFfS3/69ca1jHATEsmDaNvKAqveCuTIdVgYUsSJ8cGIKNMf0dSerwwuD +P+ljBA6A74VpL/d8xLgLYAbFRdFJQeRVp9eOZtJ8pYlYWfEkdCqHbv/MsLmnLzRAhxzU5FJw/ZF0 +2aNjdqSOWGUfZ+KRd+y4H+VrkuY5EGiRXHL/3V9zSIVBu0BjPWQQv2j2OFvf+vfGbxqoNckPtY0d +b+pgobU8ASNoR3u11SbsFA2mkgzSFSaqoHeEWtMGeXn2g4kjEJmjNMatlIsBPFSs3n3qyP223/IS +aRFVoXkyBNSrUvgc5TGVXJBRYL4LTXx83RpnzYhasTKou/mqXQl53eVvnTGYSjtP1YVX4DPGU+9E +S/T/daStSlQ869EWsF3LE0B56QcQhgHDx6nmiMLSrKXX43ExQahuxi9q9cUlkyO3AJsU3995xd4+ +h6Ijds8QgBJEL8Yk+cG/ntH8NWsaxApMcbvkmhLBoCUdfOA4mvwJDYaBIs8d7wMY25EfhwT9RJzF +osDrqYw2jWQmyviJRTdEfGS/6Zr1I6YwFY4ATZTrRlTn69z0URIV8sF9yxZRw0TyE7MUhUTKoVPT +gbujGyIXB/FxFdXLaW0gUlZfmRA8dS/FO/crwSJClF94R7H4GfE4caxlepzr6JPfkA+OgLrjDFCD +7T5iGEuBiH69q0ppGs4iWq49jYKZXk1SAAZLsMUZ2KBDUVc8K0THU0mr0YEFneLw4zheLWwyz9OM +dhwg1U7YfAlif6HmbcHgP1QUWR4lzJdjbGRefdhCK0VWHmbxPh6Yka/hsvM5GS3DIPUZY2ETQSSV +JyjgrgisIipigNzPdhxJKBmACxmhqPxEF7J/nccxf4dDcJ+ooRT+tc5hRMT0cmySrkMY4es6OlLp +XVkkO1KJMIPbj2X5OtHLr78gJ0RMKhnrol1WnTe78NO6YiKndgGJNNoFYjqh9Vy8L7ueJ09CeOAL +CjmvcGh0ddhBe+l0mjZwDY9zJUn5g7IBPeYiQ4Xc6TIJiWkgUujlFwcPCG30SF49dug7Akl6tfDE +3lVZjF05d1m5z2GS7kug8ohd+BFRHxDwSAPtv85avr+l3VQKt/BF2P4zHo1uSDusDqS/e/ZzBI8s +G9giEC8DCa6E15vo0wwfAvn23t+Paq3jO2B7V2DnhSkSNfHObFWKEo9O+5OKaD+uaoXtHWV8XQ5m ++Sv0cuUgScX6caWYVxjHvkXU9csSYucCzi2vIKIkObzKYPU0JlCmGUDkSI+0SJtUKOPY1lXN4jAS +8BnAuQFuAvm66B3pwG2iGdyyicLtcabf/kIkWTWpvR1OjQiX81LwR3Km2XwUWBSYpdo07iVPtAHM +UAbMkNBPugorqBCsr+Nnr6Rxv1LcFrWSEQps2duh9+AiN4S50QoC1UYrSANN8Ew09cEzpfXxvByk +9bzYYrgjEiKmAqQfQVyPx9JlJ0eK+cixV5wJbY8TYaqOTmdJU+pwOdDMe08U32+jjrZZth/NJ+c5 +Uf6aNc5OkIj+Ps+LjE9Omcf7CesHNKG+eDMr84hGm/l0lJ5YmGEHOuP8taS47dMe00fXpP4c8TAW +thkCk4UTCR103dySV/do35d7BUASyQMrnTxtTWHxWV3IVhxR2jPzUMNE54a2KFmFACSljt7dGd+S +VTR2tb2ZN5DmRLlnOVaZefZNaMhyXENp8AprBws1jpeZXndP1AlYLn8BVubRPwewNtIe3M+xS8x4 +DkUvTzsqcgfzZf9wJ814X3LFlPnYV+wO8f84FvJvvb0P8UpJuV/7Ehmv58g8AQtg17mPfidM065t +xIhoD7K2vrAA4pX060fCYK8To/6qe10+9iWzqdzWrTUaxw0prtIjifmfuXxTB2pZrYdvsddS7K79 +siZzPRDFt0HjXKxF61hlK33wGnadEeiQzTNOn5+zlhJFqyhqh/arU+l81bzLUQwz6e2+3BGlkgtU +/WtlPuh+CobXOUi5if1MgI6o57qgnKWELrnHsRTxQ4raLnQuUX3QxR0QPY6Ani3bznr+GBG5ioFm +yTIi0m00y2oiIjOxl58x1teZLlAjqN/ZbeSbu04NHvtscAJsOrrs7fy0en5aDYF1ab26H795PGSU +8SWf/SrXdxIg8J1H0ewGkRdNs1BIYOx+BdDPjgFR+zmQHegaNw2OskKa6Oj73K8+dk+HmerFVWPf +mljuDNXJ4hl2qX0Juv02Y4y51K6jqVbY6SRCORKY0bQT+7+fuPalJXmdiary0awWiKliV7jfhEvi +JgkdOXKHrfLkOOI/8Dbwx5OQq9a1QGbdSS5NrQfmOe+lGmczZVs/KoP6G3R8l05inyu8SqTndkSs +09CgVXhznJxrQRiOiFzylIGG5teJHEaTyRYT+3HmIGBJh0dR8LpjCfXkPFF3Gupqnwjy0l2vSNDT +P0cdPyzi+q8Tadu1DlsZ+jLcS6dqvN/XOwchhZhBD43bA9PDLVFUB7SDojpFNilM2rxrr8lnF5FD +r+y3ZjvNNB58FDLaCHMhGj5UxKaIidgT0nG3tPn49dAuYUVBEJg/6V1VmHOCvcwIykY2ODir45NI +bZRfghHhI3x/JWNOqlXGtVKmCQKigFJlk0FBurCp8k0EVftnwaDedLNrsT/1VWwRBkrZ+BxGNaCa +GO5kTJiUup6Uuq3DK13hlbaX3bm/T9YWemzQi5l5QlGGpHcf5OdBbDKaCcbOEkiJCJ7Qcb+r8cXc +3HaQ/YP95a/WfpEu58k13QfXwc5Xt6kS9hYDJ158awA6GdKrJk298GY0sqPYv463lJwgVfdW3cdc +6c2pv4OJ8p3mmTUtwP6wd2qet/071339f6yd3ar1SnaeryD3sA6dHOyo/lTSYbIJweCQkJPERxvT +dsAQu43TMeTuU8/zlub69pqrvWloN276WxpT0tQsVY0a4/1JNdJ+GeVPoEpCGh7IKrWKwwnFYn64 +fOKML+BbuWKI6hR3WMEwZHYQdCtZobMDO5qSPsGDnCF9QmKu6wt7W22XhACWbVuMqLIX9DCGpY58 +V/FVt8hNd2wYtOMg5g1/G8XCt6Kmpqhzy0sbMZ8Iis2o8Vx1R8hCoe537QjKU0Qc9+eVyL2YanDS +JOrStv7QgCrlm0NwbD+3iYTS3NW2/q7vhADSR6SigU/lZlmRXxeiUE9haNj7B+R65TzixVHVc+t0 +K/tkc1uI5xqiDrvriL47xXe5w8xmQpcPO5t7MJ3bUwWbqmN7O9Roi19addwb1w6dDxSVmHzRsFW1 +JqjNgIiCyQqpRvB2YQf85D5ESb89UQovRoV3wYvI1u7evH82lp3OBIkf2QVWZFoBrIdEAuyB53XG +80LtiLXTqyWfCoRLgZNsUQVyry3qjH/CDKADfZLizrcmbdIt+LmAPYDuMvPaCzeZGWsavXqwyEp8 +ozV6SyedGxvgGDvfod7ssS934SRBx3xzp/AnYYEGbozsSH2sMkrIsZkemqKe/F3QK7qnaL6yxdN8 +Y2oIZH815WJoeu0UN0SNqTtO1nZjRHZczlzBChds8FECZq4YvDKEab6QGAuY92scKe4g+XdvpomV +9WJTug6ZNvw0rBWVSs35HRyUei9j7zx97J1CLuMVpNvYrD0I6XT7jkfcCj9ideCfJA== + + + HNoe0zy0PdqGBPRN1rOoC0T0OT/7mGsnGOrsbYsHDrqgcbAo0npNqQcwaKyMrsUebIkR/pmmJH9e +E0jUXcdp0wAw5IM9pXEgVLAreQ0SW8jsmgEnd2mbXIWsNaymy8TGd64X2I80ZIrFWCjzFnaxgshr +en9lnEQpL0NZTfHKuX0n13dfP97peaK1N5Szi1GbjeI7SLUVoBT6CqCrkADKhgS8mH70HiOz39y8 +CK8KG6Cho+FwEVmgd0h4Zta6VgSvYCJQhiq64eRCzwJtMxB2G962Y4b1rOhjjRk463+jJMOLkiZy +n1oWhKblDFfqOCI/ez8scVqmTGN08o7Yj6Ahi9LLoVAF4F4EGCue3uKN72DyKhtpMgwojJmiehSv +qF9RwaV+hahAqk/XwzXdinfX8VT0dZr0SqF/Dq0OXY4bolYr6BSSoj+S3ihr1dpM79O6zHrnjudR +oYxNa4b5Gr1zKIrRIsEzvWTqsFFcGFI9fTzlAlm5j5gxDLWC+FJs32nOgr6iOTsfPU52RQ7BS3dE +GSC+mFDvdBnYjkwkrMCiABDY+K0q9WcdBGIGhW+mLdGQn9g/zv14HVBnylu4cpNmxzEWJg+qnSTs +SDdG9/CqYono8yzoGkaEX/2sEhyMkDAy2ZH59JdtKpxFYOgSGkZTa4agLwmu0WH//uwiJvh9rnK/ +LpOFhO3K1TbH+9wc7xaMvPrPMEjr1gFI/hUBEgKEJCMAcu8LIcFKBNvvfaEenZ3KUJ7pRyq3RfPf +duax99RV88nbQZjUSqKXi0nuhMrqGeZyCbfZqXFfaCvq1hZ5kRRgRwqw89hPZqg3QtYT6n7OM1ws +YmIGNwTHV6kmYDNcPfT22iPsDDKwgOsiM2XnwTutOg/LCumHSgDnpowfYDeqTkaHXBZcBGAwnVWX +82f9M+nBZS0+nRQ2LvtdBXwnq7awE5DMJsuSgpWnhyId2M1OuDlFlZMJAFVOJkivJ5OK0Qbq4xYa +R4oW2tCdYUCr+bwS7BfHLIk7lL8tf+EWlcRonim2KmHTD+UKP9d05g3cacbm0kUhv1yBn681XjpS +w9EuXFF34g2RfHq4yNryIxVM8SiRzRZPcJb5z6W2xFlwtr0NMQMNudua4dyoZMSojpbzOl1xIHSf +rPXP6UKzWF8/BhotaXoDu3psIrPqpuhx5cJTfYkD0ZOSgH1H5hbrABKF+/xd8162AIdZ/7mbWaI3 +OP84dHVFIvSUlL52cu6q2+DNbiFT8N7Yp2EiGM82c6VPxw/gSGc/ySZ8X2qylImoyTLPqt6NEelB +r88xM+K10ZBkI+DepAlaXHeKi+6L29r8tP1WkLuClEF2my6oNGm2+mtHvkHUAInUEWfxUIrokgh1 +ZBFGornYS7+CvAd6N196gWNj0x+ZMttEV9pEAnjOO3XwAxTDmfO4laTbDmoZEDU4hAO44QiMTUo2 +X79s4jaMhjlEVZ+HFBtQNWf0hKD8BMEpC2RNFafulSz3Ev4HrmJ+JRC2WGd3cyk0KXS5L7A3+out +IcIHB+ppP/1I3buRB5fIpkd1klcqAY2mMtIWNXrl0huPpnVvAnQOKVhf/0AVUPyY2ioL29SMlJE2 +tTMLvh209hrul5ilI0JmrWymNVe6QzcYcrHp4h3qNAFof+ghV/AGa06bqtTwMKFRNWkrI4qeTGFr +NaOu6gyY14MUDZIv0oJDUdHtxdWT5Taw9fORc92cg3LsLdm5VVAbQAKZL9dWDdYf8PLHFkIPWKop +5rtpwbAzh9TAL1ovryuJ+lxXiiXnneri2spNioltbN+rA5rEGVLVOL5B5LEAKdJOoxPM+s97vIWm +sVLisfX7hxkG2R1f5dzYEuRxpBQeW1ATJxWx8M2pTEY+JT4Y+YznhyUgffNAf1Chq/kQSE1TwnRh +q1eY4Uvo+VtY445DHgyULnOEWToultF4W+P7eH4U5B6F969J4KyBtgf4JWvh9rd1JT8w2Oqx4Io/ +5WlJWcB+3j7MyMEzg7AWA3ZimbSv5MIKyhjhLXn+10aoTTaxYVJE/t6cJTR53hjgelJegPrytCle +u7zc0Uh8zm/xVEn7bXamLWUR0hFNe7eQsLgOix57slkRGIAbse9Ao6xEhLS70rVHyJ9siLYpjTPR +eERFVD8sHMS3+r5P3jUQMpSAjbiSz1qkKYjdvKR1R/bhBetETeDWiywhoke2+4AAqBhx2RC+SxZp +FHXZW5BvyrTgyT1kIOYX0HG1xoWiIEwMAY++EHgQYD3BkAWkBpWFzSp3oqWoe4tHgHRuO4epjUao +7TSpWFhVomCWQQJi/VG530L/kJfvmEIj+D5ZBFGW4M5WhEJUtDyg/Py8F0Fdc4lC084oBjNR69f7 +q38TbpsFOVpyl4cOTNOY+iL0iny4RP7trrsi2H7FzCGct4OCgi+QJgPrb+C9Nu/ocLOvQij4dtDW ++NmtNyiZAmmZkiGi5e6PfmycA3ulJoZ15fxPFQDDKJJCZA2p+lHJvsYe+vg7HuDwQq5wtudNveVL +lwh7H3nxohxZ1G28kKbbE1/ZHoHr/1Q8Rom1qg25Ju0W9Gd2uWSJXAkgJ3VIZfS3ukq2bCsWZZTv +pZegpKfKRT9sQ2bOEFZCwZtlMqPSFAsIhhaYpcQeQitg30ufGmCbNAD7Rfc9FwAnwhOpID2fXtdx +RESjbfE/3YoqHpjHuWERdECC+v7rvYeValiRvLfxdW9OhLZ48acTQQKwJl0UkImh4UfPbP3kp+6+ +54Mk4+HtHcyM+0jFD7o0nUoVPx3DpIF6S4/gnk3tIiuMpBUOI99rDRQXPWaIU/HnFkL1WPd3PAof +LHyXntw4DY04olJlYrutOFnfq73FQvovsRRtuEPGjUqWI3g33Fv4Ntsmjwb71nJdc7LlonWN89Ds +c00kRhU6qLsTigMg+VvOU9ILgxWo5ddvIvD+nHi/f/dHve7/xBP9hol8/lP8z3d27tL21osAI+8c +JGyktiAu1mS/tq7bzRDenvMSNUOBz1+iZOU5KV9xKyORmJsWOT1/w0XUA9kDgad99m7aXZXA7zES +i8hAEiflfAok9J6ZwZRIha9z07Etj0KR7BHXlaQBauElhrGimhXlTofmMqpG2p3MdHqeJpKaZv8d +UZVyRux3pCZ5bVcHznHkHGkRF2ah/rqSDQY8BvrcssKaTGACewaTLw4LdB1Y80BYgGQWDM5jqCEt +gSa8NUkitLkpMUDNxm57NBYUaFQ37iHeKrRNg/AOgm4Od9Nb/O0c4Rkc4G66u2CWATA35/Woad/Z +M4ri8Ab6Rigc6HHFHkl9JOr4dsO+WkyhBdFTl3JCEA5mQ3Zzn3MlKr+gCI8ieyWYCx3VBmWCqnB5 +RihbIh0KrwySTgo8w6Ed2+ksdh7rC5+PKyxUXnr1d5IBg5iG6SecFI9ujc1zQFuTmQmBCJJXIsYh ++g05d/1TmOPO1/lRzSDK3cEx9/2vUS7lnADUeO+0LuKi4IOdVAd6bkWM5Nx6GxP7w2ftpbUHz3Rt +UMtG0Tq1dfbNJE13lBbWBbCiKulZu+TgrrTWxi4yT7dLSKfXe4RJQ0luTv89yIWvp7HeiQNnC3iV +GZP8B/AF9JP3AHjW4EiwXt3IpbcganviAsj/VyLWUTXqIoDpcQ/b9zTzumrmbJAGC0R/Hcjdg0BB +8oeUjHng+ZSuN4DK0IEOejgMs/UzoTDJJ+0R3bHQFdizK30eQ0kQrDjaBRo+BUDDT1Xz6UEh/GwW +3ogIEGvwI04j2JuZ7wB7JiLg4QGF4PP+qejxmovO0si3CS+iOb6+x22jnAB2g4mo8pMA8BcjLr/a +2kdrPMmFoDVwoadj1xmglGdv9MXvc+OrQYWcFIU4T6qOWDpXs0WebevfHOBczpFUpTf27ZuouqXg +mQzWfqULFYcjeQI3DT5HqtPAP+FgDNy2FfWYBNqciLYjNtOlV42H3o51eFeURtctDIhvoHLsqaEV +SNb8HvHtUH2LquBftb9ZOxpkACCQ9qpy5I0KCFAQKodd++BLQNFpStsOD/y8XwGN78G61SShmTvX +9F540Zo7PnWB5pb+t8C1Xu/r3EACo5AAoLx9jC11tSUiTgrtRpy0vyiAK1Z+qn/PAdJgDqy7j0XN +8bxJmh4Vz3tWalfQb6e/xQHIy4/TUSJiYyDnBosyX6wtMBHiXDgQuXRS9baH+rTrjbDQretX6xsn +f0jO9JVhPPIyT616WNT1JQQRUBmjKaBciJvILPoakXJUKPhvB90OWqealieFfaYArkR/jzGFqgKU +2zY4JNSilbjUR2ZFb3a5/PRdN4SEj62oaucdJsuQYljl5ZA5qSiPXvsjnPCvZmD/at65WTB/Gnde +fIM1d/oKJf62QVoNsaxhm1CztIO+6aLsNbJTOe9J0TACwHY5KxS/ZOdyBI+Wtgb7COZr9hEUF3BS +SVbNW/MwEoHDK1nMlFzi0CKAfYDlUeS5h5wEcpOiuB4u5u/oQqtx2bcK81p9gU4Toe3GgND7wFmv +HnDNipKybdSRj6vshJDatlEW5spATYO7ByUJ3EenZyJ0IKp4Vj3wpjtSbPKUcBkhfaGdPLR3DrhI +UC+Po/QYAAXUhSBMjfRrrMHJTe7gGa2p08SFfRksTE8tfe3ljizGXU80HF+uiJHryNFwkRNBeG03 +xQ5DPJXiS/aVUnhn/FC3QxKtqBeHwq032aMKCrWmFxrDpii8XgJ113mmdmf1MTO7VI2VCNosJo8h +AxrhQ32KqVqXBwlcUrWim6yWO1FzS2VTE0S3u+4LNFZznCRE1oMwVg+5bDhd3dBHHmR5BPO3d+ia +DZPAAyEZ6QJm0279dPo6XOoC9Bvd/o/ffmF+/jO+pBJMlLLFd6cHnBOdyDXht+zJIAre0jzXPbaN +HSIlJqhHvpqa1yVPBdbHxiC1YJDE74O7VTqdhe+Iqm5gTKkHvjA+xbw+vMWglC6xTKcnFgXUxj5A +Y12KV9TmA7eiW1v3Rw+BHef10AqoYgf81dgjheOuYTc/EzhH6mCaT1ZkfKjG1N0Xst5Li6r2UFfX +dCFj7S0ilaa6u6LlEP31dhokpBTnQJ5xhPMbqFClZ0jJMrIZa2BTjWaDi9sMrTEpeald1tQSDvoN +NWpksdy6KF/Frcx54tja9ES4xB+2L3OlCPPw0lPlJYI3jojyKurWXTFEU7g98jiqzTRfBdsg7rBW +IoXssOfpivDQp42xGU6dNkqulk27KB6kce6X29XIrET3BiYhzYiskFDFIV9T21Ftq8cBADSQ6Lu1 +36SAQuVWq8eDnlPZ2JoWUAywqteaauHV7l7ZtTnAWdTm7EUhnI6wzaEmfPi7Eq4K69U3xwXGW0YF +6vI0dt6iNl2PoptQMpz81JATz9TUvwyqp6ixmMU7fRdQK/U94ne7L6IIzZo1u/JM7+fZSMwDVvqV +eyFdzAFKG+vA2YJ4lGdfD7tC+wJvURC5bTVcB2bYPno90PSFOYNoDPGaiXmaEqkqvA== + + + 9mb6ZcGKOO27sG18LjQjbwgv/rwTdZ1NDExnVTQiPbX1q/NjaH+qcLJvnRF5qhMwzRkNRXX3eJDt +s2AfPa1JKbmHAz4SNY99pTt6cLhhROBUtvi5sXBU1UHGhz5e1PVHF3GP57JH68nuMA0MCz5hmqXX +tRuI69HtmmuU76H16Uf8FrGJp9V16JkNvkZBoxMG1Kgb5NkPy+Q6n234hQMEQC0v7RqKtbz/PQN5 +O14Xns9Zv/k00AdLV4JnL/uG9sDeDgC7pZwMMPel9fcexZ46wCa9SJWj8aes6aCSI48ZiVdJPOVR +QqiPIOE8x8sGuIZ8hnSgbQM2GPmtt7w3mAumKJAZCna/jQZkWFIzY/mJpLVE+nKzi9hXYnuGqn5h +c7nhv8FYHWC2gw2Lddq5BaBv/u/ynbVAuIbU0Iwa0QDXWzle+wJgtlK4ZyXaU48KN7aw0zlVTQWT +b0t2FHQEb28nLxGtzhKYoDaL9Mf5qMxysATeKt2a02zrBqFYbKD9wwy3kgq/5qVIsQoDbAO9r5xe +1ugGYzynH1d02QuPmsbtHauZYUdp7rbZ2ku6vPiBohvE2lvnrgNMRvihP3eNdmOkxLoQOQTJauwZ +glReaz68B4HUCjjzDoo3/I1k6M+5PWKHo5jPykaqbcJ2BJhXTosDm4ZPSfeyWDAsU7fxSLWg63xt +/9oW/1pnQYRY7D7DiZkx/FXHtTcoSCn6Rp4YflfbqRe2wJd5LPvhqIw2VzoI2dta2Kr0ijgjCnMl +FeZKonnqtqchQnmdh2mIlFx7xP31Qq7apK8fMqkg494LIAvcqWrt568hPNC6fsUludphn6HXrAPK +rOe8JVCczpR/bneJKx2tSN1TcD+TDChfhuzF5bbn2rLtHYnaGFarBVUYCE+LCfJc0cWXB1Js4xdz +WMB424DbBjcV8f3iXuBKzRZqOnCuSGhwCdji3oY5UZ2PVKt9Ojd261dCW8YotejZE16h99ucpZOn +MDWd6J5FVv2P9PrKpkBf6VXbrSj6nbXPK0HuJKru+8m0Rcf73lRqfNKRSCt1L16i3+726JYpZMTf +08tfae94zl9/Cvp0JDVEFtri+Bq28uGxTrB4zXQ2Xc94Zd8DkLJKOgJA6SGnGjV31KybTUR18TgQ +uwxjivpLZ28qlRM4s21dswdZ4prT+ff0EvtWxcFo8/r8jHxONsK4OYjmhebGbrNuFbbzjLGWrjl1 +u+bc89MzUYsvstszFRoxtDFUCLHJRksDr1k9f4TU2Ei28MalOLAIA8b8GuDtv3kLvp0G/0p6Kp3W +MVMf/rGWRe4LY7Idce6I+7FBe+aKLwcFQktqoEZ/xatQ13EYxRa57GAxOtaeFlVE5cYVoRq0e56I +Y0c85RrFb4YuHqMKXQdbeiVKcOg8Huu84Pm1beAEa1TgP/AWUEa6UFU1zfEqPfwqSBuQGRuQc/8Q +2mk0WY6uJup7IXgmwc+0CejY7tm9RTwja+qisx7f/C6KPra8nEaCqCPfmd0ZfiTwXqTyx4kRf9/u +qxOm1Hoij2na2DA8+f53NhTaVVRAdJRxxrHf2yNs6Eqm4p+pp/PBkGh2u4DjEP9f3XbbtO1072ZU +HFuQ+1RuqISTvCLWdmUmgi0ZEQIV6bg6ls+hv61XCgr9RNr1s6+vs+DJDzSzo6l9A0O1jlUPIxAU +6n2MqlMphh48j/nCRn//KiIXmDEgW6ef5vBEzWtHyQa/w+8BAwQYiRtlz0juPUQ8v0fUAHPFyjwq +X+9R4KTa5ku0aErpWTZKi7vGtVOUNZS1bx8rJ1NuAn/pdr9HeCEoMzBfgUYqV/12nt62HyR52hVw +j9M83/khyf864qHvwqRCCydX+hJVbRHyldZboKLL2Gbp6sBZ3dwlHaR61KVEwo/0piF4oSXcl4jn +DY2fG+Jm9/3NeeYdIdsqdScrhpJlAAr7dxFuokrcaq5aPgurd9ibCN87o0RabK6NxPWUzccum2dr +o3InkO+LTjjGp+j/NDtq30Tk2fVgkXDQ1dLt7TyPhCd82trHzri0n1hLV4uKR+Ao66UamlWVmHwU +5LzHp52Le6a2zShJNUncOipHbR+ooPTXBnsInjpSl0EFFIPPGH+MGH8cr4XmiEldRwj4DCVPiFBR +ljDnESCH9kbf2MhsZchF73wD0/IuKDdXimvYyZz4CC72KBwjnO9vUcUbRltzinlYMwbYOd4h0uj1 +A1yKaWEUdKirel8ivIyoO+Kqr0RFuBYgJSBWb1FqNyS95EmdKnUrA1bWRFhNNd4iSkCpKA48KPz3 +qJ4Nd62pm3RyA7H8M0UiPGMR6+WbIAnON7ldMlEIORVeXdnZS2VzZF7noAZw1XZkxDIiigNMfqvq +dv3ZENjYchosNUQ8YoKKmMBRGI90ilGgPMhktrmKJfbCS68Mz3jyV+BVuZJ1XdQYU2/f9Q1/lGtH +WBJZiUF58gzZmew4IJhRzuh0Xg5//lsZjlKyQ6Aso9sQui4WnmlUluubiDGCJEROaz67n7cohUFH +hEHLLsNXeDaQ18/vXHlqF2n5nRePw5fnyO5aZXGCrMLwIp/RJ1K3E70YC48jm+4C+Kyk8Ql0I/qY +PuxLYtfPexrWxvAN3rj+0GDSgmRytz02bZJpvp6Bqt+xHme78x7wu6eLd1raB1k4vznNfT3sXIgd +I9tZakxsZ5kl3yO+XSO/RrGgxCxlgI6K7e5DL5XAUTfEPKZx1G0nvkC3SW28jNcYA0Xz825mpMWA +lDlLIZ1b6vCVGs7DpUdKDC5914x4fRVsWiv99RoX6GPIylLbMR6Nck/RvW7tB7N7am+8+zBZIZ9R +moFb1h8tyR+JRG8R/7IrSc7ebx9vZ8oqKD3cQdC790HUF0tk9K5vIKQ0xtkMSS3uTTeP2R97JaPa +jtpfL3zmFdX0NzyeqhkmrveOmDtCy5Bj0w6axj47glyusT99qm9kjWE9jdR4SlSdoDrL2dDOPOw5 +/aXdktT8nd4HNvaiaInQXBjLjfHp3ySEsyA5s90178d6sfggTkawB4aKCuuNlGeDsRE/+hpkcUjE +4hrJUSyur+f8j+43XcpnU6Tl34BSlbfHnBZ5/EPO2a5ar7FT1c4/d38P8vTZt+6bJVQU/7ZVcNNI +F/sJ2BgzljgTt5oVNTQOhZCKEdGKYLOzzxNu+2lyQy9Agl1XZvI5rzPzgabYGUsgpYYr2lM6jXwT +oboTiQGtWs8rzmAGrihxV7Ioq9VTyT1r3DqPq59txBmy6qSBGOitwQV8QTuetvRwH5MrW9CZSYa3 +3eeVpXWoaz8ck060STDplJ+6AuwpFJyazy3+aX3cctL9XcS6EXrH6K7OV6vmiJuDUQrS7QI0sqll +U+CivN5oe0SnK7hH1u0aRr+pKu64UygpwEIa5HeqFAGI73waWrkrDNVGpSSRgqMz07b/DjVTodKk +V2of0dwum2nCokRWRpmBnXnApuu+j8ezo5V0EssZdW6j0CYmaxAp3kqMnFcEoAojLMoSwapAnunN +nqxtOYPISOt4+zLH9gDgHpC6oYBmznekYlxQ/b5y9q3wjVZ0NcJBV07V742Iig3Q9fmI4deQsvFE +PlqE1+i8IIRVpW174ov3oV7ShBXwm8IMgafZI4psACDGM5Ajsk+d/15MrBWlvgrUMLPMuXF0B8pF +MSPsMuhllAR+pAALe5gJARg7xcty2HHq3c2tACNZEYoQPReykmKPquRKU9Lq7Y43V6LIzZXYxKrH +hqQVemxj34sVLrxozporBWerfFV5/TpyZNYjPpXZYcZjClxTb9dRk/HHsy1rHpD5MLZ3G6UAfSCI +CKcBufnq1k0dN8bVq337dh64rdYL6U3sn1vV9YKOXgtbfd67REnepsz1eP7uWUE/KnNSYKier8+g +SyQJQaeDa3O+gT2h7abW/dcIDFWKdTge48NT+Bo1ztSj8J4m/WYDnEIt7tNKM5atb4TBr2Va6EE7 +65K3tw487vIanzJkuHsVb94+rgNn1OdMnRwZrfxw4EpVqrFfPH8YQjN8GoXG1svswgKSYW4eJ7tg +Su6abG2kKU8SpFDKmscPjzl/UkWcLFWX5HI83aYwwSR5Xyk+6R5SZW/uj77o60ld/BuDb51uHruI +o8sRzW6zsHMjNymt2oonourxOKMRzYIiqR3g3DFet+sqU5kTBP2fm9KsmMy1yVXKCE2qrsEQeR7o +ijMyLlY8vh7I0/3K9X77OAY0oM/X4xqaLYP4Y5pCzH0e/ZsIf8eR33GURynma5SoeyaMiQPpvW90 +yzXqkdmeHGiL53Hgks+4JrsHU4PZhJCXNS9eoHm/RvmVyKRBVfU7P2HQSiXtDMyn7hFhaqYUhaln +f9SfxgZlrbVEPtTcdJZ2tOgrgqpiSV8XKNBq3wvfbxHjisUQZesHuZwotp1EzWhqgkax0i0ZBBGj +yOySiQaeZb1YNt188Ap2W68jLI7jkVRb3+gh8ZX4W6KxPo+nHqLK8Eq3rGauebp4GrSCdh3jihC9 +KHoaQwqMKz/aLaWsAf55/mvXbxrpIWSL0fLxSB+tIWAhHjSvIHymimtfGSQkrLnsDI+tbVxQYuuv +F8P2IurD1RV1KMrAoHFeqWR3M42WDf8+aCF+E3F0zX/zRn85KLuJ0t3QPGJubIuVYAvKRSsT5BF0 +g2nW0yIyMCGl9PeIrCLn1m6KYME350Hbh7oh2j5USxHLsy/5doCiJBnJGu5r3DxqCF+i3jS0afQf +sqSh9V7i/DcGnU3YuQ1S1NFZGygmh68RrylEGu+Fo9v5zXkgtNI3lXpaQqQTVIiK5ND8s2vgkKc9 +qk97/Wb7AuhDzRykyisnfyPVxNwopeV5S1QmVnJDnSXnNUuZ6o4Y0RA4Jv0pr6mppwtTdq+MKH04 +LfJeOU/AdisLBWpghCy+tSwcJfeiE0IR4Ru4qp2PYbX/sQi795Vop63FG3rdiOsXBOp6NPPNIgyw +vh9QyFBL+Atrz2eVGEmTjbrLbpqfaZozZm2DTqUNze94W0wiOlJN1wZ9JDeA3He9R2RMbVFHrEPK +7N+cB64oWEr8/5zMa9v6oIj9XQG7KfpRNzO1g6qYm1WKR0+Jf+Np1Qn10xkwLnCpbfEG5g5FpCMF +sNCE1g5Uf7qxG7W0l4TIUlig4trRQq6bXjq2nQmz8HVE6VtBGBpd9+77nrGkAgkTRv8BXoJSwdyG +U3gjE/EarGtxCPiL97q0b84ztySSL2vbGN9LhC2O2O8B5aG1sq9+foq3oCPyypgEio6ZW24K+vSc +m0/FqgimUBNLvtA95GkPYDc8qKqD1lwbgfFsqe+09NAHQqDPKDHJa++ue8nJ2AnS83DWlyjEjI2X +Zwso75yxE03pCqpSCGYI134aqYXlckVDCuX0UfLxSSIAXGZuppM1BfwGrnetBYlthzL7a/CUB+CJ +S7c+bQV7MPm+Sm6jujGD75xBkvrC6o7g4F7TmniItwDQVmqPKj70wpH+OmhsYwDw2g== + + + utZtsPhhqyG/b1wYdFwKunNHrIE9rveIPK6x8bKTOvj53XnaJh9S1NHeoQUgRSJQrKH0TTadyI7H +f2D/uPB9H7WLnjr1wRdDNogoSptE0V//q30/d2Z/89hOq+9KJQecgbWei3eavI7eQKd7WcZ7BGYc +U/b7TWngh5rRr6Iu9CxwmFhZ9zlj/5M9Kc4DzK5qFaRpLha5zLjnlPNzVxQqOvxLyBBKiG16Ki8s +VfiC1QmI4kHX4Kw7Qhkr8Nnn+9qazPRr1JqqtFzobDFUhiyx0avbS9SOAIlQV+2zWh5Oej/I7+t2 +LBhxLJiPauiWwFpfp2i6U0uwZfTSFFTDo1E/26ZsTjwQfUWpcUSnH90LTWKYVdXpV/1WxsUL4GHu +1yAizfixwdld3+k6hTjhTNMUiANd090E6gS9xhDNGjn5Jr8IczSUkKtmYoK+kLGBMA4MRLm09c6C +FFTSXdrR2ghMl6e2rizI6kDlvbxHPIimADkGZeHrm/NQ6pYvTUKs/jg1t/Z5APlBe9i3sKGc9znI +Gu/yfAaBiDSzawTisYIgUQFUbXGtWcH9oNNEx3AMPeLwh2mH0JJJpe/nDZ5T6wtVhJ0TK0u+3i2x +vR0vMXQ/6uMmNlWv/vht2N2fE+Qn9/6P8u//xJMdONaPHyn1/o+/Xf/j/PiLf/vxP//HH79Y+fj3 +//H3v//fH3/xH/7yv/3NH/7wd//8j7/85f/55b/8zd//4y8///6f/t8vv/9fv/ynv/37P/znf/79 +//2nX130fp35N+j//5X/BmDWBbY11eI/MIJCGhLuG9Pstf6y1krrIrzQa6X5ULYphm9VLOcHtNlB +/kJVYaDlxi4Je+TXn/3UsPLH7A4p8TvRgQm6psYzSmws9k+c8B9ykObE+0G12NTvb8G287ZivYzq +mfAJiAM7uWSze5e4UEXV1BbeB3J+pwJMexYGvsP++0ZkWtzssSsnpAmZb1HUFPDHCwS/VsHtNTVy +oN85oM5+3cQpP9F3yyQpFhewMLj+pL51baIMuLK6Uh6A9wePHODmzWZ25uxRI24wivMyUIVXcB6N +KIXFuop6Hwh5aHnyVWIKitS0QSecgTfx2k0xuhY97UIZJpW1eGVSFNuiMymm90Octuikkqmwknhv +hV7gLdpPKm14WVJbWVz5UPGv1r3ZuOzw3AonUaEogYQfaq+slOXZ3UzW0o0XTwFGYBWfOkVd0M6m +qyVrTz9caCPTAyEuUNV6iD8Y0c2cLtaLc9oVQPhzA9QETQAn0cGcunDNzfWHIM8mJipFFjzKJXXg +A2PVU9mlrvsflm7sePPPTL0ZovtPKv6rtDQ3Kvi+1j7h/jxQS0T3Aak/Y/rzYE8FmO3hYUrxk0gB +NkzQR9SCV7iODscY7wcCfFqfKt8cxO5Tj2/8e8gN4PpSEKvsgWbApjplq3f2fEUqA3VLZVsiuB3g +fqptNVTfLF1nuI6gpK3kfGidB5/vMZr7qW2p1o3i77w92PmphPakHPydFgsU8PN8k45ORgMpLUwU +K97YjU8bu6yzIS3An+Ku1MJ7/j6S/xdmyqcGtY/Rm0EtqlCA0oMIrdp4DKvuUPSI+Chwotr99nff +YdCLx3g7dohhtoRPXZenenw/JI7ADMtHOZ6Z6BGll1/MtuSnrbHangNdIT5eWbap/dpzkph9WsDr +RWeLcCWNQ2VipXEXw5fGt15rzqAP+mBgUTb8TCaec2uqjkKK+4Hv2lE2Co2BVvUOy4/DQQCNIgAo +RtNasv4EeGLsAyRhHMC2WCrgHadEDTDADLQtqSjc+Q5cIDxc20ggW38KjYj5HVmoSk9achA17/e/ +czZRcvWbg6dmO/EAYIpbS9DxuQTF0BAqY9YiTO/LXriAhbFwrR+ST62fZi91571tEJsr2vcL5JMG +hca9hstPEdJab+OmJ1F1WHk95ioupwUTKuSu0XaKfl17vC5hNs8154C9gOW1fkaV1XGWR9EJ3Iom +o+czBZZAWUgSz2Dp+yZZ4wG+FpR8CD+xU0xaMEQnlmorgkaiEbeSGnRi1U/cqobAsa6t21Jgal4H +rm9rLanBM2kZsKIuRjQRKxHhSqPLqSSCVi0RYNSIoPxNRO13ItaeU2iW2ti5EiRYnuIKRX2eTQRi +5Jh0+TIAhQRojzjvuQF1yhwDhnNPN5Cspdm2llR3qMyQl9NWQ3Ngv23sTiI9J6BL1eSbfR38bgQs +1tsnjkLxD+mua2KniHhqsRIriLaXA/5GvrCez7Sn8oAvChKdPR/CCnDAoZ8GbKxvX8ujx/FwWcch +tGVVZ0NTVY58XYRqIDEVxxVRtmRf+DAjpENERSJmQIEMotiuLgF06Aigd0cA8jK5ThDFHRrGvpD1 +clSWXY9RUREUfKBusp4wNbzQH6MnrDXH+o1/4x34+XljmmLiA6srGZHIe6krSbcFGZ5/2FGoXLD5 +QW4wImA09yjDg6LwPI5vHDKUGhuPINl6ls0AmNFcCOa9AScPdNDq2IsvUXQxdN4aCpysLzaUBV/r +2eyeZ30ASPQFlXJHaGK0hhlF/iZ93SvdQBO8Eq0ZrnTtTlPRdG5bxcD/oWtWnePR6OiIQcKB7KnS +6r4DSXLlNQWeEzjFlYbWMb6JcBUDcKnIypeDJxr+ijlc0Q/BdIj97BruldZqQYHTYvP6aR+PJdrA +dFQ4eNJAGQoX8SGrBPzdRYlFfv2OJ4L1DAT+TmeYv48NHIGoQOnDg3jEcxDHbWpMJKseoM+ERd96 +Z/g7NDRvjcWFN+wRBkbMkKrlyjjtxA3lWaNW4YszwDyvOfYUBD11lXp6uJN1ZmzrUA18LnSj68fE +x+KIaWl8lU7ERMYPB8ghrCZDrtinew7WDQGmaEItzKoKlWFsNiAw4jYGkY5FpbbyfsCvhoD5nO8H +cdi2xAZJ1w17B3VQPg9gfPw8oNffhupvPIf4LPUIseM9j5gKbGSFWTBg0ubqxIxin0Xt9BjIqhPf +T9uI/L3tD0XY+8TH6fqIRnS8tqqlbYruu7R9YuDXczDua8hmrVTppJgb+aN4pLGiXZ6tqeQlBVtX +WeBteW+dDoFw8o1mLADVDodUH8OouXuSeJmtqfp1QGos+++WicPTvQ7ekUbttjZ9QBd+oFSM0ic4 +ui5fU2fxbw74Kp4/KcPydpC9oGa/6B1o3AZtdHz+HS1LDW5hDG9I8edByDv0AtbLANGP7o/KJbKd +u0a8a21oHzdZaIkuVMO8p4Oa2WbY6sGdKVDvH2INhvWW3JgY1G9+IcVk7jjp5dHh0bGZtkX6KlZU +VfFov0Pq92uXhKFGQa628kod4FlSsk4BHi1j6qZVJ1ekm26MiLYZ8q1xcKU06JWqMgaYszsszqwb +621cO401VeC8eAB9n6B180sfNjWaJYV1cbhCaISi1DRtruSLAkh7XMuack5EVVSIjdL/sUPtYCFp +0DqgRq7Zem42Yd79Cg5iGDGPSW0ChlRPBCDZTtwmyxKFBvsNC+fcbEJt1brauM3zXLRtVgQmTEbE +tE6hu9wLafOb7F8uAC6ta0kKSt6XQtXXrpfbR9ErcU252O5CSDhYQ62t0169P357tX4yYY3TWEjX +bq/JooPnfGjNvKbg9VBk7KIOMnz5atbOe4vwjWNdkadNxtbo+K03ZpxZbmXJ4kl0+SUUt2WiKGhA +GSGpbYC5fCDrDSdDg87Wc+O6GRB0auOoliYYZbotZyJcgmD/l8xvJshEDJY83pBip5xJ4qkS16z+ +tHEwbNIskX3XEM5eciXsf5gDGN1EIPNCBO+/EeRgRAzU5M0xkJZeEbgB7CutJ3FJ+lxfoJ/p3IPC +BWgaGD4b2OGL1Y7t0oy9LC7NFwzMolAcUwjvoq0Sq1BrqNY2n+uoGUqle73k6Rqbia73GfGZtFXv +GX9LDa+/LpkWksVdTyT+m99w4jKDhmF7aCUUqqfu2kBB89OmrzB0sf5IKTt/v7Nukbn556KL9THt +UOAYrrGzxOnPsx9x3Z6Ckyj66IxOyquvIexX6u1rRENhdzUZuT4CTPkeh17Kx3AXjO7gMV9jDAV1 +7+oceb1MQREXmU6xOMc4naOJcIYGYfE3W8xvIqyrzdcP8euDSL0cUqccWAfsY1vTMwwupLHA2iLR +g3gW2HxeFfby4/omwmnioqLBYOvFbfb7eSZJXyT3hbM0NAFWMkh6tvZi5nPXFNz3BZnkxB2XGJSo +YxQocVX4HltwtrgImLl56chpxm9CEG6j18cmyeQVWeOqPuJ7RMoONKboYK+4ctT3KH7RI785VbMR +C2lyb6xajzq/ifiKKX1G16+j1FeJN+tU9wy5ptaqbg3i4SlCU9alusQ6culierDRoj33FuA3QlgI +T4AReOz7WVZ6fwDBGWCkrmv3z5VHbZP7eAugH6TXMoSJvXt4jxKc4fuEHxfZthdGao3BWLZ59XXE +vJpKAEkROkvYmpbxHvCMtpNt/hptEAu/Oc2lYD1Ypsbi4ap3q6lWkbO6Yw/KnDxwahnBiaTpz5ux +BRSNYhIi6jij9RDcQIuTsxGHMtcFCnhEFnTuxdeQXeSlSctJRD+2xgIwAiBLQCqfC60li31HTAaN +EkLeEKgdnqYOUcBYk6YRu6XZVipRc6H1FnCONXj2V0oa1aLtkit1INxE4bNbM6EUFkPcUdmgXyhV +sJdb/3/5pXFsUytzva0ZdTwj3/Y6345n0IF5Qeijs217D1I+HAQHfIM8l7oNYFH1OsZ3EUeMF0Fs +XPt1fQv6Aj0qGE0emXaTmFg740uidH9r6n3eX4/nUV1sg9nt8hLWt3Pgqwg1SoOb7Z3cXUPWiC/9 +24iZBkmvaE/sn+QtCq1NQVZrYN1n7va2vtMghkQ03xpDWxMPdaaCFmH1OWBw8h7wvKHuNN8+PZQc +nJhBTGu4dFO++TM7nyrlI0WVVN2+Rh3bVgVZ5GJh6dxjjj39dFFR/QPxs0uJRjS8gz0ETPoekedU +EFHoINpwDf7mPCQjh1JgJ6SPnZGNnZGJxRrZKwKYOJ4kAkvEM/v4WuNWnB2ymK04PZ8UvthT2dI8 +6v6FIvWavHeoUL9+3mOfgxqPiIy9uNieH+RfVPS3YmSm/Es8AwayOKWt4+whPW7RqqO3e8Qrmsze +M8hZQXPy6QNR/G/mYpmMGMH+EiRzB80V4AAlidhFvkIB5DwcNy0yIABbSey/Hkg60Xlq5j8w0r/7 ++Mg7Q58pNgH0ipjRqcNtk+xfRyR5aEkeHjr6e1SPwNzAOfdMRgfs0nxwrXHWbtxD0bZWMxlaoU7I +oHMiEKoDzsCC+iU6c+z8jN6jM/q5AbcV+f4nNT31u10TZSLUlcdq+VY8CG2X6IjexWkVk/n2uoDz +P1HD+XXuGhOKuPs8Y2pQHpCyttcUWVCnrdfzo/A01v1D3DCCUseKeCk+iTR2PzLi88rPH5dnNo5X +JmGmRTZPoDuyqlQXysrW55sI8CfUGdZyhyV2rvQeVWJaNwTpZROGTwmJp2XzBwplaQ== + + + QGby2d167b+/xu85Ql4Dd/YcFK/LfmJLdHJTbqiHJdNmee50+3NfiHj51VMmXFPZSsiTRd6qHQOr +xbH5duhZLKF9SmtC1wqcqXCtADrMvJrqIdAvsFiAF7hHsBW2Sb5G/O7p58BLpZZtq+TtPA1jn5Uy +Q9HReRD5LclWqGn27yK+W//egtQ04Ec5AKGuK0PaHKCB6HMzPfe5TTTxdmI67lqc1XWzA9surdx4 +zoiL0d3y2dEaT5l7bQNcRNbG/pZewxq1TkPvE27FCWaOzURHr5Lklv6JhXBaqxdwjKuYTuEyI7q2 +gEDaNRrq6WtonyDwkn0APCu2EfENLOruvA7YytT+6sR5Stz756egmU4k0m27hRvnBggQGzBMdtKa +GiDdvetE/M33zr8p/wB/+TTYyld75u0iWj4H+nOAwlQxBXxO16I3UWPF3otPgU/pJu6BEO0a8lUe +gHCndcURCwwV5Txd59pntBmk+eE4vLJcGKqpKKILevHvpkWcHpN5vNe9e66Q2HQGxMJnjVCcv/0w +KhkOjwutrosOaVwE9LLQymdlLp/V5gssrwcplq6DzHwgZqlS+fdTlyCdvzhwqj3cqA1PvSGvR//w +dDcfmJzahY3614d/PvLnKG7fJ3Lnnsy2Kx2WU1hdcmHr6gA0aHXgy+xelGLcerhsHxQLg25M37LN +8yAvWpNq00sUsQTWmobyY7CHLC5CBe8omDbVNycwJBwwo0lCCQndJxaXzwNXYM/yqDbt6XVwUnjC +VPFAZfFDtrDYnjPVdFydaLQUKihH0E4VsfSV3lwUyVJApVGH8C0qx7uj72kxNT3YPRwgP08oLZQN +AlFymmB65IdaE24mbADRyjDCdhcitSab80mJsaldswpR9naIii4RJtcU2w5qV9eh5fKp/uAuScKy +YdksKgjyIq8X55CKdsZJaEWgEve60qBpBk0a45LcT/Hjp754uJVd/tvVk8Bw38aWJaiQcneSitHr +mjdgE51zRlIgFPiO2AsP4IKm34BZTkuZ9OAo5VT2dnA36EgOgAPHxBHCiBu5jKqAwr6SHZOBpfys +ujsYxQZiANHonseqIBbZR43kgvTcqt3mWnUKvx93i0p92/dC673SmNpbrGKvahB0nZstn0Ez0A25 +c6HJWrcuZFnmDsfAe6TsQ/FLI1+J9kLMmpD25ycwgZrefAxe0be56ZEfoY+6Zauw7eYPB4C6q8S2 +Mrq5i4Kvg+OOS0XDSKvkF0UHhOt0+48DhCJUS/g8bAXpm9H/VqaE+/0a4f1S/K6kBKAKmMrezoNF +uKVKBNBreWd8vkecG2reGO8byv8ehQ2ceLs1jg/r4tTNio9IJfR6RUm5sA9mlTophaqr/yUivy2s +T2w1bt23vzmPQ4T3jGm1xYVcKAPrOMnfewDE3Raz5oc1+x5FC45ieRNbsO63Jj+mxWPNhs0cpWxh +YnQYLxKaKxxDZ81C3Xp+/iYX/YcrJAf13auuCStxo1YDPkxoB8J/urKXgIuapGiOd0YHwrvnvo6Y +Nc4wNpSGKBOAE/gqCw9348JDA588qDql4ieEhUYGKd1y7rcKMqlnCmVEyA1E7L5fsibHQ6EiyjIX +bTkaEFUtiUvr8tNmOKqUeqKQdrToGnbPszJSXt8iCxHqj7lbfY/Ib/M143k7DzQWOZKAXy16nlvF +C9UudoBvEY6Cvi27X2/616irx5VzjbtjjH3DMzd8b00K2dtoA1NQp40ECojWmLSorwG/2xAmuxQ4 +mzL1v58GpAuLMEgXzRpQDpTsuv6oCR76QrQOsMPUAuk7e0BAKEHMUIy5ArAHwi7IZQ4xLBK8LCRL +sW/YM74HKDXZttTkdgt5C6LBCYSlp9wOPpsUTSQPHR2Ake4H1vwwz9iTTxr9oKyP/vzgF+h9Wnm3 +0h1GKVMNSZ6NUNFPjCVo/fmKwrCQT9SCJ12qSNGdROChY0SkFht6gp9XyupKe+OOpvA9deZmTr49 +zwBPTYTQxqMFK7si3H54JTalsGUlxBNxSWbpNDf368LKRTq/ntQ54gAv1QMnSzcFLWVw4YkbGLSN +ZCu96m8i6hVKEzyq+nyltyhQvgp0mQhdTr3yQvTdVV3+iP7betOkvJai9OP7gd/tLKtSI2ArQVn8 +LerGRVTdsL4l1tjKrrn4dUDr9aclv/9UAm8EZAfWBuYl9Q3AvBuzyvv6QQYz+QknGT/MjS8Brymj +w1ID9TbeT4JIwhXzBjYpSDGwRRMgNCQj4tpy7YfX8/AeB12CqOkRREM8uj+oEaL7wzbICAqVs8QX +XTUXQKLsXzKCSxpvnEPi6orADYuIMp5nTRRT8dxtJ/WDJC0hS7xv+GQvP9ftikmXMTRUGJpWsDDw +ZKLAB3TGV/Sglckp+oMyLXvOn8fQCwilJe29S7M9v0YNy9qIh+l1BuN7HDzTtZmY5HNvEeCUfSyM +/P6sG1+jVKcE0Xkg/0bqfKdShHPSfT0qqVdUUsd6mrcd8uv9gCNKnNN8P3jBsbviVYA+NZ0y5D+b +AOBDx+ZR9+YSA5Vg/+eGRd861LI/jM4P3r+nLgCQeYGxoHITivIutGCdg5+MbHvcXZjSgDXQ3jlq +NhdjRp1gzWwAzKTWf/27m8IjCKOvxwad6hJVELVjSVjW1/z8+xl4bF1Z57kn7tdBEPEwEUHEU1IC +0dk35QDoZZmTt/rDbOcMhPypGUKy0PSCvwmQRx62+jXWZDi3SK78CDbX/r0oNtMffoQqJ8/Zpj8H +D5AcksY/jPxTjMvpgQjYM/sceVoPa91NN7aRT23upM8y83sc1W9IWVWg3Fm2xUZU1y/sXusPB1A6 +aQ/cLn/jF1x/E7UaCXxtTEDPHULHvvuz228kh2RGfDmIR0mPrI7YGvXNVw40S/a+3Hie6koZSfYd +USUIpreDf5VLrQU6U6ZdvkIraL0KVCdcCpBwUJ/1DFD580ALxETfpJ3dvw6OI8pcWqhdH9cVaPib +BCHLBpuBm+3zI0L2JlLIpgFZADYNYxznN+fpVwAlNC8OMdnUNRC7WF8XluF7xNflI9XHr1FYIIuW +RtS8mKd005G2ZQt1IOQdOqQ9CttJDpu6eHRotqIdIOmAAsDOovqEJkVTTAYLVoqia4yVbQog/Lmt +d8K2343kCRVXGD7uKPGZp0gKavBp9pvC4J+CjzJCZerOsZ+eYjpBzOAwgYefQkYlVPi1d5Xv9Ne7 +B0lOTpWYJq602QsXG1pv2AtSRl8bXuSS10bgSFobegC0dB0rD9JGLL3W5c75HpF6+JGtOEBqcRRv +59H9mB8DD3V3jGO7564Hd+m4/TUCBW86mbSaH0rvW1CPTFDkUS5lXrsq1mDZZkAFFw+hd2DcUVF1 +1l+3Sptj2y5jONiiZm9hqmyNGZRLNYW92TwiGMZqUEOSV0GMCgKtqt+Ebz1AL1mb7xzHAufwR3Jh +iRg7w3iNBNdVuqdDa+8TeMA/7ChhHSdM2C0HFOsq2w936tsAwtTkcGqc4bUVZCdHXrwmSq6urSDF +r7q1CvCueDJZHILEJqBkGi+aDUNea1w6A8i7aZvNYkeme9YIXbe8FdIPq9bcKbvgQVpV9pvHxsIZ +5dZlHFG4uXtmr7WHOfDjtieDshs9GYupbKP4MdhGoUWbBsk04mxU0e9tPOdG6/i8EjwNolrdWoRH +aEKzmDJP0KSiahAazPAvdKSpNrAXjHxDvoka6eOkCrHPT+3klsoEvEBrTTOdeT7d6jUR9u0mMtQv +Q1akCwtCx2TlT3JZ9nLWnPj7dt+0J4gyFT3B887SIdsZ9Y3zwdt1wYbnvI7o21MhwQtUAKOd3Pu2 +T6vumcm7HkZ0gbaYoKIC9VJUYAJf0Bw6qIKg1JC4OOPZIRaoYE++/edG8JJgYXUhOyG247r0MqQQ +VanM+q0qDFFWvE2g0C8KrMYD0vABitku7/hC5QDgf85bnmzHKFCkHXBkz9Xj2SMEJfdnVQT3u664 +DxFTKeH73IhPoVd0Fa8aHzWBolzpSWKEVGIfDaRy7mxb70ucgK55b2r6tMt+qPEHGekO2ggTR1Zu +GOooo8iYg+b0bCPVwmDjItNFqyh+0DSc6fDRKGbwxfftjNbHqVcC5h7AVcQislqJC/800EgXubHV +aBo4dZo3x8TXKPox4NN6E6elZIWNTEkXAn2QXYyksfYl66/zyaMA20u8QMxibsezOvRbXDupI79A +h/Qz6OxHeuYoj7mwkja0Vsa2g3314RvjfR1a311hhUvBLsCFFNL6eubAM42gfIlY/dzww4LJG3B3 +dAo9PWpJ9iiu9rqAhqpkZody3VcYvyzeR8uV2MUJBSjqjl5RCj8kMMwHLJlzRNQY7WGwsgLGr9eV +7gwvdmHT55Dpm0pKEKmWKizxKMLc8pVoIR56PN7JF6gCUUvBGzC0LBo+D8qWjmDZCkETYysAbLHs +PSFjwIaQRTt6tPPW9zzTdmo/sUtWD5W0QWc+Hc0uaiGPhPqZ1YrCN6YF6r1QHV+pKFg0r0QvmivJ +EW7ov6HagTfwPLYrMUsYECz627ANZ/+ECUeG6SlwXI9tH2R1MbNgJCDMXl3hcNYJ1UGOwNbp+Zp7 +n1ckfw7MEsueTW961oqe+DooN8PigJIMJR7b8IXKzlC269InUB0tnHspe9uLpflkCe/AOa0ZpW0R +wPyrB5sMcVcqFmp0RuAYRkQEsOzhgHwcTasonVSL4P5zPPUIuyKil5H2fe4HJYSOdu/YjC1sYmFs +dQOsHa+rH9dD6ZKODkOr5xQ2o0CVnU85QnfNU+mcvCv0uiSVwR+afLx27S0pJ8a0UXSd2HOxiuiP +MvmoH8UEdoOz3kAzHBEaaI4j9HN8nYDV4OtkrU1pInbz03zIrY4oWTKSYybJUToazjfALqQnH4OC +5Ddx0kyNhKbfTnxcH02NakoXupUUpo8rO45/PQl70rpvNTgKTM81yf5JpsYBD2IVBniQgQ34QIMd +mu3XTvwuZDy1tVxbWvC8bObITe7NBSF/An8mVwZBUrgymtocD4gdWeWtAlg2So6DwvEodaH77UEK +NQBWWGuJuA+x6QC1aiJMNwv3WxKhPOzKCrRmB6IKHL9Dzy3tdaX72mI4+rbDcp77Amx86h1aXZe+ +lvNelDCpa54jebm4EuhGW8fKlMYZjdZRDyskmHGATz3wOoSdAc7d1IxUL5xCRYH1DPdpY0JiXLNN +344VMg7WBuNCeTs7tTOtXHYo6uQ4wFBQhgsAoIakWMooP0AMui6r8uSid8iBcpbJbUUufiXLJJM8 +wiFeUXaDjWIZ5Svhxl00DcGABZH5EmpO0/kX3RPmAiLWBEoEtVACwlzQl+1J8mEuNPPOC+pttbEU ++bTYTKtadnnDYPCy8dEZvZIC7gvRvCN3vbaSm7JmdS2pG+vEJneArhkuEBlDYJmUwKRew8PFuwFs +XbWl1XoUL3DWpfj/2+/Jz3/Gd/ME5d6y18b+QZFSlpl/yMETWWYVTDVJVCl3WjjSAQ== + + + i0+B1ax0NtbuiERONS46m039VJwh+kPOs6LDQT23q3by1U8pcAJilCwBR3CUVKRQy+OvsWGDAPUA +yyg5uau9NvSpAgMIYxOOq/1v+jTgweqxpf41kF3ZVNs6LVfQNVGlJNNGlfK2qNl0ZyExudc90r9s +SQiPJIRxXfebYYCN7AUHKX9BHQVKyb9vq0vlMaKdtMk4IPue06qDd9mPf52tqlBXInq2Dh4IcxOs +Fao+GyU+G7jYE1hYujlwq812AlZ8GJYHguokOD4nPJuhtVnk1fe3xJuTlwNVZKGQJk3b4KuIyExB +uu6CXm8p3K4ZADLShzzrGXkCEuUCVpZ5Z01aCBeqzL4fsYns7r+c2e15Ku0L2+PVOJk5LaCnt7DG +ytDBoYfBjj1Vg3kNGNO9D3JXPV6NTo3Yws376Y6Vn5RMmkznpA30Oeisl0CcAhZhAsZtPb4ojxAW +BIcZPA1uD8BSoPNmS8csUJDZfr4S6lxDVEpz4Qd5RINHHAMwQeZyFn6+ITQuI1Q7xYeAPj8VKkbZ +mnzWtNGzw7yMgPr4dHiPnzCht3lV/VG4P41caKw3z2OnfioiOvcelIe3bpj6jRHcF5p+Z0kEmKpb +Qez+upBGv7PHR8rtItMF20Wxq0RQCiCi769EY9cbOIo3oJEQX5VVtWCN0J/zY/mIUzrSSy2ieza0 +MaXkF2ScCJHGtwoLJM0NuDBNJW+NGoKmOFekuwuipE+Pi4rHYf/0jKgfKV5Ti2LlplcQEXa6EV7l +DpAaAFUD/J9HDgd9t/aeBInTliOOlcLe4PGx32bMKsuASari7ezILXTc0Qq8790bqcfj84zd0W4j +nj9ts9UStzaKUes1593TC7pqa/1xkUjYpUEBxArJqBQUBBQCDlM6qT6CIqPD0L/b1qKpOwOyFr4u +fZ+7RF4eH/qVi/aHHkyJ4ty2tCQD6E2sV+cD7dtH70UpIErC6ApAxtDD5tpCmtVqTX8Qi1Xu8DWD +JMc/ExzVnc0SWIW1HqKiLYQZqZvjihvZaX8Nz8DxPC7B+IqJwabGoQmM4Lx3/Qno+MpbkMShd6bN +xd7LA0I+71hf1JCaqzwn/g0zkTLNLB4ofUuWKamsU9OmS1wPzhJRR4TxKH2s/T10/1vG4DW8tz+6 +3v45E2400O+SQpn1XrZkzPQs6p0CdIscZpRKYVCub74mdNPTA81rlCLWvIF6lm4t5+ZeT5H3oCa8 +Yw4iP5tKDgDlU5jDh2QUKaxlkyup3qzxwww15z6guCXcrU3fd+qp+6D3sA4Cr+cA3c6apow3ofio +BTLrEtvZG677sd8jpiBTcWq2Q/1CaLv3B2+/ZfPjFFPLbKMdjEQSq9sYXWWEoDKEvNSbHOfQhbbK +v7hoCPafutklb/8lf5V92Us3QyoF7WC/wEpFgS6vv5/HDAERIooHqPpwABs8Dyj1igrtI5zBLukK +EdUhzsF8SDSstyBXduKsXjygyCgHqhTZtew+Z4Ndxa949J1/X6BFK1294j4UwjD7TwjDkCJA1AP7 +K9SWWcXAD7zAVGhZUWGnsUNFi62wTY/1BLgZpE1aQMLrDZuR7kZdleoCa5zM/7UXB+RFI+d2RMyX +OMvxyAIUSgLB0HcrrSxHH8BTLunpZEfS4e7N4VpffaJeYoWUyZTFhGoK7sZAcBEeQtkhqPWacpje +KOdWjYeVp3I3u7ULUtKmEIrabgOeocvJyvUF2NGCpKIJwYfWC2bmL0AgXW+ajLcF4KPv/gvl4SM4 +WCwTgOaqEggnAoDsRQfXVlaLpsyaPMfzgOir2kBb4/5QvmNlRcyWVOEs7HP/a9wD2lSXFCc1gBh4 +pj7Uz9MNZ1M3NU4kazWj0ES9REccKnLInq8RQYIImqB3wVuwY2i1iML8VERU34SyxXpzb6wpqTkK +8QCzTqdrrU8I0qs30SCYgT1av9kul9Hac6pXNYctM12Z5mIzo+l6BAPDlpz6AbgIsOsMgQ3uv+6N +L7zIWc76dgwvSwHbUlDPEgrqPnBuh0ZX7XWgX3uHrgOmFYtjT6z0dxHAvCOB4267xjQBIyjuzdcr +bgdwjtAs2Uj3C83KI4UKa+64VVKeYvd0pcTJK3/Vra5C4syryCLPfXiSR9SDZym3F8WBle9cbC1K +EPsqfPOqMkRYXwVKg76XL0JlY3exJqjOGmi+07DF5fXaI15z1UjqqsqAfq7YEBxKirvcpxOvF0hJ +gQTPcl5KKv0fE/GWM2zbVE5Ara9f/oKg2KJAbBOBunvfxGHU+XWP1u67WDDu8h+PLXWGZ1jdYhiK +SuCweIq+krW/ZgHEdFhF1m2GXEtdon5uUWS9zqaGQW8pprXr1KiD68jFmTTnRSX2pGONttyan2CQ +HVdY8J12TkOIeb9mKHs7QPXJLjFzodaRjecQ5GjxEpcfECr9jtAlDllzC2j2l+5M3QophS5nJdh8 +VuUgRU3woFjbweF3H7sUD1GNIvaWsB5qU98exLsRSYcCr3koVBDNlzCiR5MXDgjUWgEiEDKY6cHv +Mj00imuLs+S1HTFfGVBgW1TGJaSt3070/ADAuc925PrXs+1ZE4bKmI4T19mmLeiHBbsjrpKTyeDK +Hh7pGWHDa82XyGZBDehoS+8kguzjgeX/JA+F0nxMBnBdFVrFEhTlIfGtHdLLXt+bPZriQoVSL6kL +Ze0PCFShNtY0jhHHVUPtwnNgRsvd3GmIfMjprq27iKAaP35HXp9WI8IFRz4VPwxE8ChUXKkBeMDF +ELr9+Zyt7/5/SqasOoOPwHHIRdTpWK8s/TEP7DZcPALGdT02XxcOC8EKaGdoSV3UCsXQHs4bEGy+ +lCracEXU1eibDI6m2mOMegQ8Rip2KKKOx0sesjD/lVIdQ7q0FFZec5qPvOZgJnYXhSe4fetjS0MW +6j2tfHQ6WWZhLW4jeIfZH1vmg39Ima9tIUC1ZacTqo5Sije4dU1azQywZcxTyG90/2o8qGJOtZbi +tllBHT1HfjB6EPDE4HqcgUxFv4n6FLMaFZi2nheNA6cLeLjsdRoIpfZJ1pmZs6rQ6Qoqh3oL41i+ +0CGKOph+wQZ1ms2xlZWSkR/0dmbR96P1CHCY9MC1P6SRrBmbxF++5q01E3pfwYOyVIIHnfzAs6YO +vr7eJZzb/XzPfl7F+TkCFmjWuvaW8owQL5umaJ9e4CYuiwYh/vXTKYrdcrljLgrg6F92zUC09roD +ptRwh2A81PV9YYvS3hePv17SfgS3HeXTAt2YL1L3V0UqYSsECyBcQ/UCN5AH8l2UJtq2u859nucA +VSuaZEAiHl7s+qj1mERorNXRtvi8AF2JFXVu3NalweehYH9OcwtFw/NjJgKxzWpvLXewIcJn15qT +iDP3yMrxutCJ6gH0YgquIDQoVRLFS1iUJAJDgDikjk2D3+ikxM4Ww4j1ovCNcDvNKWyQu6loZV+I +TBAhghs3lJj1mBfAG21m0EIwJW4o9SI45xbmZ1+ZHF4JGapecGNAN0uUxT6hPmszUeQGCi9p5T03 +SndtH5uZuKxLeBttXec2QhIpQiaF/H3tQc4zF7jmfJ1X7Rt1RZregIAjqMbNbDBsuSoBo7ff2RV5 +Ammq6OmlnGoiLCF2Z+vXBgZP1Rt8EFUCikqqdqLGdvOqYmBlg44t5NXeIZLskC73UG4rxpu0sr8D +SxaYvpVW4dMaLecSzlSmgjW1CuAvycphBDe29CdZ1BGXgHI+CteKAHelaC8xojXESblAI2KiciXg +S3bpA5SmW8xqC63Hc0asYE2RFyB1zF6HVfn1//cGLIMF7GBnVp7WrSMgasfMXnGDOb9DXWEuycq0 +nuiMdNB9IcrVcR5MBUaRM1o+x0sNpGxp1ydHxCCZKRxhLpI7AsRtgQk4ItCeAhRugM+F7BYjz8a+ +5dpLdgXx8OgoX8duQXWyyFzIFhT70aqSEf7yoJp6S8GFCP+sMRrGDmeuP3RNxgnl6ZmLO0RHZp1Q +zQn6GojkVliCdOdpXyk2wgbwdM6NhcQancV194rKxvoqA5FjqGfKODqYn4ozKBs5+2tqRuuSKNM9 +JhUY5EREvQiSRgLS7JE86nH1TgN3q/79RfegV0HiIcYBEDtJNxMpoyZtPmySeq47NDpe37BEckCV +DcZVyymeJbiIrRZ6tAYYyz7lRwoRQ8MSMa/VZBBnAAcj5umUf8mfYSSsfKXU7Vp9P4RBkrSTl6ig +zh1fDnadaxkjVfclVb/qpPcspu8ODgbBYmBQ0lcyPdHxK96apS/EHY7zmebKwzQisSHqeKqTOvN4 +JQE150Qhf0pxbOiDqK9Me1gtfXQQEQkjIQWK7sbbkb0fVR/BxJ1NS1hNXsIcbyizFvWhD6r5Jw4m +PGnw4kPgG6+sss7oiHLZUf2pW4AP6C3Nh1FL6s94Y07XSW5uEULWHzZEXEgEEJ0cer312j06+6ci +nmdwHitBv8+4ks9UXxvU5f2NasiQSFZI67zGdl6mmQneoz1QUp3Cd+EYqkuVlK7aAo6enOJSmG/2 +z6VCMkz1/Kcy/Fgk8xs3Zu4esYbLevQ2rV7vCSP2u7NK9lzH27V38Ea5opDTzk31OzfVjxeqU+gX +hLlexLnJgMm1wk0nQrAfMsdWdCK8Rip6Qsnco1mf2mLrCto66aeCJU1IKPDxHtmF81TH11GYhEoW +g6tKboXpYfikMRXWJe9FpW5bjHDtQoG+MeBNQmnKzmM/F1R3TssxscrIaYZYNt5JtrDocNwBeNOT +dQnBwe6hJd6Bb4+bp9ucE32lkTSzwU7qISP03GzBg+Yts43daz7KA9q+rQ/lZ5yRSWF7V9wOsA1n +LdYn+HbxPul5oZHAXCVBDFGhA3Jclam9U2xyUcmON2sXFjDw7Z8cargKge2ckTywq6mRyBnqm6qZ +a+5Yq+KZmo2ZOo9mU6Pd+MFusjZyqPH0uZpfKWpGr7cI92IxATSpkgL4f56EUuLI/cFTHHCHW15s +nRFpAL2WVKKA4RBVnYnb3mWYakY2sCIUijrwcSZC8B8aHkfLlZqrJSj9kSttYH0oaM+VgmPWmfpM +lCWUg6HUPkI6QBCO/auTDMaB1fOMLh6jBzS0IqYOz9jVqFS4nkV7OJxrbmJE23b2DTpHNGakw3Ol +C6OES9uwQXcETUY3uyD6aa+IWp7R7oTPuCKebeTaZR0/4JRMW+h+zjOGtkoCQ9kT4RLteord52Gd +FGUX8N1rD9kUpq0bnQyhmD9EgBl5RoQHN3ASP1GF2Q7Iqa6XEzuyygqqVSFoA+tpCusoX3FtvzfX +Yp4a+yEZGIBcwcE8YtyWB9CQ7Vvx5YaHZBcwOxTKBBZc0ayqI6dxF0krUPWtEgUbiTwsacBQ9NLB +bezlKIHkiABHBlf2w6baa7tX7g3sCtwaEkXNxhhJfa2+xtYRhch491OcQfjJGoKCqt1NarWplKBd +A3u48z5SVG1AO8rWKTUfF0Mwcx7aa02f5zy67v5bebMEaHpd8Av8AaerhiSz/MiFKg== + + + znUNJ40tb32wlrPvOo+4EVt1bTg7nRFWvRWoQmU6AQermx6W9SmblMCVOttKZAtoT0JdaMD+NV0c +mcpoTWHFyUyY16MBOegRaRqqs21bQTpdJLYNmOsj/HFtvO+o6IHG71kRs0a79IpqUzQXWaZ5mZHB +pOgH9sItoynrVMZpplD3xULpdSUhWBWz5RkHptOUa00pTD+2zUVyoh8xZDIMBal6tjdD6bYi10OF +W9pWwEZ/3gMuGOmbkvkZCqN+CVXSqSNbIN4a2QJdiFCjDCM6buk4M73hZjjOze6k0Aa7k5H9QHel +d0NVFESkBB+JC6lgjfipe0AgDAOIDfuxsKxzb7rb9ngiRQ3iwtnzQdq2qD9Z4JU/eW34iAji2x/X +Bb1jnNFirRFHJOYkxhUEZl+/lQNZvAD2KHyEWkZ7/JXurUi7FrPRN2bVVt9kUzssm0Y7GBmLGXej +mkamLhoo7cJVYaNqMgA3qO4cLHrA1YMaXxV72rvdKgdjwkCJy5GTDKuzluy4Tnrh9QLOY0fAmivm +OefrAuJoUC6Pl9Sll9SxmW8dxnLL3/WJpf3fSiSPD7oHfUbbhwitxc0gXiJp7MvFrq7fFoAKWiHN +LRRtxHujW3XHVJUvlF0RQRey++FizL5VuvsILKU+iHwsqJtF2XVfV54vTpmMCLzhnW7lDcEjqVLR +g3QBaO7WFY+fITGQ9NinDNJon//YstmiY3sYojRbMK02/aIrbAmMPhXv4zHtZ/PNXBhXWtvkojAd +UyxaR9BN3mQdonKMiY5ja9H4q38TGokKtNizndu+nsyRoKPaPW5bRG8ttAjrexoaEZUN3Exn4grj +ZAV7mzWizesHBKCy6QAt1YCOl9aM7oF4VDDJTf/5lnyiXeSWPaJPJzgzTc/ureTMsr/mj7JtNJWf +Jdeau15Awbp2W4KUSapZpnK4VLHVtuWNOYYAii7lprWsErzhJE0255VRVeA86mBF2a6VLb10d3ss +g5AXUnuybwtl+Jsgtii1ZJPcsZCJ0qhFzLaWkuuOnp47vnW0g1z8Xr2DQjUvHr03sTyQNMhjzyNU +jPXUKIKZeliG7XSJKE70KedMHwTF/TU52vXZTrdnsGXVhi99oeOwL3Q2EteGcBnVtB7LOQHLNjaC +BP3rvfOV+nM2pa5MtIJq1iinipoXNLDyGeGqYCnSAQFARcDYujhN/p+4hg3AqeejrEqv3byevpKC +uKrRUciCcAhzKPJOqBWmYBJTcKhFa/dww2I8NgobwiMo7GOnXayR1xXNZZuG7MzJ6mdLT1sxxEtt +Yyyh9NkQo4HYSXxy1sk2FPxExWGL4lYPFtVQ7fZdz/LCVgrVnLWV+qPIoz8nvOnf/VFz0D/xRL/h +zpn/FP/znU+mqBVKBDBnGq+kcHVWZPzay/YsgjnD3LOiLgrZb1E+LMHnFI2Ur1FpPwdc33mKqelk +FwRu79nG6QNyyDHEhNF9xcQYhVWB/bNOw6zWo7ll8BU3JWpWEaP02S2WrslQ6HTbgOuVFhwvBvrE +5l6VTLQCm1E1arlkptPztC6kZkLREqZxRlFxuLP2FNJpZ9b99vRSC7NJf13IJgNYj6qkeMlqqGub +TNUS5Azl67qFHoWoo17NvRFxZrN6ur8hQK8ATByeGsG1zZfQyru3TikDFo0iJo3hZpp9XKA3QpU7 +cmA0bjtFSXJhrDAfTmnNThEYvJftu7sOBrvHX6IlFYILd75bdEhhqIKVIFXe8XJna6YJ8rEvxPLP +M6OIEnHWc5vKDKoE0QB3ePa14Gvwh4F5j8H5OWeeychyZgGQNXYbqNOYuV4rURJ8cM5013UbPcN8 +k0RZcJiNRHSk4WdmA595iZpyu9iVHBhPqEHPpHW+LhCaeqEInwvkm0z48PvHbYAN4OGH6RMgx6Rc +0HMrWS17jLDmJrpPNZH3lhcHVDrHFaLbzApaA0FsygDUey8zQAD40ZAhVl21ZG1g8T33JvxXEV6g +m46jMLlSyfObqGrRc/pqjrl/NPti4B7Asn8T4TNEjxgB6H2lt6jjyqLdSftrtPTWUgU261R/TRBL +F31VzU9WDt2O+3UgXwDUBTXjC6ma64dPlYguYGiuzyfqxpa01g9lEalrX8VH45EnJfUxrOgtxPV2 +2SQJozUgEX6mmo8ri3CNcDcgwwoOQpSRsdlbNmcrYiKCJpNWMBCNj+PzG1jbw9u07tsYxb30BdhW +uJlt8jUg07RXJUOCA1DjqC9YruUCJLxc4GndMXVGeb5ujBJFSKVPd7mxWfeOAPQlwefrgfDUjvDU +NrLqm6i6VXQvVMJP/czpB7CeSJAYSIHBmsJGEWmgZl7SdkTbEePxf9Xq+O2YfYLbUoeGJebpNtIQ +kYqn69eIb4fkWxS016Y3wDgUj8OPjRYsfvdStW6FJxmSaC/w2gxfb5qfWw3AIhkbxXbitDKyFDhd +gsbedTZImMwUQl/bmULWmumuc4MFjILHjCCEiEeq0Jt9fdo/JIJZkXqdZXQ0l0mrMVe5hF/VVGMo +5z5vzNAH1/NmTUDlfwpaXJtgfn6rrPbggTe0RIgdZGagw4KN87UPSDnjDXyo5gP/cgqWgOcv15OA +kA/JU74Xcgyx/lFYgqVbJye6/zUPJGoAR4Xu/h6RWtAmveItXb49D1s8y1Lab2UuSeF77R+vEhhv +uyT4rid2R2fTbQ8JS31k9ogasmdpKyQhQk2EKMof28ComjJV62ikTGoE45r7kJb/1dTrX004/0QT ++U1gZdtruV1LoYgoBOi0FcxN9wBe0ECn4ABzxdqHew1Uvrh3XJ2C5sBAZST1lmJ00BnaewCLiPa2 +42CYdBpb8BehacY5YfKxI0r1AQNUHEXPoJzxPeU8/U5E8nXqRbS3uZIqrTAwj1xJwfIBB+/ZI5a5 +kTRrtR2W4s5UzMp2diGZ02n12lZwA/NaoSu8LCoOdpn5RmjegPDo00ktYh8FuDTxLHdJ13hAakbG +01LchaHCOQOLLxudhYRpjcyfzp+o23bt5LY6ijby89OWzuo5JaQTkFXR6IJS6so4rwjXqmdOu9oV +Q49rjetgaHZF+y7ZPWhMm7HVaE737S//oODdNq+oWUvq8rZBu0IREf9zueU8o8aJY7u/UMBPRCjD +OOXiO7Hechy9coGeZjkH5Yx11c78N/psuHWDIxPmCjUXoJ4zMRHB66zRVR4x5e2wtl7tI8Nb/1LH +q/trspox4hZ2ScLtCO7z6H/rzfj5z/k2gsqmmw/8nx4OGJton60pvu1dl5BuOPBrSOHrSRB5L0Fd +Zx3J25csgkEBLACjFoCR8ongSVXJhTZ/B+4TjBJaAP0TzFM0XUELoG4I0iVQie3L9DyRqJxuAnYE +86zklwgLu+E54eYd+xwH2l4rwXoA5nRoBXlRo738TjVuoOWkLUbrlKIbKIB2IKq1K7rAhs79U6GY +Kp0NRxMAOl8jsi8auwHa6tA1+GsU6UmXC4/JIjU3ah8wXNdEdsQycNPVC+6xsk/R5od9eoz2adIi +T5wojH2IWieBo7qGdIm1izND34LERLi8H+DCZq4UHYwLyc4IeSi5R0R5FXDHrgBSnKZUjNxHNB0a +ihZpdbihunDzunOeXhUEQfo1EYMFmg/WXAmyMBE0KT4bX2k3Ia0IU/FR9LidJ80MD7VreKHXk5vB +2JUqHZeZTScsGYt61o9oMJMeYXz1rKJ02Vk0hF0AoBOLtYbu1AMSRNSupK+5GAJgtyWw/yyC2xIo +xM2nJfAc3FwnpBYkzGBnJDqpoPSrclwQOuvXEwN5n0/zZL2U9jS+RPxu9zSUd9Cc5PomSp0DsZQ1 +2aH/Ds5Qpi1e2K/s6HWQUW1TIH6UeYZUntkmjdTTN89ybRg1zTkiYQt0iTwPOqS5Cq1k2i1PWVv5 +r65wdaLWRrA6aFtJVrT7XzSCQ6vULAK8oDiuYwO7QPiyC1ZjTDEqCOHts4COmC5R2LWG/DkSBX7X +8wjhUosX1CARZ6yjBbGJ4j0f3ij6rDjZ7nShulwokAX9OiboFmfC7ElbKs0+uGVo4fLMVSo+vLPv +IjbtrvJ0HkOhtyhISgJ3Gv6kefiDynSX7UCTbgYaU3m3mHupOPLzoR5A4/5rQKapbfk51k/EfPx+ +GrAM1pvgVdO3OSgW398cMG+jR8e7/ag7vkdJKSBDjvuaeg4YA1CNmj1vm+1PMt4xI44oPWQ8DOj6 +yHWtVf9lhTjCGV8X6lLYofjm11/j9drgCyYfYBVouLyND+rru+LV6JHHyL7aabqVJfZK0ExmnNjj +8n6AZQmuqwimAmK6pVajUHrfviEgqazurUEDZCnUYtfUC8e1fQHFC0/hO0ewv3Q7becEXmUFXIAY +NTAbPgUR5goYRkMU4amYMK1RY3dY1jGdyYqwzeb9GlX0/jzRazNKsmlN5RxOnwArbChVzZ6hudUa +4kbRiBl032AzVXKdosxuf1kwCWuihQesSYUkoihQUaW74y9gHe1k4WghSaf5xfAEv+gpeBxusU4j +elFGkK3g84VEKHGeAzX9KOiJiWMj4IM5Ny55UO49A5tWBJVXWIOh38iO/pwbo74lOJrGCGa/lgVC +NO4/5dh4BB3WwzivD4j7wzzp2r1k2AhreI5tj80Bu8sUQkpLmjUQkLn3QVczeK/r/K6uMyJ9Srpz +OnSjhhYDM7pLNZ+42q6ai86peTqMbc5i6zAgcKHenfeO6yorIGx8eIB39EWTUp3ZkkD9APkoq5+R +h8QPRHg6ZKM84hgtgimFgb17Nv2OX3fTJIn0EiTclAF2PBT+CyynKzjsqDtsxyaBdI2zQul47+TB +tFKS86B6xRArLvnKVyaxOwBBIFllH1Amj3olJShwTW0vgRp7ILEG7mjaF2/2GzkwNrSflI2VdW0p +uTfFQzQLsxPecEDLycjCBCqQbFHxPpg+KoOC1Mt8wDYnKNp1B8/f0XLJ8g8UctecPCgYGKQadbi1 +9R+4G1WKXNOS03rIU4jK9fzTPhly2vMVATbrkjMDsB/ADnDDdaM3vAUBaGhO1m0YcM+XZxMZP8UH +8aLRsZbBY1vhHFu5p5GVVFiXtWycza8OcEsvQ6SvB88jIt18TSBea6K88GbJgXMbwOQ12X8ie2oC +86ktrz0rPEx5BPZb+FXONX2cJ2zbiM08jRgP7JxBSQdAFxzsVw6KYAROEEMgntMjjs0HUZIr/ZsI +fGuqC6yp3muT/Osodc5ndM7XaKLnEm3xhlgNKyg95PGhZdJs7wf2rzudLL4eVFWiBZEDYI6f6wZW +AnKYSeS4Nz9nfc0NbRBUzPuEWDJ8qgpWa+UQV3tG+hFG6HqO6226AB/M/FV0Es95b6xgOql4XY7t +sISc23r1NEIkeyxHeB4cQGuO3h1DxtO5Xq+L1J0AiYhqeWsg819nCMXCEqgXVXHJTbr449PwqwP+ +yge+JYE7BaJnGtl5xjArvfba45Ck4656/XCgBrgpSGJX3T4PUvnkGR/rFWqqlWTCuA== + + + 9pJFy3K94xAzoI2/HfArIoDfvvmUJpUZ6XpGc8+M8OfvSjlwayiObXfmfQypkgpJCCD8XKPs2v6h +196547NCLo/+LUZ/bweesVuRlJvoil7ffJyylhKA26aUdm7XF2Wd9f24yXSJ5j2mlK/S2B2y3Yrp +0aePlMxc+aPlnfroDYEcvVRpVQMN3g1GNHhTqrP69YDPhG3jdwcjeHbvhbUfWVhXAnu2oAIAgyl1 +Dv/uUSVEKhFhghYAC8FTfhf/xmYXOACOEIjRg5GI2PmI2PmzGzoRgSr5lBCLovmvn+q5qbJTT8i5 +tzclR5wDsek4eem3BNaktj0iA+yzq4K7VB6brMtrmTeBWc9prYRrSbz2sPNA3Qe2Qf3Y1n9vB+m8 +mw9ABIWvu3YlF5uJzwMlEL6C2s+eBF8HO6I4iDSI76Au4B4c2gLqgmi6qoXd8RAgoaGqtztf3LCT +EQc1SFGg9uJTajxwAEF6DsD+8wCdKyV7qapiWDE2LdeDJN5WlBCP4l1ZT4wDZhfoONGzRjyKmp9P +zG9x7m0l6pN7WeJrm6ShUY+52voBGNEfXSJFV7WpWHxDDACS+3MAZyArYStTmDsZfB1UCG1ECI26 +qN0S5tevKvxDK69v5Pmf4YFKQg6qzcBQPwHNHGZm6ybcWBTAMfhjsKW/xlYI8/FcUlJ+ziwjs94f +O/JppVBFW9N13FHg3Vo34r1dPwXSqd7A1wO/e/oOp24bgH36exQ0v/AJMUljUSQfpzhOPo4G03vE +dzP3W1S1VcOMNABwYBy2ZcxXFK0w2HLnIVvu0tVHP5QS+Jgg97n5j5hg0/H/eRdnd8m0hTEHLJrT +sF2lLdFQfBAzjpg71MAxraRS0oc7ckLhLbKx9IhEjArwRHagxzYbJeFnokLWnr0nvomI4D7Uh7cD +/7J3yNnSX9fo5f7m42tqBGtzc1OoaagsSAKKsqBef8Ct4HKu3Tpb4/AgmeopsffHcsGotqPKE2Wd +4IIvtc8j5OYQOpyIuSO0Qm8bFU2EFY4S0T4isPHNlbbHM1ofTAbSMo/QMkGUG8CYGnQ0bgPipGi+ +WRMA2W0FVGZiI9ieMf+RIj/XUcOaWpVG0T3IO2Rm8yyPn4Zc77WPJ8Oi8oH+IlJ2SKjh3Lg1LqE+ +hqgDgf7aTod624w1OktKnNJkNe02Fd7luTViKurJmofTmqCuIfj/3iQsoIz1MbSDYK4cNT4AZ5T1 +aasRNaJQdP+EpKJ0FGVZPA8L5TrPYdPy3hgUFNxrbNDGVV8XuNSSWDmdah+agrJf4BdhxHwXoX4O +qyVNJS/AGscFHp8BeWwsEk/FCpPZDuflOAM/hSdZNcWYvmpMcUNzdll86G3oQY4+z2ZvX20P77Z2 +mYqXwfNBKBtYu/3IluIpMrGP1FqzDki7H8Wo94j1ROltocs0n3KzUXNHiWXY9bWGsMDm5wQbN2gk +VG1cA8tag1FaAK5tTD6UaAachY5+5gXM9bjG1vqX3ioTauZG+drjihu1mvuwbXS4YBJk7V5v6RAE +f0JXAsAHxl6CzdywtwqF7GHG9jQ8xiXiMlEoLbJGi0JFY16ne+6WInXdZSQi6M6SWLX9SXFaeLrv +ZPNsUVRY71FROM+bYLxUi9h+2mrXiqiMKCKiSYVuA68w52CIcQ4R45BGVcVY8zty/rnSCE8U3PEl ++qo9PsalyiQ9QQizFoEk60EunGjLrDlfhDjkTknLOCpZ36X7Jjh8ZTYvUsho295xnfcaT9RIFFQj +Irp0qZWbnDUGxypBoBQ1JYm2QA5OhL5AvaneAQKI9ef+vJI7ZdpqUuhuuHY9F1AEYF2g1XwVNWVW +BG0gI4YOdHz5koig/hSUKa+fR3Q+atqNvQBVUOa5Nb92ttBFKlDRW4QivggtLVtQz9cTU1NE8dFM +sqAettxRgwbzqH6/nQcSntUXKqz7Z+5XXEp5E4EHaRW+dk9CwfL3YJHbFlnAaeDur88gdSKQmQLt +HJt1CgADySMYem8RjH8SuCZZ7eF6fo0C60KVAetDclpKnvbUaMoUNZLK1lCBVS35Vumorq3R5AU1 +4kxE/cGbPSNFFs79zXkYA9AYGCkS9HpypDbkX30T8MVG9jWSfgxCia8oi6xeqi1YSiA3QrfzipOo +uz7YZhD2y4OG46EL3D/tdXz+IprQNjAH3YPqpZKYamfY24NTX5lvS4SwBJBtm6L1IO/4m7nMiocv +nIO0adfp5iHBveqg4E2AN6MhI3KDA+AXfJHvCFQpR9zA+zz2vL1lvTnbFKaH8ZkUzEpOc/k8hiR5 +FALO+K+GygunCtzCKLu8XhQreI/Ig99s1bePr9nIQjyV9ykBbabE1UgT6NG8RfjLjvyy4xFzfYsC +zO5MojDuvW+050bPrZGmESguERsDqGEw+c4LH1DGlmZB8LGe71HBgdyaQNp64kkHedHDLgKPIH0V +BiSwC1RD8QQPpOXaMBIgaCW1StFC7WhboUyvIQEgt0TFrwXL94hxxYqAQuQLl20U9QqixN0CLYML +d+h4FLWVKDvGe6juwiFba/waC9KAbmYKeqFhH2/JpvWFHqfksY2vSGSuEiU+TfHQUUeYhghEhIlg +c7K9snoOgPKlSXdcW1sPUDJsxPp5flfTM7xh9Vho2Rcq1TmJThX4mvQWhb5AhZlSrlwfDwAimgbY +7Ug7Dj+B65ktYAO50WnIot6R5O/p47ggAZQJPPWwB/A6cHQt+jKL5m+yLehhD7Wxp3yTbIealuFm +deYuQ614Jr1rE6CRiYai8jUiQ//efha4w9TxzXkQGCGBZ8mxEYVK46jfHKC2Rl6yhnY55sPU/hL1 +pqVK8/KQtrlerHkGerxRsmy8TvM8Gn0MiMEI/RrwmiX0Ij4g9PdvTrOWwyjfrIGsbR57XMBQ64YF +pgCRUYyatF7Ans9dZsBg5O8rQaY6jaK3nygKlPKGN9QG8JbEAgABqG4MVUfIMRhdR9Goj4iGkOZA +QeKZj4ii7b6irBoQpRuXRcsr5wnxCUExER9lU4WKMtZGCA7Fl/na92JBfFhFfoQA6r5SkY9r833E +JISu/Un+yAKJi+3mQf3qAIPVr476wn09K8OVtNko2heABaWKIp8wI75yx6bC3GL9bnKMbWTrHnGy +Fp3vERlTWxDu7eNXj9j3QAODKgZuT26t1r6YSr56tJL+q2CRuhlv9EvXre5NEG8OpDQUwjdUP4Ds +taFvM0CaWOKwPG4Oa3gLa/PZZ56j1ZCBcNQITN/iJK57rAU/b8yNSRJjZ2zNP4Uq6HFgY8XM0I5Y +fswzthVFqVGYxtD31xR7znMHzAQ8I1X1Y5EuvN1H+eY0ZSu2gCAeZW4g4iVAcKgz/BZRHgYd0ifX +gyF+izqiLoqTkPnlsQVxOpZFZ7xP5HPi3tTomfGV7jyqqr/G2oMe40GWaPAKRgvbjig7BzGJd/jI +x/Wv7loDbplC0ZvI8bcAjCj6G2GJCu5EWC/0LT7tVmImc+Ebv60RRZOuEZ/5p/6UwX+loIC49PVO +/pZ1cyjRvIbPg5ZHCjEF2jbEdR+PGjc6ADNwtBngW+TUlb52nEOdusp3ETQCTgUrD9TrHuDbl6ix +9aTHOC+f4YazUrxQ1xcoeI+wUPRVUFI14kbhcbxHpPRwJdODLK7Y0dcogc7KaECg3yoFAj9Y+ZUo +XFPMpsIdSbFEpea5kK/sN2ZuWE4gXomqV6IwJvmrfT93XD6nWzJ7flW7v9OEmarPmQdga6JDiC7j +dcCKi4xaxL3aD7UiDl5Q6ruKHxNPARQMgn5XEqdZWsCshEVYrCTaXKKSzs/tEXyj6N1tZhwrvOJG +Vw/ra8CX2J7VIa7j3e0P92UR9ZxvUYg8kIP0U6ttZWNE9ZwaitUAnMlrunKDXOneOfsab2eZW956 +RN56btXCY6vwgGS72LlxZVlZiG/QVJ8/pS9W7w2gpqSh8LMSXgo/K6Mp0PtpqaP4LccYTuC68YvU +Se1+MmBycK7Yzk6XQ+ou8j8I70CREWrC3gn53msLL4EZIW1u9/qpaEqtkaEU1NcDG46RWsGXY9Se +zfRYVC90k8jD7azsA6iW2fC8xUl4ttdBVl7MbGgowjds2NaiB6BdCAWadUdAHmAZnz0YzPUD2cOf +VN1+DuIGDkAQj4BUMfClEVEfq5IpmPbjj0Jz/pz4H5m4f5SN+yee7MAqdvxIsPV//C0Nmo+/+Lcf +//N//PGLlY9//x9///v//fEX/+Ev/9vf/OEPf/fP//jLX/6fX/7L3/z9P/7y8+//6f/98vv/9ct/ ++tu//8N//uff/99/ykW//8R//7t/+ru/+cPf/e0v6xK/urn7dQe/QRr+r/w3KBrIAuKGSQ4hjaEn +5wqMddAHG4xqBaNTsVgvmRovMZup4sI+AEkOLOWAA6zJ+vxgn3KB5Xv+7Kd0H0T4BXb7t1Tlzrp7 +2pwA0Ht/dLY8Ct6XyiWD2AK2tjIJhKku3p+3KCIoWxMxKLh3HcSquG/Ya0aMlREbgX9Md2O2kU6H +YCJ2Z912Rqc6cNNpAbS8VpYuKBVfh9vZdU0NCLFyGjSymi5FInP6qc8agGg9cXMBgCq4wpLiD4we +LqW3CGJD+GGAUkEHft3diLU9AajK+j0ScXS9mk4gYURswRxvYuRPSOui+gNlxbsjtdyw85qIExeo +AvQoEes7Ckxnfk7EyjeIoDqWCyC6hNAqzE4K4n33Ky/swJG0Wz803qOWmNrtFzhUwSG/Fzragcxj +e3jjIrjSgD7S2V/fDjXRTN8d3HIf4BmxquJKQ9j8BUsNFnozv10/yCHdYf1YFAELboonCwgUCPbt +6xZmZFcuJjFyNS6AD6a0PmiN6wRrXoteAfA6ieoNixWk+w4vgrB50Y+UzKlouT6ZwIEznqTL60p3 +FYNDTQuF1UyxE5XTifGlhkSJ4teZ7Dyqpzn339fW3E+DSvFASAmnDHYjAIEDYUC9/3V+yHtEKSRM +FHhmojqi+UYM3FzZVZbc59pLUsQOl4A7gMZ4aJWQCz3i3BMsHJUGIJ1rnu9sTwq3eSp0vz6NMBEM +LFrWvCWqkso/kDmAizMbm/13zzq67yEQBFaR12f6I94Ciok3WIQR9SS2EN9HIAfOz7t+vutZ1r4G +3cVy9vrGmGM1/VqDN3gG/I1UEK/6qFbu6Krn5/pyIPe/cpBev/kU5c7Tnj8bhtvHxaK3bq/q0HQe +22uNPfDJUzn1B13fEG/wvMpGgUAEiRwPmFPkFVE3P70RseiFK8PvMjLjrDHVDm/lCI5ova+IxCSC +SWpSixuvC0kRReCZYU8QfW6CYNN4mk77W8vpkoCVSBBAkmvAevxHpj4eChEXukgT667nQvBezv/P +2rvt2tKt51lXwD3Mw8CBqbavOoQlhCIZgTgBjqxoJUiRSBwFY4m7pz3P22rM9Y8+4oUly5L9e/Zv +VFWvXtXat3k34b0w8+sY43X0gRAXZSo7gaXQCkYfhkVp3zpmWsjmdNlAHxGP1dLiQQ== + + + bm9b/4coFoBdXdOWUoYZri8oXagluw7/NSgyEFNc2CUecARMjoehAT7qHxF5zBTQ3l+iDbKwH45j +gsXTNR2W7EvoGlh8ffDT0/t+tmBeiuJgU3hg2YDZ30m605td+z0PZKHRA1ctKi/uZw45NQMKKipn +xQN90rPpgO12ZRfMj9/QrbIzKTlrbVOyjw4oUFNxB0aV4Yc0Y6RuCE7ig6rJXNPSiwh0N4nAAzxQ +oQv+C+Am1toJn35I/+ChPzdzBZG4owq4daJ4U4hCX9DjBGzD6rmLZSMQUSDiKYerhOwf6MyaS8Gg +gQAkbs+727AsRp+fXkd2sb2AErVfJA2zeWcH7yiAxZLdvMMaLeAvl1gcDZvJfXFZ+ojwTLc4bpoO +4HZ+OE4HYTrgZ+1vvovSPtS8ME+5kqeU+2JNNU+5zHXqK1ljFOs4dxHGq/kOapvkOzyQRPBdBeih +6GvOxJJszjSTM/3Tudebkodn3A8a5kY9b7of0PVY9PwVDDNV46kmj1lKALHjXKoV6C8JhoZ/KIJA +9uYyn7xgtM5dPHZu5eKxS+lfA0334+fFZ50deAFRrH4GH3jfS3w/2ll6HPbsB2z/tkTsCq0QgT3n +WSbbWSZrjs8SREQpZ2DHcsvDSBQ9TKM4LmQWhrNn2R7LZRuXRCPqfRkxiwF7p2EVdIyXE+Fny4nm +gV6wMWVd10GF+6BIEcV28/XsoL+ZecHugE7GcoYQ7w38AawpmxD+9iQOMGC9tNslvEg/N6PSSHs2 +ZQcRzO4igRs3E3HurJKD68UZ6Mo2PgptIrpAbnbq2KGIeRfTKrAa+RZ0HZj77KyJ3akrvM23gADE +NvicDZMq1O8Lhp71RAgMd2WXxdjRmK41J/778Si/T6BeKIJbpMHoUpHYMxCY59oqwl1kGhrDEeET +pwBjroAfAujSRSPNEzEOAdbzmht2VBYl/42S/Nq+yQV0FVXD6a60qxx6mrTtHl8AEjAkdXyH/9ob +8qfzQu2syG1oXzDy7WGhqoN44Q92h7JPVL+oJGgguyHXTH6RisCsy+P4cF6gUg43lHkQ3FDgrkQA +k5IS2msooa9ENB+aUwAVlN4LQWEXRZJh8bwiArgBEbAgEyA7FV1Sbja9vcM4VYeH3fe1uWPogV0w +rCUzIOTTK2ntQ1N7L3qs/MlTZ4ilcBX3B7RZqCYU+HvqZ4QngPU2apfyOADzfhxHbmK9qCa8XnM7 +dDCY++tR+dDPXWq0XmXFbiEcGQwFD6DdqEuCQI8bKXAOWW57y7XR8ZzH+0Ef6RBzlL8t0LpJxh8o +PWF8K73EB28+kc7h5K81yjOoyTVaIbY+y7IFigJ890Royq72Y46P/igR6sKErF2kc99vMvYMV4xn +b8ulyo9uznR3EoXL1X629iINH4vN8pIftZfDwWuPsgGb5d5QlbltIJwOPqDjg1pgS5DJ8iFOCWCz +qJJ8LekCY4OEufgDyBHaCAqAF+4VP3wOKaFSPlVk1s8z9Rl1B6YNsxW00n4u9y9T4KLVeQEpZaFd +GqiqBu6+V5s7I6n7R0C+D+LQN1/2kgn6eRSmXkyzGZ4Xr0NgDQM11M0/A3au9jKrPj6rCqt5i3na +MVmD7nNRtfEY0zWDSEyC3lKikhRQopZzSLxeaQ8ghmjt90SQnaUBXXcjkFd6IO7zseraZo71nMP7 +BilrnSp4GXC/j0/XQwmptxtVxmaU9l3KaLD+S8Cf1O97j+BxJwJ3BKxOgcUQ0exJ3ChM50rFlVFv +j6OK1ZTHZQ4OTNl7xA+woEAvIJr7FyFJ5toeHsueO8ww/kJnf/4UcKzYNDp6U7WPqGcqYOo/IOnB +BUNw485IDvdW8VLwc8B3o/mBsgnTfU3XPyLSRGEUr2gOsIr+w3EAvtnjqahf0+sYUdmmVwsY6zPi +Porf5EFfreLPKMwGhkAfJlf7OKrFjzt10PBtpHPx4Ojd6CVVio9qkd9w7LnQyGr3afeuv4lTRIV5 +VPzz8xww6th3ABWlFnrTnOjCfjwpTajEhMX3qBRwt/Pz7Lr0KD12QZN7/aCstBS4R+Zml7AHm0jV +kmKYzHAQx15Xu2Qbd7zOyUipPlGp85taPePgUgNEJoqWBdrqUHs9TnbkxvKVoqRdKW4E1vI0xVSd +NPB0/iBvwS2v2vAgZOxXvhAmOr/NXEo+EXVhUU0UA0+ihn2Hyezx1phGnyUjXOP2g0+iBDb0Ov8O +Dv3Sruf5Oj6yqTI/QLZ7FSTjXAVgDyPYNm/TvWqEivrXhWJoroAix2PQFW52rgqSX+i2vt8EJi29 +UA248gIq5MreaiJJscRLfFddT90VFiMtRJPLnfzkn86E3iJkZ4p/AwboHgpskNLsdGw/lADISGtJ +mQYjLfZ7HmxAhbQElORT1BcSC9T8BzuwI5QhBZe2MndiUGiyRu49Xis4uzo+kwjAnZyUqEIpOinm +7ly0BgdGzeZxbNayh4D3MILdmjNBcBvW3vv9mNzilv6RtONLuOahuxCV9EpDiwsj7zVzfDLPiYPI +leukwiCiQdryGnsDUrvWk8xQ+SvMetvpNwx1US8uAoVDLrMF7n7Rbd0PzxBxRI+fr0b3FRl1etYX +ixKMJOxQWMWxdYOnhdX9PM7R3G76qvvPGbklQ1O6fGcZ8DU8QX2MYE+Z39OCAVSJbWlvlMwSG8Q7 +HGb2VV/zevnOVIN7oaOcRQCWKEd7V7PWNQDzNNq6TJsNeLLDLuwLjKDuJiJegxg1QSJoNkt/n+jK +ZiTx5gJ0eeUyx/6J/HNEetyuRq6g1Pt8EdSY7AbySMC6/foCKwMINIGuJ69SEnlA4ffjg4su5x0r +gG5Cou2GYB3q6O8RHfjLAVx+fojXse8Jri6VG7DvCA2JfdfB8fzqikvy09B72hnhwL7Sl2N1bdk+ +IjwTxmsVXc0HyMdPx7m0p++Qvjvt7v3ECiC76bbThhkoQ027aQy+udrh64NNA15rrtkcZx8E5X6U +9d1Q2CXYUAZbzkDO0dKQTGkxFRpi31nHmBrvr4RS0b1vy31JRP2I8Cs1Cnw8BNky+w+HAfuaX/9W +xHXvKzuRE88KDrD+EAGQDg7eo57Q+3D9IaZhQm8OvRfVzkPaoDExegaYypCWGZAdZdJDWw2YsYD0 +w7j5hwBPdEX7+2YUyDv8eRj4S51KsUV4l2GA/IRrINX/UwTwJvjHlxyHc+c+opgvgE5AhlA1BKZC +j8UL/PqddJFF0b4h3aPByw/jFvQt4n3YKPV42DqOOD8cBxgMdtDgWGs2O4agqFfe6CbuffVvGEjt +CLwrqwMmITW79qa7fc70nHXopodejBKeQzN/5zE5ji84zRBLwmOisSP2r3wb4ZQSPXgQ1kRUSCNX +4dbdX2dy2jnjZ5AoGBuXK6eHqTRnaMVKXiKgmYkAZciJzEfRrGrnKyVrQm28vl8JcVYe/r1IqWbC +kkIrkBrnsssGPZEnUuGFasTjNnOxNuZ527fqvO3mJN8iciYEKNpPf05yZnPt5hE3qdKeZqfoYOB+ +CDh2ixeqeO+G/BnVg+kDPykLVH1+mmAXCIysz8lE2t7d0K4AucDImG6WlP/vEZ4JA3V3TPTj2w+H +AcTGbqlrxswF6/F+HSn+z4joNfBExj8jJ/oW1QOFpuVrwuwFPxosPfatrKCHCJBBP6Olo1i5Lfu5 +bX19RrzvaPqD6GSMzyBbuJ1klHkw3XeMST7/2fIK4zwknuZ825zfo2BO+VYgMNCLK4mPIXYRQKPh +kSpGQhYLM2EAcXyCRF22ub5H5I4NZSjuqR98/+E4jYYaAo9Dn6eTlY2TlXHH2pPqde59DhQnSeZ1 +huB8CBKWD3fO2fOhNT918lj+OSIdO2Iu19XH38yAfXcNsErfAXE65RA21Nhzv/abR/oqUeVBNwFg +kBvBJI0dHgcFMSKu5QjtkEL2Sw9h/VeOcRsBX8qINd5vgrAACybowztsZn+UcjH3gjEOjHgnCBNd +RxnSvEA7+S/HDWL0riQerK4LnaePiOxptxMgEpv9bv14nOe8UfvMQOtQ7KMvohsnJcEPEfehy4vc +vr9y2T9GIRylPB2Q5nuZEqPTdjPVnj5op64CEA6Wlu+Ezes+OzoG1Qgdcgqj3TcH7G8iB2LqBKnh +BtprNA8z+Kl2RCcVbnqm54NOMo5OtpoG0jjur+Nmd6g6kTvdOx24oVa8xyWb5MzKKOJ3oNrxfplw +AfXavAkoQMnc7um+UOit10WdWZPVCRdZ8vODdd1RF4nOL+oo2wOMwtINrEEyFqhh84cAdBabcyNk +ul5Bgu9RoMtAwAOaXMlqC7j6STkP9sIJaLU8YsC6vwiaz+Xrg6/Hd2drPL4V/fKvv3KCRTGBgSQN +YbzpJJzrrorgQRXwQEMxx0X6x0brhaRt0GxDBiTvxwTfsnzi7LIUSA08tYVX/3IPnlgwMRFOs3X/ +lwPhlWtkjEcl9T3gz+9ITUDIWkOBlG9BtNeZRu/yeNejMyuKOrhU/DcT1Y+InzbIjyj6mxJdHjkw +gGgGdDxmIiQd+9QlBpuI+2LI4DCjikG5ixNMFOUEB+D9dexwwOKckUKFx7sPA7qVOWdX38URNYnn +jZW0PU98FmnJTx3pfnUdQh1TI9FdbeLLZ3/8t3MiJsAOgugOrzRoRTg5KwZVxGhw9a8P/tF20pUl +nD2RpujXX+khqQKu9pNuytRHz7F+s6EFYIUyDQ8pO/4gQNMPe7KHqaxlSnZrn7Lz0FiuJoKOGRF2 +nbOmJ2K+ET0RdmCNcOhQr2MqQxCangShSfCLPin27fRJBZYbwQ9JVjDN/R55skSwGySiDFtznc4+ +EUHDoP3XDxCrcnaKHKRMVo7THWeruMxxYDp4R9aVmynV3A8gsfABusD+gtdBI6TwfE7haS4BZ446 +6MJzrCND7VHBDtPtwivLBxG1Baae1xmz4R40naUPFQHvx9ndO5FgbjvyIQJv+8PqSAxrMKZqz31B +DE3EBN29lHsxwkWC5r99LMDqZkOI4B1xaKJsOiCaeN8BuCHVSNRil04Evw3jMwaEWsE7cgfRHxTA +dEoP5pZ7imIDCm/Yxz9vy/ACLbgf2kf6STdFs6R2vs9PSh0UVfsHIL5vL3vUDeobBUEQfM0BzU5U +HbdznzGThM7S2/t4XYqp0aJudMh4fVFvVRQW+0WAkPgTQWMHKs9xaZChBI/45+fnQyLFjfZlfeGE +34P0wm2Uabu6fYZPUPCcBa8N4BEtKAikL5jbddTzyFpdfmgioJhGI/GGRH28nXitM//D/fsOcCRn +appUdq1hKRAxJboCkHRhvNEFZH7dnmxR+xhAlTMTFbsJS/Z00ohyjLijur89s1VqAgQ/GWoQgf4F +ERDWEzEyfQU5YAR+G45GOtg1ziQK9YID8XydaTiS5dfv5VxP8c8tcfBKm9eZzdpof/IY+jRwd1cV +lH3T2bsO97DDMO/XUqCACokmMLQOGtWI1/EjPR4eXTQxLdUZKIrq+ATvm0OGSa3daA== + + + TRrg+nnrLHzO05H7ez9s1Q/Z+/jAjihCGXhFEkErnYjbPtG4go3ZEbL1vQKWtX0F5S02jWqYS+2o +Iua1nmenacKTM63iceoSjltlNnlt9MD2BzIX/KAIYi03CKn3FzBLBF3MarBfTTWlOooEXGdPEbsP +s5MzH9bzAUKafuddl1zX++icDzH/ojEOqFqQk0m+YrmyXPa7hdCePK2BNwSYIWF33/49zfkrIMbv +fzMVc+K1pF7gtSzz+fpnGMM7zWMt3AvJucDz2c4thTmDyGyixegHFpVaYAn7vbEovHWPBEKxb8xD +Wae29qifEfnByEX2fnRTEc7+03EiMudPimQ++ACRMPfesxHt+yECIS5OfYM+fn4/Gn+IatrNXr7+ +lXnEmEnubz2XHn+6blZyped/I4rPw80C1HxZGw/g77u+bwdRaB0QxISGH5x11sOIDVLgfiRAQBwY +GtYNQJf+6IK1TkRe3p3pvNPe+eYx+OismqthD9NCmN/iA36NK/zkpkKdLQng7u4AdvlfLABwNG6X +8uf+OpENPFAmTdh8O90BLPz4szGVDrsxE0FLyzyG45DHQG3lMc1EitK5fQZkWfiWtn0eBiE48Yd0 +9r13lG+2k0ZHO/gzwoegn4fgRXh9RFEomrNOREDGueB1LviMEJH6YYTonH4vjTt9JIfdD275IeLP +BwvnCGYhwUHm8XEcsFHCsdG5IEKzcx8qDTLEHDkeWVML5F9gXrAw1JeLF/pPB7skxkrn7SCe6rKl +Qz99ndY4qHpa42v8ENFrwGaqjLwoiI8oxFzGAVDVKYAKI0RRX2wJ4yDc98nusCFICflZsXie57ce +0kMnM11FPo26rAl2KkJyMtSMdurbZXxoMccPScrGdIIILHJumGYjC5sr2g0tefw+UzbLAaQuUQ/J +5C5SoVV6HA5LxGQwR30iyv1GCa8kwpqaa3GjIkKHgf1cvp4upB9CNIDnXW6y4/xyUNxnxsO299nL +HMHcccUFHVaXI+bvEU84kSAAkU39GvD+IYo5CO84c5BLTscIQM8OIQvrVGP4dglfpHf0n+F2fET8 ++SRN9aZg2LVQoa31cRzUnWksPkVbE9u0dKSBtk7JYh8RyLz3L3TCHz4DgCgMF21TYVvKK5Kzo7w4 +A8U/cG/GT3lR9upO+tf5u8+Ir0UF2grQTC/84zjoPsjWUfih5TolLivrt7LVDKlA+x0p97ndPbd7 +vFP3DttbPkCfZ8YF7OvGgsjqjgC6tQRQcQ7lMYoRw2eeE5ndIAFIGwnzXZLXHcGg6OtEWbbPEI4m +Lx1Eoq5yLpj1hgh0/u0CX+QAgHtKwHXLeRxwzifI0/27FSKeL6TVePeHKdqbhgaKpTCiWKD2rRsn +w91FeruGQF5JTosmMC/K9wie59wVGDpvofYRhc4Xg3Rcr2ja9N5SDcCdZuBBl8Hm5k12GfSz2AD7 +M2Ri3wLy2PUsMruaL0KGvx8FvulDqYImRwkMHxAAxVSFjIEeGGp+fT2HVMKL9BbMpR+E3l6wsBeA +wRL2AXDcU3IF873XJOH6dzjaoKUH0jUAieyxPJMnoUhfWYe5xJ+zFOKMu/ez257RHfARrTKU5OiE +UBBYmLLGDktgcgGSEP6p9s+IAKG6KxhjiP2YtM+opiKvGLdKpR1ML6deGg3/FIFEm2Dc5QTunOkj +6tFYF2StI2IwWOL7nwcYaA0BSlgxIupMlZkaPM57SD8TUb7wdft5IFlD8GPe58OArSeSEv55HgYE +Ow8zKpjgQR8iN+20CXgYRphE4XjtlefIABvlo4HSgRdaQlfbUbPNdK8g0klos35EkIPLsi1bcy0D +/DXVZJk5hi2LvXFdby/VbtAUqFqTD0EvBmvJ7EEzHFwm/NYPGN3b22oWuRCseH6MWH/zmpb88GG0 +Xprob4h7z7WqCPj9HFOpUO8Ov0E5Ebee0p8RuVc9meKzcgN/OM485D9pNMXrA2N1rxnBHTooh+g5 +TM2+o+h9UWKqY0NnmkN/j/rbczlwNOijHJJdJsNsDkXYu1ZZEqR2Qc4b/azM4PbaC7DnM4Jh1nSx +3ZvTfAuojyiMy8hVEC4zTUKPSNaHU43mqEp+JUqqNr2wLRjIpeCB+lPEW6rByKNPSmP3h+Pch0a6 +GMA646XjZDN5Isv0GfGxPSe5/R6F8o4kB2ygWpLEbnObUYcLVzksgp3/rpJOSkqHqwFDdcF9yktb +aEGb0LbDP4xFF5QatewNIRAYAyNEuslYmZqYyVvAcWnVTH0v7ddRpjgFaTVt6Af4525e3PvAVZPu +KRWKfxTaJzkNcpSIIDQkNzr+gkBb4OHunUKuPyPuJnsOvHzN5idyCtoCfhC1SJa7WYCkJSCjJyUI +QX1GE/1vxN798Z8zR+lpaeixwnvx/W+PyyWpxpAJzCBhpIuuCe5nBNAXZnLoOvR3tvURRWpw44HR +kyYPf5PhCt12AsWlyRocNPkBEQBaYUi0H+z99c9d1kp9J9V796OZFsQzA4G9Hy16xwN22Tq+sRiR +4N2OBuSFs5NX8Ffwfy9QUPL/JwW+QEn/A/eceQbA3wWpUTYNc3gqs/2e8+7+hxMlQgiR1SLfpGuS +dmN7bgrJcZrSZ5C5ixEhFA97X0bIU2DYFjvynqbo0lr7LI/POogXEjvuvZBy2JRIXjA9RpSGViSt +A6TvqDEoOXD3xUL7F09hUrBrhpyG8hJiuk372heMAQaXGOZnBrmq4UvGcLnU4JTp6jtjom5l0qN+ +ysppKqkObPt1zoMQcCrbvzgRvViihqhooqQXejdyHJy5iGi2X6ZmP34wGBvzAQBUvwjwDvC5zxdS +Bvwrufquh5BghB+prfSuphczqoFtQRAQcij9KTBo4aeoB2kWmiabaXOHGAw3/nQAMpR41D37708K +AAR3sX5ReukVux8imu9VztbODB0378wVxvWgowZzhH0NCRhLpUUacYHOPwNHnM/ZISYaK+0RFtXB +ed4HdbT/Mf8qrAwz+e4YthykAC0roRK7WL1YE7GlPew5oiRNTNamkfvuNFT9c/Bkl4AyP7A4wRiG +mmey+858AGbzxi/zzeOM4jB8SI96oa22E2YHzLcnpEf1nIjln1+I+xAhdo9kN6CmIIw9wZtdCcdN +cbafMu7mFTvVWyfEK0AIWzU7X2qthPanCwzdasFNFez+Er0oEZcE5a3amZdLnZ5q2Vfnw5Zpc2jg +KfjAWZadCiEiMzU5Qi9YdjHDDgTqKlNEQ8Op8zWWmcEcoN5Ij9hVvnNGhgcuoPCNpqyrJ8iNkmG2 +5CjKIhyjL4BDZ5o+Jzra79ZwmFJIZGMHz/eEVkx5i9VAbjXkuRmvN0GP+wtTAEs39CmzCEZHoAiL +ZGYG6nfh9PLiHu5sjJQZtAKJwqMyYqQO7e8DPkQcbCWAbrKNZgx9UNNXb3LXQ5okcaKJ0+uqmjF/ +YUZE8zKfpIIF2YP+wuS5F14NU/AC/qzW7FBrjUtb+6vXXAkKNR5i8pwgAAkSna7SF1S133kqUVno +JXBQ1/aJcCodFIpg+kdwj4UJ48bnV9oVNmBBfn3zh/3r935AfrIrpzId72NwB1DPW1p9T+/0C6Yk +fvY/Zpj8jhj08o7Wkj+ZWhDvfwCUz8+2Q7GOdfG5UUiefMuz5q4rmxotC+BWg5EDs4i5C4hLN6vz +q2HqQ0rtvRpT7DEmfz54kwkXatCmUWC0aWRo/7h+Q9Nt2M63DRXJYxYTuInD/jjCwzsdF2A9srS3 +HpbERCVLc4qhqNvtwtrT0RwaUvGWjaLksi86Ey/wTEybhi6o4JXhSrSAdxBMBB3zsBT8o8e5QpRW +y2QGgUN7HS3qy2XhyaavdP88Ea0J75n+4k+GZVPQUMl5/J77EOs1kqhPshOfMdefflb0fTWsEgQI +PJn6zRlgXx+7dy+NCDCUsPDwRiLC8R9KhfdpzgkBZsqHqQzeOiC18gqpVJobQ+rG/4XYect+ON/E +Kmiiy9mzJCat3HnLelPAShUEmGH5y7npoPSEr/fzlGgdOGzeJdpM501s9tppZLvS1+xq4YE/OURm +rMNJrOqr552kqJ+kyJh0qbq03aRVbK2kVY5OOIqCCehFXWHX/tMJ3JsS/igDBfCD9eSfZbYdJGsx +Y8Er5fDsQW0IMwoLpeAcDwSeSeyYpwcws7R3qzEGAj38Ljra8LseHsd+2BQkg/NdD8uBgja8mGo+ +pEGGTqDQfToTrN9I9ZWgqYuYmgdTsJmILqLwQm4yOGmyU7xfXz9to9wHGjze2yQ/I0k0gHOUoCMv +VCzDsJt0LqS25Dx3S3UAjkkOXb9fP5mJFD07Jx2hw3ySwgC6boVhoFwRTqPd+1NjSapPJfmavP9H +Kj0gYb8IVafz+3qE+Ej7eko2JufD+6ymG5nY3U8qLSech+sJl+qWD0nixBYC3jZmFeR2zydPK+DZ +fuQCKr9pgmhxEDRsmzZFiQi458iX5sWVzAVh1QhmH8iuIFhHRJg0Ts1fJD1MmpxAH0+NvWeER0yy +0VZqfm4xvz9H3sqjU4ByfqoKAnSs2wH6Qfz5VMHDlvEux688fhNR0geTi5FE2hYGsw0HjjjZWj6i +9n2SwH/yzfjTv+DLKNLo8fHdT7GT+72VA6G/tSdbvodNc4wpYqnhY0IUz4QAQeojW1sia6wiU9uD +GfY4Uu/QE3poimH5kdk+DFRn06+UqVG2kp7Y2nU1ugUSoMOwchzggByHbYUIsKdEXOUKCEslBS7F +hk9MDwERoHf+RbMOcGbh3nDbrRAcxaEUw6KkAkWBsiqYUyAMjubQ16ziffJkhNs/D7f/VUID3y76 +aqdR6N5T0ERTCjnJarfZPseDog8lJxmRqNq775Ug7xobFu/acEKBOU/yVvqL7y3bb+R+m4liCUkU +rT684IHfu2nIMgOUtQwQdLHXx6Upqi/19BDorhrh4GqSIZX1+0Q4x10CPHMi9DaJKjMc23OVSYIn +Rve5AKQP+UNs0hPxuEH3V3ocCu8uP0hvGUFnF/cHmYB0+31a+l3lb6osD+Nscx+mw5DuuYPpCna5 +O+36GmHVeRqeFc7H9E20K79ErAbOlxY02fvyjaenC5bD2+4ryv7/vrJLF9N37n6lxrVTdAeOP1Th +QB/NyXB751JhtnOcCGw0fJ8yVuxiIRYXVkLq2Qs7KQNV0dfkqk0bgqicZQK2bJwUfdaDMFKPns6Q +BK6S3AsB/vUEIqXLvBSjeipZBG4WYNIXAQSSgZcNJMM1UhQWkO6Q5ymvuTfpk2LA+5wIZ/UXHfMA +QuU5UVDffvDbhcwJqfRwH7ZTdisecumm7Z8LBIHMPE9ThZrcC31OQE2nA+t3/l1Hpvf4l8DBvWfx +LFodF3s2vdpBIuJhKih1p6fV2c95eX857zpfjFRgwWN8R27766MQCntHfMTc34XfiachIzHUHI1Y +TlUcO4ohA0zD9lhiGni7t73XjaLfY/lhy8SzP7ZbLoStW/A1IicQSFk2V0VesY5N5w== + + + AHgG3zade/l9WAmDij5nriEck3GREy/cHhCJYdhu8/WOoR4zMtbkwFYcgV0U793JAuYVTBbqqzKE +mn446/r7CuAgO6IBxxvky0gTHkrO84oZMSpBytu5HaK8V5Link4R/NBy0JXUsQgJ4GjnRTyvOBI9 +9O7YPDKQJLbsWPdJ9ZZuYxFpyiwB9xA117opJF8VqMYXTPgGYPFQ1x6NRBIgcNnNTjgFsTDcOpAw +E9phI/fG7eygypSfQZGZZFWkjy1lys/1fMF5qyz+V6NsdOkbjHOD66unnGTcL/VR12EWlLD2I3F1 +3fEAFKWBWSDfmnzk1VwzioE0QlgiPhDpPNPfbOLomIHHwznQviEwvf6qgfrv77QrYlfXEbtqkfwk +f8xDwD6MRDq4Sj64nT5j7xHhAhRkiYA5kOMObu4CTfeOm18cM7d5BAaFCr5kaABkupcKfNeQ6EBR +kpT808nNv2Rdg9BB0SxNQk7I5mnN3/RkTyqFesNAQKFX3W70JEQYHJS/IgVLWwGe/qHIcdM6gZVI +p4CjSFKKoiVDG/F1THVVYnjV4IjqXE+noZIohrxEySxR/ERVy44yCKTy+7CxlRWM5gi9g8duI1I4 +Kz0OI/orMbIeYUjPddCJRnnFHW3unInkmogaxcsV6XC+ZD5/8o2uqk23Khq32hKjnt4ATHJ6OvsO +Q/WszjZ2hoKkxt7DSerhmiNOv9do9KV2RBNJz5hEO7YL+xu/SI0VFW6U/fQEVJtb1FHVb3NYZXxd +WGU9GhAqfkJYvlVl0WlEjkEXRa2Bx1BEtQEB2z+tuI939uzkbkfVvhLVcx8ozSKjpGbFo7vLiSCz +ZCrcjtBSUteHDtyJQPCdiNmfrzMtsUcoopOhr7zLRoH0JEL1CpABpUX2FYaJV9xWeBNHTKnil5EI +rDRA4bffEjzSJp+QhVQmSOUG8ZTX/JpZ/fdbQTkc6QMUyy+B91Osu46ozDXA67OG/cZpr0O5eRiN +DV1Z5aSW66qkKqhfoZp2w+2m+dzktHBXGREKt0Mgtvtgvty9PvvRM0G2H2PF+ziLwbhpKxrFt5oa +jT3gsRqHgrpvyN6yS1ZgSwAkgUS/3nUiheSKjhcWzdUbEfUrnGrxMlqphrWsgdt+rZkzZVNHLAl1 +CoTNeWyR4OWxhb71BfMV5nAjuxIpiEz4JgZmLUj7AYKPp1u1sREAO61QhobrOipjVF4vypJhP9xi +DBuVRNoPB2k9ScIhJPsqUeDfXPW+e9PR5gpwCij4014QxOlRICuJTZZlk6sKiIIVUQUTu6V2oA9B +6OXYjTLVZgIBkRhUhjgKNlK5QF13sbM9lKNCFaUhT+SvR/8ezjWvycwEtlxqUwO279EWMEtpzBVC +VwGZBomEmd3X8bNbArUo2VUwIYDkM1PJrX1j6NHg7BlwiMg3UnAmVcKe6BTvzXamAzJfyhJPzTmR +ZlBg9fgx2/0ZxQ15LGHgbox6SPpqOylfkQirY/wMetpTZmd0uCi7/3zwTw/iJUQ9LV0K9iCiGqtQ +zpT+195QWAHYe6pfJe+y/cNcQkhFTLnO4sNP4HgCK++3ueS4CVKNlAS9w/kzxiBP1k+RvPuDqGeR +TwfSg5wiiCvK/Rz+FU3qMCCDL5H3/1jv5GFz/I5NZhMQMzQqAcmSR6llMEP9NeUczYxmn9Xf/YbE +Qow5VEU2cIIen2FkeymjrsPrR/qztJwHIRy0ueV6XPPwgCCFK59ecLv7jeN5Qtni8QgWYCzXl1VC +6WtUEbxn/Y5AgS81juvY+3C7FAnB/4gUCvk0PQXZD+dRdyBHta7EWDUaYPMoROXNEb/vAJMbrTkB +Utrq/VzOyQOfB0OIs2wVEjY5xVfxa68ZE3sX/wmuNjIgIdGhk8dLvV8n8/lHFalu0S454/EGPSbU +nQkpF/uFkrlmhi3PEURWFuumsitodEfjg2SP1Ttsx3q6/kyvlFi729Hhdhf8BRtsHe6+KjP3FVE0 ++bPYtaryKodo+dekqQAthI0pZKcoFeZtShjkDim/BQsVzts8Lux+SMlHE6YpZwCgj9djlxH5s/uo +pdOmQUkQVJcE/4aCfE4AsIGIFqmQdvQqRPO0rzMJfIdffNTAWK+48MvdAGDJiBrKo7q5X62erzZC +fd2bC4NbkLAlJ7pysc9bvJMNjB5NDMHuPJQ9KtQwPGj0KfLOxnFFmMmGCeJLOt3fQ64FEmTPemW7 +ix1nHb+foxCkLQ6/KoDFpn6YWgO1lqPAp/3TTh6hFbrdgUtGquZ6E2ZdKfce2r+kKGeGrGq1YDVK +coBhA1lrmWqx7S/W0cGb9B560uFq7cugZiU1V0Kf7kwNHEcxZfLM8e6FRKHLfGES0SNTOOTJtdbX +SfF3XqXII/qsRmhrhvrmpW5nPU00LGN92urJVtCXOl3HZLX3yWrVVqtnLtJwpx4ehyG7w4jyJCIy +UZigPieAtvpQtI/P6eXRQdlJwfMX5+F12eeZ15G1AYusMSMZWHS7ADoyAAvf2hEeX4sXDIbPIEdD +ooSne5WjWELD601jod2rD06GYXXUxFE1Hf7UvGtoraWY6T4FCEsWmfaAxlCzjOV1rJF53Dq345xg +2JcWaTUOHmuokISgtIJfiMSBw2KNNwG4D1+bxGFEaUtNOPwS0nJFa4vt5ErF/6f/Ki4DsAu0CGiQ +T6+YuANodclB1dUCEvNFAclXeg1YdD5+R1LrelLrQxrFBDVk1Ost/JbabXRoeoSjeqjNYAzvAw89 +uE4Ygc3CmGqIgREyg/ZhsipXmC7NztDpJCBE+FIdkxpKyVw5jEB75nLikRUKYbMAfdbSngoVb1yQ +NVylp2ostMnK6bpAJFK4b2/Zl5yrri4c3Tj3XUgAZDAA4MtKP9MxHOJL8n3szI20QkUyIS18nV4L +PQsghQ9uTjRMx6sHT4Nl5oTywtghbd/PqTExPh240YUFDyZpWfUtmrhhii46MrwH8JDAI0nZoo46 +VhpKuyNJdKVbkq+6f4pGc0hbDVFwFem9o974UxTbH1F0ihMxE9GvNwJOBxFfZ5Kzsr+7CFYiQFq6 +XvXfZyL/knwwo96MwoDPjlrD/QCxAHxcLSrXEfamkhqn0RO2CAtsAmYuFoO09zyz+VdkiiVo2TtH +KRKgkeZrwa6lOrrjhsGYGpNaI5wW3ZqVRFlBYA860syL/3TKpfiwAIJBkAEjiKoy+Wm7zwOBhwR4 +cyYR/EJmqaBTCaqjBnHjGc400Yagk4U0yRdzqUrbbTyC06iwNDSbfDyMggE4ny5HDD2qCeM5jgJ7 +YZBPpD3o+jquOd4NjarlrwLx8twyppSHbqZw+WMqawSVhAOjxk/2FJTHObzzAJzEX+FuXB/sWbPb +rrg+RCIc+y7eXpzSS6htTSTydzw4hfZtKY4MZvvBycKfhA0a+Otd9T6LpHwJyy3LAzsdN/4+xRzi +qUjHctWq+SNM9XbL0zzmFSs8tSKcJdujKim1A+kGeXaNCW8sHIQ865wnuadEp2c1DRJsKgynenvH +3ov0ATnP0JhpuzJ84Kdhs7AiuucnbnTQ++XhIwNTP4uuLinpo7pnmH5QpmT6vXqSZURJfp50XKYf +C/0Npq5HL0zwqXoLdJnd7ngKUHO/Iton8njUY8E0QnHNCbpTcD8sqr6y53b/ymIW89vx8vr8Z/UV +JvX8abFOJwlAxQ5252KcIKiw2vDde+sEGcdYFZUGZ+gq1Vf3V9ddcaA3sEnQPageizzZP4W8XoZd +Payxr8yTKOVpiNKSAHmaJooeK5DqcUTQLSRw0fQCNeUgmQLQH7xGVH3hCdpOBNK8RJDxv2e6Ithf +4swj+ir0gb2NnCGeqAOU5ClGuRYR46hg9ATQniYg2zHP9Hv8K6S4xe4rNX+vnSNmOrdbz371lcGe +40yZq96uh93FYrd0QdUZ46xEJJzI9ABUU51hZ7KPSwZ90hZwvIqOyJnFUGQGsYdO7SVb8z5rVa8l +JLRpU9d2Vn2bFqImWfN6JPRkCqbJz3uQM4U5Sv4oVZw0jBkT9BXfbSJUUVDPoCFsVSRGAxg53+gJ +CmwpQ3XLbEzfAX39liXEATIqpLSB2MFBUoMLlJ1MzUvLEUCzN5CJLXisW2WGcyKKIx9AxDl9APt5 +PykmWEvucYgOCy2/AAwcB4PQIzVgv6MJCPNvZVCxl5rjFwg143gm7Nxl5NWuUgzGvnLWjHVw8Ddq +MyrxTN28b+V+Riix2dsfBiPSs397EYy0dZeyJuFu55fFhXFGoegWMGZCFYq/7Lnb2fvPx49KwH7e +doL0dSI3lR203937kMRnSOJmp1APmK0urGPKoZEnGYuGCRFRHn0UUU6EQ699jHL0PHlAXF/vC52I +jCmR67qTZx0LN4BiKCqZW+Njo4POVM/HncVruYugE297CTNaVuE501HpJX/opAZ2ZEc6socosJIF +35IYqGI8SoOCMI4Jmqx0LTd9jy4VBnpFGuHsWC2AQZaae2apZM1R51PwT1NLxa8q4ZxlVaWbh0YV +rwr4/Rp+PznyuxMmAYKuxcNlj4O3BqSESh89uBQI01EF6lFhefBpnRGfOMn3YA+VzvmIVu96mXxl +VVp20IR2R4DKQOVGFeVP8EpIK1B9qo4k8TDIQyEXT32D0brTf40Ezq3+3u/NnecFm5t12qvuCHuD +qkLXMR2UvkRWp35jD8GJLgfWJgrl8istyngLlUvL7lsGwOG1GjWTs+c3h69weOGuyf1gloGcQGDi +g6ZGxvWShOZbGymqKyUD6GbLOU3Z3dHr4T+jlwpjqqyABiIvA3YHQxyth3NFSTPQLznkfzAdq0uU +Qtw81oc94uKs+reYA5oe4GCWfHZsXtWIamJ5Q7sQYIkTy+nGpeQE6PYKWwpntI22n03KL5q0repz +DR1SMXCWb0Rw6IsoaQZqW00hwfkz/IrBv9Q0HOcIcBKW9kF3019RdXzuJTH7+l5mrWqCsR7DRsk+ +DtTBoZ6RsOa+sg2D3bdCgjYmSgaS2Iu8rwe8frTOMjm6z+SI1LrNtMaBGM8nh0lhORAPHEFZg1Ag +bSkrQ2X53CKfj0MW9Idd1ANQ3U9jO6JCsx+ZE8UYX8oIE6YZQRAWRbtLa0VmcXa1rKeOVmhaQHSn +rf4iUNRiVIe98BMmyl64HsvIgiKJrYAlaqL30caA3e0opp17BxpjR+y3rCeiWNcONFl/swlUVabj +Spbd0Hi3Hzb0SAsAHkB3wXpzGaEeGiA6VEA90xNGwpTJzXDvUu5pPzvjpROM4BCYhytaxd2EfcWq +UKP+6SIGuXfYVT55OCYucIOVJxwqlB5dm1aS6NIfeJ4XbP6yEu5ToLVoqtJ5HNwJdZHVqISw0dLi +EGRPV2soEXzoxNOEpnwKxnydya/EXPMo+tNspJ8AtP3XqMdEy0nzEw4WfewPuB57EALG2psD4/nT +eeDC5NgvkRoYkM6V6EG6/RCoggnuaJKFNYomJxFsryqXu5zB50eyET4/T/RLJJDxiQ== + + + nE9TLqu/pNP9o4+QPtzI6YTpCkcZFl2OJaRFlkoPvaTY/bmf9EsWZnNfv8qKjMzkqR0BrAcUJrGh +++u6mU9BtTH0iselltJDMH/evw4dNfaBgYftx2N8PdLtSLXXqcm94HnRax21viLZIqr6uwiYh2Hv +v7eATBHKl3BHL9stZkVs8T2+4/4ZW/ckqRqpCvZYHseCcq93td7xhnS92RFLuYje3ivY2W0/EZYk +C0uj8nUmYXLogYDUM+oIqoOUmuA5RUohEkHlv2/EOAF34u3ZwOL/EruneVaSOruFLLr1PKxmjAqU +sey0CDCI7uOl8GlDr2ZcCvQqV8mNe4lJrC8t9pQSPZZUkyeML0DYPCVBlwW9BtnF9AWEhijsVXSq +z+H6MYnYqUD6QE2nckqja0oWW1GQwPNu2rNirki1sHcSCmy+UXZCqMm6jl5RtMLv8ihTJAhorUdZ +CZJ/ypO1H4O//a/Chas5ANY8/DuEJRe/qMVGMS1/rQDKHTCJJhFy5KQS8P4IhydrvQ7YBvaShT/y +Q8yjFRwtJvxCPX7tfDZZAymawiP7uv3VVlAQ1k4tZnjX83YEMKHqyRgj/I5Y7503AErZBKp3RDBc +9mk8CFIFcNzd/9jhk1JaMiFFeX8pzN9xHgS1h46yVtNVsUkFTgVwWvFeaZWQUdqf3JsHjkcmeqng +8Jtij/9Jw0k2e7pfqBEfwAx57NOTEeyXG5S/8zRarY+sJFZEnCTkwe5qy+kJsE7GHPuZKAd6Twd3 +cUN4trTiUIXjOiocR0hQJyQWVm0BhEwwQzkI8f/jlLTSEh1qMje752FOVGAt4eU4kgB243AFWtkI +g9+3nQzMQSCYw0DNLoi3p5jp8TbZb/4QUEAp++j+yVgr+lxd/b7BHB793yG0DsnTYrWxHxX3PziV +N5ADkmNMcBhhvCohbIFi+/erCujg8K3opy0F7q6z7T/o32PVM2owJnvpGyL/6Og8yn8gpx0DlWPA +F0PlPx0Iuv2j53Fyoc1oNWo/+uXMYKEIOyL1OOM+Y7K9vjwS5v8aTO9fEhT43/wX/Oz/2Qf6K670 ++Z/i//zkDy/Jrz7yNXjk7cKIyNBqq4duBcfPBWoWm6/fYmTwuTrP44RGSrHC/cvODwLJgdA8BRF8 ++5d+pZlWCUy/A/7F0YWmX7kjCxSj6ywNJkeP0+LD4o6y385xznheUgfdyC+O8I5q9pqrcphG8ToT +VbWvIQKw9Y7gCgLmmWJsVOdNBLMaj9FyDLXm6COUl5HP9TB52FHFqSmtcpdUxK2fIPcFabGtz/Yc +gEtRphikgxHSF3YE3aNEkJcTcb1bcDnejzNKRuAvQtNVt3vtPy0BpqzxZCWBK0uGFMY9+RGvOt1g +kTwjdrjJ6WZKyNlFXER/xi9L9wAiGX0UM6TCqfqngRVyEqqTYHCqVDgb/U5UGevi4pYz0QpGDI7d +Vkdj+iTMcbAXY9OA2esTCuSkj+DQlm52jAqvEG6HO98CMTF0QIhzCICBIyoq/5fMf5wMwagyw9eV +H773m3Fc12OhMrI0EGFGi3BB0z4enXjNWtpqB3BmlBIc0BBmTpCvso8qb50I8XlqmNyxahBMM6y+ +cy0CKvtZewY+zu9OzARwFyHjhpAb1GJWub3ZMbNH48N9itZVYAc45bIF1R45BkF8QgTJJ9pnhGc6 +4iE3gs7l+eEwdkPJwmGWBHASn69Wi8zX7wELfjbIkY6v4Xua70HDnZ+hMLimfZSeec2or+ciLIP9 +kyuVDsuqHt3784GHBSMMtmgwYmZReP9Kjx2kVPoLSUW7tdtRrvLT17GuHMepV/zP+8rxIdNOZmc6 +RJEWBGYDo+jOn1NdwOth1SAC4BYR0/ndWinahurTiQjeGDWjdxlZMeymh1bWuYxRwB7vXYmx+0DI +Rx+2zgwx1zJq8TgFNA8RdnNBfvcYqUCFIKC9o73BI8p0eC8kvQo4eQ6QDFKFhzkdyf3qwAwIAhuC +/ecH/UBTZDe93+R7FFq3C3eguZ9r6hix5STCGJi34Hg4Ak/GtF3F06dWKzkgqCMj2ok4AKEBy+z5 +4cMJXQs6Wkd5rAa+w+yNEmAf/ofPf3hWP6MesLIKX4O02D8JvNOOMdFV4ib8TFWLhybFe5MaeCQc +HbH6Tg7hn5DrD7Qt7qBInMhgQN8oD0AD07gZGNe1tENtfiEhfB/IgVFSgUlXRN+2A1Rb4qtzHHZt +IsYVbS2GbXwg7mdoQfek9fu+THosVY+718T4ahUxxOwqaEPYiB1EPMpbyev18mDZTAM0eOQDOduL +J+xs/vdR08BSV5PHq2Se9SgBkZdKUo984xYi504yBdqCyviFJoOdlVgrP58RaSKGtv/555SJNrAG +c4QwOdMcp/tj+XkdRQJEKA6KRDoSeUx/1Vo0gJf+D8TuYE34M4GidhGvIAEmoi/3yaQ0woGgQlPu +r+Vj/2QS2qTNPP88xr04CPvxrBbaDPUDyYI/25ID2s100H44phQfqV262KrjC+EEdCcp5Nyk6nLs +dqqekUdJ65uygqYDNi1uczuDuWp5YQ0lNkP0hDVIxdxlap4yLZuMEBMyHhnWGsSQzBdIxqByOFPg +RA+VtBHaepArXS/8dZQDwkFee8ZGZhwClUpRNK7hNfsBuFiAmyouAAxS1XZKK0wETkc7YvWzj4bZ +VA+zSbeY22kzGIZQn2qc05XLn7EZ0tV+X+Z+X4LRigP5op17nBE1T2tYwj9fLq422nmPoBOKItWE +DUmDK1rnMf3QT21aw8bBETjtFXnqW47fvp4uuPP5m5R4NrD6F+vCahw4/hwxpWJaStTV0v119+Uw +2Zme1zxtRo22hcgkexSgLRE7QNvggZVLTnQfjfKn9RhTPo7HVeKmWUjDHEyWHzB83n+uRJGQZKWW +qeF7rjH8lAL3+NXJP06l1MFSdQCbjIyqLeRZqh6vj46mLwQdl+fXX39l/vQv+JpKSFEgt2paJ0on +spMVIbmRF3SymtNdqPaujAKRRhRlvCO+y9emgpSqB63UglZqDkNBVV6eabinXS/gqQ7bhC8eqGjC +jsLzPHgmQWewatgjQAy1cT5g26493cd5JCGBfbj2EmHTBL3+r2lrOTgxXpMnHPmioieP1LRB1i4h +JWYcpxMM3oh+U4lspXTXHSTJ7SMiRdSTmekMsfUzSjEqdT34oVe6UcEUqR0R3ZyIbjRaRhGiGTa4 +6OS+eBGiELuYvMojNXPcvaBp9DijuVbMo39PhNv8dMB5GxFhH978FX0ipVCJ6H9pomax3uSgR16H +Ti/yOlcOY8mFrkg5ESxZRCzPLAk8Zjb7a+ZEQfmoRfSKmdSsTAzN1MGqrz4RKr3z6Oso3EVSLMu6 +H6TeLibULGqvvWSHANyCvpFYyjDs+r2x2pSd+JX16NAEx9XBv051TVTEmUzb3w4yA7S1zx3bwI8I +UPRdEWQai6cV8T1qheinJibMLm0DI0gHoe9WUlPgz4LrcR/dpMxl2GvWZ8Sfz9gkEja71gm24uM4 +B7k5+aYl1xKFsxm2th/MQCTD0b/Ry3576R9RMMCdROyfH22w9s6wtJ4pAUBK2V5lP1/VzEjNdQbT +Yi8hU2hRNX3hv9rsqiaChNDeB5oAqTsinqMlw8rUbUf0Izur89LCS1BNthdeBseQZhBsBVX8Jko0 +6+tMEeSiR70OgXwYNe96zhTPRlrKK6qpDO/5skHOofSuuNEd2hfc83GYN8NNx3u+k+RzR/hvPGTV +fqLNmQnjzslPL1adY+79o4fc94hDWb3tKH/Z9n1EXQcsVArAJL/JsHu+k9ByH4SGaBwlfeKEqXL/ +t3/Pyvb6bO/fU1rdx1+DjrChhRsaa/OCjvH88AEwXWyXgOl+KQd+RlFcB/6kA6qKNiuTMSesC1zv +sQqNE9qRUEAaOvKGuzCvx+gsSoTjKBHeUQLITx3xcGEZrFK0OiIH/v1hQMwlnbSLAtx3Xgr+wpP6 +zZ2eQ8VCWL4ctHCQWCY6gZAVp3TtCEsrbtl8Z9M2pJ1Z4iaRPZeh0gGtA+zKDgNI+6w8S5yxZBwn +pnrdoR2gvQSNHbHexy9M/OuTSEm1yFa/bgJ8VgKFvQRjwWOoxxoCkA2WDnVEj11CJhFtxfQhSvbF +OUKOX+Iu9+VmKETqzp+jmeDJBcTwAWAnQLgKUe7bBs8hf6F9R1uxr+gHx3zp3/aFRuzKsOIB9Cgz +1sx5qecENiMKyjznOWSAhauoqMS/lhL9S9ZJlDowq6FIN+eIzwqAb2+bWOsdBj+tXjg2gOXYaK/6 +Cr3I0T6muS2muX0dGRfH05Wfo/mI09Iq4p/SdPZ5ZfhyPA01I75NZvt1+sXNra7iaRg7Y2U3oA9H +T2YkH9a39U4E5ZERvR0JuppjIIj7dSKSNQuGuycbfI6r8j6QZse01V9UusDzwbvpNTI9Fcc+/GCu +9ZuIFlJTeXTdtN1QQz6U3YX1qAjZGvUzTCiLJcBQiYeaZVdzXVicalL716A/mMM3sW6UPgVELy94 +MYntSCKGEsjwm4FaHmSzhetkCyODObYjNbzqzEYg6nulfXhuUNM/i6iiKI30ydsoGKYZ8C21kTpK +X5lT92yx/HxnBFjCmnbiRbeLCcaOaC8u0Kin2ALfF57ryaIF1LJGlgxvduXVWkbzgcetAJT9Ss7b +5zvoLwxczz17MoKRFtZhZFy8uz6yUOgpbHSTdTVb7mZrPxvzh4h5shHzr9M+S9Q6Uc/LPbI0ZnOM +1N2gC0NPawk5A/HstNfc4RmmjOefXUCgrUuD3Q/+IkM6fyIH1L7CCJgIStyUdRbWUIt1l5Y8Vd4C +C95vW0YsxB5qxSeWXUHZ7m+soSbCI4rotzSQOH6E2BTKDNVcPsROLC6JI98jvPwP98LvUXpkDtYc +dCtY9zCotTcC4mK9ETMRkuN1Wnu1Hr5/CFo6/AduxRMassktcso9fAiQWisCLRExZ16Ep5V2Xe/Y +i4in/Nb1MS9DM6efwzAtN2gGznW8+UZRnU03iKJHw6WhwUfEXTOY2g/bX1ro/TFIh5F1HEben0Kv +Dh69Fbehyhqyd2zh6yZNPIlnjvc94H2wIpLRen9+CGKyLYPnoWtOxbtaarMbheZ1yP8SvPcTYqq6 +5mFVPWO0v2Cs51Z3LApTTcQDgwaRdo8rry0jAcU5nw5U0g9uJ+N7PZFz8w4NdsR6Xoh0uTO6fahi +9SxcMYNZKGe2oHih4FGErmvkTOHuPHDoEpGnGQSTX2W9UPW9Gr1WVuLd4hc0Wc4taOoLHZWLSKr2 +BJhyR0uKxCjyE9bBvMcHIP6HiPwoPS5n0M8iuTQC0iTqEe03QwZ6KlPdpN4OmPYdBDL/U8QT6K5Q +mtfF7iNKSkU7lIoRGqSKochRxbFjnAwFPGKNasWjSEXDg6R/RuSm0f7oirE1ZQA+j3NlQsOF+Cs/ +rvO8XCzDPwTUg56+5ttP+R7imJCHFRehOxerKztY32J783R09mZYnCag/KfI3s4AXQ== + + + O79HvO+nhnGILSil8XGcPiN+i85lbdkt4orZkGv/KYL6KTimfbP7787qE6Ln9Yize+oRJNuZwV3e +xvlI45weLgUFWl2YMGG5HmdVVK8fh2o/ROTmleCTHvLN+vxwnFcBFKvn/qZb/Uq6NY/KReApOwu6 +Q6DTNAQDqfvdg5+VeumJ2SX//yJrQ3EtrjWMewHx98JzHxFRzW1JJ21y3dG8xEjkLZqJ0gNvRy0B +pJzdeg77qpXjCJ5TC/nAJlPGdKBSBkRN4jm+SlCdJWXuB+YVXFG18I7+vr8E+N12fI2XGAgmT0G0 +kj3PBXBsih3gLQA78NjNaYH1EtBPEyhdXlBQBa/28hml0oN5ZUUHsqjwrWzYLgcfCtfPCMBnTPZn +HoJzpo8oC22ugH4JGGCwzLaz0hwiEVaZBVc9ZoKQmOkFIicy1Wyt7f5S5qxHjrIdWznG6voA1VdB +xx9KLd6+4tgYnaGq9LkBr/igiieMNla/v44fUS1UqY9LC/11Cu6DXalv4ooxVjQM6ejugIFKa36R +ml9kHJ3BNEIYH59ZgCMECw2oZ4rYMnZh69jfH9ymo1TTPg7OJA0FGFrOpC+l9x8iaj24wvvCjexQ +1z+i7jyyjN/a6cBHFBVvNI0LvhnzIDfB6/ujrY9kPZRjbrnxJ0qV2v3PQM0RM4JB88Ar9yGtKbcn +QLQeo22wG9HU9G4vaV9/OkuwNeEH2nH/Q6On+kDNuGIvkF7rMmU1m821lYZEyGfEn98pnqaboyMg ++cNx5nhpvPvdKylikRlA2AbJ/I+AH/fG70GobkAr2093l+o+azxzYaaK+3yB5+MgjLGhk1PSD9nY +ztAsf2E732M7v2qsaVXWZl+pL+MeLywZ91Ij9xfRA3av+c+IxfQ1ZGste3I6OspKrehcv32Zfgzu +0fWC0gEtjTWL2e9UEP0bxegj4h9P/8h1+/uHsFptpiwHT0cQ2JpnZ9ARaIWaWeQfLYog6cdgCFCm +eq19DGoJWuMNoo1DkIaJ622VTUzeT8RKxOjviVYiRMgaQSZNRHm+rJquK3SoKV1HNvR12NB3iE1X +/vo4VyNGvfLvlMb7L211GKF1cVm/SdLH3wIpCcVmYaa6M9/BxRKqntJk5F8cwSi5qYEiv/kCRziP +dzYKpUwwIBJ5gvJqhaNJ9RZDqPjqLn1eHVPZ/U7vX6X77Niq3s8OfZB2BnsTuMoMSzVtU/QB/6J3 +H3oIw9YrblGL9HpHTX1k4KpC/QCsGD4gxwn/nWaPEavH+mf8xXH14572L/wstoxQFsH3/RCgzdkN +Xf7O9esQjvKyKg3weUVcIijz9m7rE/fPKZsqTpOVgSB1D/ixyYvCD43lhEanMyRapwE9iV0t566v +POZTdcoZy0/0yW6RSNFdzhhBhGCEIFztMhjsP0XsK5G4vZPD553OGOWZ8I9r0Vil54zGajvEuIi1 +I9VclfMK/nHvo0o6gPxkJVlIuAspBV4oIFWkzHlSTw69ACG2YFq84AdAPy441/HvIQOBcwVsx1wD +0vHqh3oiPxOFLTs0XdAp1TiiJofFeGd6uKOGo2qirmHHqNhcfe4YRKN2BumGiHKnF1RjmrRsPLKQ +F2FtHEOE5E6q5njFENZxDuAyAKnvy5BJzz4gqRcoWckJIj8IcosElz/lsSMCACoRURaETvkqdaOv +nt7BfR3XRYjKKGU16UMeF6cvDNPuo/RHXrj2YtMiGeyWtdhTD2Fgb2ZE7O3g1X3cUUqwwIfSsdko +TQ0zs0FaAV791D7Lz5VoQR33WceUkUElEUdxsF/KrS22i/cszToLEYce3NOSx0oqKxFkpadNB9qq +VXkN2I/LgQXXSUNrkSXkMoO03QvlnL89ySTMLBxovWtPFGdQIwTzbGcbMbi117vQH+L/RklfI/px +aA3jllxXo/RmA+trWPtxFJiuSNbxCLfzIyvPDkdUO5COSu7pR+ohWWTl55/TwF9RP8EJMYT0/AmC +RZq0l5W+nAzwGo2APusPEbiuFLtuYLBeJc7vUbUdzDWqRTJhaibVDN+ksJBOKXzUdWWLSSJfzw9m +Pviyqwcl46NiirN++HP9O7u1YjSZWodk+RcfjHSgEEudf/HsrPBplnaK15Pd5L68Pyzj1LyRtbXC +jdsbQ4ajOA8A/usmF/8pjiP6Bt6n3eNYKYQw+d7OWmZMRpY0zhztxbDyockK/8bvwTNRT7dGN6TF +UkneVQPUtInq0J0IeTjQOo/NvJDIB7XhVr4u171lX1ZRF5AtSUG+vaCtw24SHyFM5QoeiBUcQA9y +YzZBHDh9/yBvzPek7OPPcak5MvhLjj8AP1Ym1IzQLvuM8Fcc+RVfmMtHkJB71olu3Xuuc6SLyqZF +lzBJTxT1/OAWg7mry/e4GFP0GFygJvAZ5TcydU7LLCWAyKQ7rD2KozDD2e+6FDfUQA8YrB4E1r6O +qUbXgXPfLqsHQqW3u7Sb/kOP+yOijpgQPegDvIqzRpGsP0heRHBTv1da2l0BredI8DaBfwGVKcfG +w3y9sASHqrOEwrFeobWxn4Lz3N7HHnNnwHtFOAYqaCHQ+4CARAQ/ExH9SQCgb/+dJJLceZTT7UCT +Xw3I/vv496t4Sj6418iiCsf9KiItxT8C3oV8hw4OatmeIA4ZKE62aKsOfX5tBny9F6ozLxSe3UOr +8gw8NG40N3KRTNf4qmK9heisHyJW0Tc4x/3+IcQmoCmuOf2FsKTpry5X0/gE4REc1zRtr0dwYL/p +DH2+B2QHaactXEWhf0Yp80OPEJkfB5FDvcUfPqABaQ5y1/obT/At5pvENtP8SwsdumFXyAAHcA4I +sxwrFRV1sCVYnxFfC4hcXvry4Ik/jgOtFfToQuyohUYX/OAdSBfwMhsp3mwmtg8SBm+mhWTUyocF +IDtKUgeUJvCR4sPjIoXBGBRatB4BHNfMZCwtfYmg9CXiS4+LoOo03IkYMbRutMbRokZhTVVEGP3l +PNL3mErW4+ospnq/TYVc1AhEny9b+qedC/HQEy1WmyKt7vixwnJA54A9rwn3qz98ALHUOzC/uCUJ +Urdk7+plnan4zFRcFKLDTurEUYV7V5MHmmqjXQfWoXFUQQ+3fUakWIjMo74i7Xl+OA4s0UdJq4uu +tlPrCIbCCitBtFG40xEMMWW/8PSMLBJw8ilxeVw2mBBDXcHcrikd68w4sX/zcVn3YQR1RDVvITz2 +RKaDoZCbnMfh8XQfX3qOExI3fuUtKqCqwjDM0hoI05NjTkVHjylwnf2Q+y9hTw3q7YmIUH3dj8AX +lC/ll4Kg9w/H6UckaZd0RRl7Ub23nY3FSOyHiJfc2nBgPL/KRxTo/qmM/bQl0o8AFVRqpaZXrHyh +lUzFAvhKLPoTO6QV2lDVcIv1+BXQAqGvVVGn2XeihCEL3PUwXBvITq5OpVLx0EzwZ86juRUBbPfS +k0IrQ6WifJ1HPzl+OGHZulznzyG58udMJGNKMOWtIVA/PoUXZLYpQjzQMn9PgMu3+FL0lGZYvxpD +dFrBK5T6IEdne+9ppHH3aqam2WcE4CqVSfez3t4zfY/iMTNqPxMX4NcXIj6dL0TSOHYN7bqYlAGz +OxEoDrTPiJypHogsRptHR/jbca7DQBw7B1Pu9xIShcdDazZQyiGdDrTJi/clP3DHqfWVvyiBqRHV +NH7YUfU+UXuN+ttzPU94YiS0bASrpd2C2od9nsIbToKH8AnGzqdd9McA1NIYlF/ots2/aBf9Iaqj +brEPUxRtue2KBznLDs1Cq3JBdWcWfrx3Zm122pcm4x2mHystKBE+oI2TghW2uPtLCeWSkV3ErcZR +zFIoqXzusuklf4/a61aMGfa+KcJz3DHdu+M96iSgCI4aQVfCwloxu9m3cx1Pg3E8DV4L+n5EsZjt +NRl1t0gy98QRdRaViiCEX4prT1kLaN/vVWtGzR8ZDE0vuAnK+SuOu9/RNb9AHSaB++Lv8sTF7cHd +ArSTUD4cbGiiMK2l9qIU1EYaOjuUV7n59eh0kAU/ABAYdkl3QwQOAEI5Imrso5NNEXiWdKOlWKGU +9kcvu/2uhTD1LeJFMQW7AQ2PquZ7FFQRnbUrqTEP0l53LoWwzwdIEgZ9tV/cA9X4+pANn736xhBg +Ku8cr5bhEhBpQCUYWb1qrFL2k8IVteNv9yj2zHzgps/3p4OV06Gc3l2UOruAFF6uJ9YTo4uheF7v +sbF3yx4nkn8aZvcvCeqTgf9fZOH/Mw92/YLY9ZfEev/j3+7/mL/+1X/963//3/7LJyu//tv//u// +/v/69a/+u3/9v/ybf/iHf/ef/+Pf/ev/++/+p3/z7//j3/3p7//T//t3f/9//t3/8G///T/8j//5 +7/+f/5ST/vwX/+u/+0//7t/8w7/7t3+3T/GHi3u+ruCviAX8z/xvwGe2ivEBRukK7MDeSHZig3wP +qwiyFhUe/n4uwjNX+QN1bWQl4C3+UtboYjl7agGA/gvMIDI0X//sXw3EqQC5rms/JD9JFOy9N/r3 +DTqYxeoV/KzOUrsC+w8nStAjvdX6zM+oqrYb6rP4kQm3ugKI358OPOqIoCQ3AgarxldHQr1SRNN8 +ERzeo74Y/VQnguNXRTlwRhT4sSTamxYF/s6ghJTtjesS+8bc485wZK1TNVR0PC99sc10MsWitL/J +vfcqbER/jOj17bOR498StEYixJruY/RyxjDPOf6Rfd3/pPT2vRO3sgstPrjtNextVOlpInyr0Re7 +EwEjYEdQoc9EiNEooTV7AkYC+2fcSckKbggpKwXQanmo7Cs6Iztk30JERJ5PSawKcwuLP7207+jJ +CraQtj8yp6pMV9DNVW2fEhfaPB0UeCicutIoRH9/p4hDTc8AkH9VUeUPqkvPCCTuPspLiCuchLsC +y6HlvB/7vbz2o9542yjcv8b+Kqoaqt7Uli6gVlRgogaV+P4t6AYPVPlvVFaeoNyFdg01UXPT6Co3 +Zy4aJSSqRmwWjg8B2Bvy76oL0N0gIeIDVNn2Xza9GIgIN2MwdLq/ju9yjEiZYoDU+npU0qwYuU5s +dIjYtV4PkoaqZWlolStgD9wBl5pOJCXzHP6OdUYPRFckrR0hfhcMvSomtWyofd+24PqwaP5VMP/E +rWFXc7PM9v47Ry12+GFaVpUFv/5GE4W9Aw0hjekdBT+98/T5cwTGWvy8wNPLOfz3IAv2y4IaYZ59 +GBQldNzZD+oT1V3M5ClJJwKBBa5BnZ8feALuoKOb73/1JH3YX3pnFi3+hNCNAB4DvNmLU+wOgfcq +zL/fpNfR1Q/xbEC4zGEWUF5bMktdtPw546hBA/KOynZ6wQikeAWBfj26vs+ohgl3RYf7Gl8naqjr +QHkdR1rs8CZw5BgehryUiP23aYWqQ802sb+mEQMG2kDFrP8g+J0zDXF0WOb2CL+tjCWQvMO1qTyZ +w6BDSNMmdBKam1As4B1/RojCoQ0x9q1u72/yEXVH+msxJBncvCqO/kFNTTUHGPSqhQ== + + + 7R0Fk8Rydx3HHjI+VRi+R3gmZPiwptivD7/1D8fRBIMChMY4yzSOTk1v9o5R5Q8RPz3HH0FATPcN +WfG4fAA/k9vB7ImLwYWowC/eL1DevF+XXdp1nQD8Ie8sgoV2Rs8uE+4GqIC92haKRz2N+1B3kFwf +UU/2fjCL/+hdOKyU+eJSauzu/IBNYP9118yI5pqSvIC0Li7vSvFDl5DXB5hiOXJkfnjrVj6C2pgt +kwwmhPhFE6FU+17flraPREgYZoZYDID2TUAExWZcbMScjKPUWcTJE1XPPG++ZO5dkAKjLOK4AAbq +FjGzryM7dsdRd0c8DlUeJcrb+oxwES0xt37QGp0/HacijQ0OvNuDjEAXLyYZy5WMpc3XqfOO6Wal ++vjzSY1oQxlUbe7j3j6N2s9o9zB0KohoGu8pZfCc5Gkmefqnk7A3N4+oQCtT1M4u6RGFTG9wMU5a +N0OvMGawUONBtdMKMpgiMXathT7Ar1aPKBd1DAK9vEv0Bxo4qgc1xof+TrByLy3jYKz4bFSk2EvI +/+LoMNozAqBdATwNggYo3sN1XDb0jHhuKuednt5Xjq8MJ+If5eDEG/xh3GC8ty14vJD14bbQxS6P +Fm9EDJrNRsgGRCOiGAD1nwA4QJ6nTxGDyrl7HhqAQLAKvDNknChyUdBfpflOthrK+37HpKMFocng +mZrQpkOdsr9llAkgZ48RkI4n/UhF3pgLYvkNtEivB7p4j9DnpXcqFfngeoXDuzUP5Z+pNKni2vEJ +Kqzfyrjff/OaQvrhhDhArqRu9sEJrYg15M/llN0vCh2FveEHPLTYoxSdjsncpFfRCy6/T4DrLFHN +vIle2EyHAQMEj0ODkYiAcYnwoWOI2HIJJVTW68mVHLR7pVY+v8gKlavQ6ClJXwJZv+U87PtN/xk6 +K5rmEiRrlLExIaGv/ddekT+dN6ohXMjGtF/pQs8DZbpH+cGdkSEb9R9OFG7C2Jg/NCQBVuv9uh/j +SvtS/UNI6nvVv7DWg6gTKb0GUdeIqklTTcYXZ5mDv8WtEwHu/efdzt6OiuAKEB06tQxoSBnB4vGL +J6Kr3rYv/94Rwz4bx9dmkjr/NDyq9okkt7uwAPGj7RGZ4/6ivKa/qjoyMRKd9FcuqOP7rasw79hS +GCDEfutbROqTIlJxv5eDlvQPx2lNUSW9FR0sAFl05o4lx0VE2a/zZLbNmJOnaUlRg4W+XgcxorQZ +pYUA+IAovCUfAYsUai3+KHAlivqKyy2UgMq7uLO1GC3yARsdH5wEg89srCND1ZhbEESuhWEFnH8i +Ur/s5YBJWctIlQBa1wnYX5mAArnY74GRWzHtzXnQ70SFhvY3FUzrzTF0hR8B33Xn+UX339F8FREG +1eO+Quem7OtxStd67UU07OVcMeXH09NZgrLwOIDbCfnOvPb7GdvfZmrfMiXQjGzv1e2Hz83MljMk +mspn3/uICjxeJz1axtX+I8rA9057erxMEZrQu29nn257pMsNrREc2r4F5PvEnZXduepa/P0ouNkz +oNvPVdHm7Tbd4joGBM3PgBR9Ofr3z6rait5ifdqKngfowRRL6OEsByrHcKqFAZq+rb28z2fMCgjp +jqUeDRqIUL/RgJZjcFekjT1+DrM65+C+gf5/euYJ1alSl/X2dRobhv1ySGxUnBF7ZbzqceCdPFi7 +gJgxYg0N+XZK241okoouWhFxng62rePL9v4C9TyQxSQwN2Wt2DZOEiU0LrRiRZmJcRC3GL1FtF/2 +mvpDwHOsMNlw3lTtI+qZ0Td+VLt6vGB0kvjSlRSGdi8zP9q90CnsgmgpuRfjItbie0RWqxYucNsp +ukCEj+PQPLHZg8+gFtFD9X3eIeCOP0SgW8t+Sh40D13ghyi4eQz/9o++8+ZflbEvgNPW8Tw6Jtxd +k+5BLbWzyL9JBxcWtmaEXXzWn87x4ShA7rLfzZ+fxwCY5k4uJ8YmjRSKpv5PD4pSUujDtTBf7qPH +JMf3nAc8N/hulGGkFtzvRI9Nbn8NpKzp9FXadU8mlJnI0ZfbC9F+4FM57S8ElPoYqD9XDNRrANlE +2bqoaNWXM+NyP24sX/tM+LVeGB4OZTmCenHKybiGFfm65AvSaCz44zBxzVe+0BY8TI7rkjnz4IGU +6W5VHOqi+To9CpLQfD6eN8IVjgnVbUA8min7nX3vXealh16XhDr+2gEal4CEr21IHm4C2DH3is1T +Z8Slth6ehz0XYIHDIe5ZP2VAs7UDUO2caGdLLS8f02idrpBZrE8Ev8mwMshe5CZqcGoT8uuvJ0Fv +AaLJok4h+yls+o7C2xlaTO7tIdkS+kB6IRb6E7cYhkhxLoyNJKOjDoXkpUU754vE5b4lNAqdSDbH +/dQgtxGXDyVqeG9CuqNierrLlDFy3ZdbGVHuStexxEQAVThFFWrlmWbP+mwxQsRdkqBVgQpO6F43 +0edNriindVPtChtfyj1zBY90L1DxU2HjfX908g4ihgjoAUncrmYEufX5JvsGEIJ66nUMV8Hgg4pp +4eA0XXJ4Dzopr4bu9CivlU6bq64nmLZ1dSSZ13uCeUg+qHb2JGjFPFR1zuNrG7fHmAN+ywucILEv +7du5C6DhNwMUzJz/mi+TjBHV4h+jnmtUpNCaxW5mWE6SaQnkp0bLjABspBJB3U2Efuw7XbsVj7Zr ++vs8x6kWppCKbf3KZQ5X2y4NN9vVyAUAbM0XkWoWj4BIjX4x4a4jBgCjfuZ1SiK/C8vsXVNbOx5e +fCXCfZpuZu4gnxGCoOv6+iH++CHKTpdMSWyzA726JabrY1pF+IqOt1EPRAVSjm8HpFMBx98iPFO/ +JRbu9ABWdPvhOL0oY0SxW58VMOdUXpKGbU32CwqZ5PYR3fkdqmhhq4HUvh4USfD+lbM+HAnrObLP +tE5hWFFQK1rRVKEY+5eg1ZRyAPMftNDaDxGZsDKiLmIAWlMN+/tx0FDw90fzbMUWB10ZcM0PRIzP +iD9iy9/H6w8x+jc/8W/GtyaGy1pTI111RV2QebzWxlUo4PE6hsaCANpHRIrqR8OAfYcrmcsPx9mV +EyQF0MSI/R80jQrJu7woP0UwFy6yLJX4O2f6HiVoi32AxZBFpznRisM9hIxHG3a15fXALo7P2mfE ++7xNGym0Ww4194/HGXGw2BGU/xHocLzBGn3xro+gJSkhdoYXaEOgPwWczGtQXLMUUWhUcaPXQQ/R +smHHJ+JStPJRSEOlVSb++68W6zSzL54IetKC9FBVGax2Jdjq90QOPgvrYIs6Sxgkrp0eRlOYvdEV +jAcNiCCjIsRGmJFSkpbzjZI5lWg55URF+gZgkl0D9ywqRdvxSD/ivYzrPW9UuVSnwMbRB5/VMc+b +LtNFh9X2GZFfKfjvH/686yihIecsSdLjDY0rS/spYGnICpd3Jyrv8T+ivkEQGy60tsFYnO6s0MlH +0E4g/YDk1CcWZzvZv+tnRO7ZEGTGdKmPI+T87ThPJiB6HrRccXcrqVpY/xABMP3i17nMUM6ZvkWp +tquBMr+8vteXLHSE8TsdQTAwNHBQVlnqE6FGWr0v6JLUz4j3HU2LEMXgo9Dyx+NgJ4aidxEfWMLA ++fxnSyzpujhQzbfX+T1qxXtJkXTkmLmAPIiaRzX3mkds0XPwkUDsH5f2NW11fY/ILbsVUwHzqkfl +53FIUy41xndc7Sc1Gyc1e5KnWsFqrP7Clr8Mt6tMJS3Tuzji5xT+1MojPvGq5qHCp335fPzVjFCm +lURYXvOABXiOYVMNxNa756yQbYlCWdEVOnvBJJ+Nvztuo4Cx8E0xIv3Byd2N1zxkZo8xxtGiPRIS +/HdvIt/g2j3uhf4qLCqNpgd4oQJ4EZ0Y0m6aK1QBRUONFFNi0y6dmOdnRJKPIgnVVErk2MdxEClK +Inqg9DR6wK4WW5/lp4hbTYLkGeP+Smj/GIXsbxNshv/MSvr4RIHYsqoghzCDsASGzldZftkRzyzk +f8e7jPF9k8QxzjhBQPOhfTzjbWvNk76uqAgHBrwXgSeNtYc8GexDe4Ui/ND8Vd/eNvrbfRtII+Sw +q6h9W7xjO8IeUUGb/To/hV+dn4JNgwgaLzviS/hNJoKVCYzTOz86XTv8gUhxXKGjtcUedZ3NBngl +m4275/cAQGnNkRFDy/N0fUTtXR53S3yt8ZhtDuNUGugja0AAknYKGLbugqNpunA++HpoJ+/zzOzx +668YOVpp3DWtYMyMqKzBD1sw4xZhSbRms2mxv3p6rDvtRIbYpBKXTxD2MCFtB/c7DZb9nE1rTwxt +KH8wtOl67dTTaEWsreub4zXunRa7zO+f//kdpoFEZFJgufH9INfIYBpIKJQvFgnlrin3LRE+In7c +GL9HRdrkVrOLX2If55YNuCPKpfJu6cdvl14V70qJD+LOjRgIjXg+NmaJjWnjmTNd650mNORNJFe1 +R+Yd2dg+znWk0yoMW45zoVtLN56ui/OGmt4grlPONXGgkrLGsPp4mVTV3/bigBFQH3lmkSWpzon3 +UfdHqP1/ffCPNpNalm4WtPb7swrvfAFtgbhMBWozSHMSUKHLZhaoSJpZV+hAt6p56YXVbF1++Lwf +Kg1Tgfznz+2WocZkxzkreSLmG9FPxHMcA6iGiJjz60SqpTBU7HdE8y9Yk9re1jTd/CUhpPdjnRO+ +bpR/E1GGbbkWnZYnto3PkaXMmXaSxku7f4qC/I1yLxVBqf1arIvjFLVOLdpa1PnRKuHfG78wILFy +x0HsOuiDnRFnSL/fIJ1Cpc/qkoLEwaSPOk8fdakT7QOSRxFzG6c1Z8LWFVQMFlcBz2ftH3e+44gp +9csPZZQtbE+Gf76ACPf9jhQNE0ZI/Pw5MGg7/6wSPXKcBCyToIVM5fw6vu2GLmgyUeqpspuxNyei +VCO4Y0RoC4CZKT4inogXmRGDxHxmbVM0cHL4DDyKDKnHHUaH3ppqGpQC9t6V+ge4/H4qdj5TY4mr +WDtTzJ0FgOJrZdGbXEBypNCryLzTHkQoz6/TlB98JIgf51cVmQXW7YcSMOQMnRXdmBG1JU18G7fs +p4ARz7ynxgQ6bfDvUZ0mG6NnlBSe4VMUWCfjJJWpWjAQ+rTwGNBGImFFUppSDIAmYpeQEvme5zle +Gf7BZHxmYCM5E6a4zz4RIHhknyvDvuAkXRzRPKepuu9Idqn9no3ow7YD4dwv+wvbIaqKpixyplcw +W8ToosznSHPsz2mRzkQMRVkZH+Y8HWujHYHRVM4jFPVKw+Y9jwg+oFxaVHo1xT+fuR8UrE0WtV12 +/oLnkL9QHK0egRaYcUeDr2KF3S8uf+9ad9AqRwwEJNI+ylCv5MF1NLCY6vQTFQ6eucqcG0FHrZJm +JGNcP/ednq/ldnXONc+H+nbRwXv8c7uhZGSS2WbUjIi4hUbeLaiYCgCzJ0J4x76C8laZRjVG/Fqv +RoosD04roj49E0Q2zjRUyAnvymuj/YUXUITza+w6FRo5jlPVHnbhcSgS80eEveqcBw== + + + n5/iFQLQpC/49QGUH7/ygyr+eWzeD+vUoQdvlYH3QDWzBz+CZx5XWXA10r5kYH5YGY72+vHvac0f +Kcxvn7G3yjr/I7v9/ecWEo3m4C9R6f0Ml0uxuMxcC2P7JRHqkcS0ohIQZ4epDeWO2FvIYhhCn1dh +zm8R+b2mMmsPItSFCvfjOP7u+83hd29A12gkKIm84vb7QwTKBC3e9K8swGcU805XDLTYmN+/UmCR +IoxJMy+e95N2/65EBg0mKdLt2Dvff3nX7x1S2d/0gbmdz+hYgfgCEcKCZCPVEyEYTre7YYQavjXF +lAFRMqnP/U56n5PGKGvbD69bHRoMq5hNE3HbgrqlR+u7MeO7wRcwgOZf1e4t7PT9tksNny9VlCgb +d/SnZBqpkUNTYD/6+9+9ZUitKWU11al4LPRp9oFW8znNPOoGstQ/I/LjfEvbPo8DTw88WUOLc3gp +ar44lgRT/T3Ah6Cfh+Bguz6CKA5B2d5seUxXvdx1Lhey0ixRp7jR7aX9deEEwL0F56Aq0reIPx8U +nNMXbWJ+CBIS1URBPVSNqqBK54dSTzMUyTR2eVBKR8Xiw/4UxJKd+nr4OOCglkgvZof1NMTVDUGf +afwQoV5uUy93PQf98BnFrHb/dSkZItTiIheoF6ALEMdUM5V6+Y5MOXKJ8LfqfH/lETrSDhK0aRS1 +ClLljTz7jk0iMmpNwgcRviFgpOedCMDpOyKSFvM5arFYDIzfZ3KbxDZawQr01EkjZUb3zI3z4mns +Fn3yyB4UoImJsJyOPVxI/aAEiPhSla1PWLb7DUBORcEwqWuOLWaGwnb09y55OXdhn4lRNtYz/YeI +Z0jRREYHZd+vwe4fopBFitIgIkNsCXvFja7TinQl0CA4/HVFtpY1RLmDj4g/n1xJCfJmHVJ/OM7E +JXkJKgDqF1VIFSN3RV3d7L5HIAPevyAJf/gswpY1wpZCtaCcdz049g3uQegf0DcAzv16LiBOVC8A +/Vgnvkd8rSaQVqBRNzXfvh8HjZib7Yvlb0Ts/NK8r7IsLuFnY7Bu8eM+7dzuntv9eooT1aFx8lOX +V/UMFVYKNAs7ImjQEsGwUjUrrBAXgMd6zmRi80y8NY3QBnCRsN2/z5QV+4zeVE+Dz7CjrnKuGN1/ +NptHSU5JkyQA1DslkLoVSMuYzwri9ILGvhgJvAir+90bIPD4GyIyhbAp81meA3gSMBIQnj2YeuAF +TOIQn/0I4IHOXenBBOc834LU4x09erwAxtY8RQD+As+xqlemkLyyCiARFLAfHmbaHwEpNo7wJ+zR +W72/b0cZ4RwD7d3fd4q4nwCimB0iTA+AZVyx6A6lBCbMWypjLAUsrwHKfaJNEg4CGNyamlagN2oQ +fR7/dF1hJrTJIXrI9kqTnhTJiPXylnocQdiZ7q5myUVGzmyMJlnDNvSoVVOSYkRtuxLko5qUIDkv +jSa+RQT9tA60rAre/OE4tVkxPAALIolzR48b2ClP/WcE75fw26U14DnTR9QTD8W9eDgXBokFqH9f +y863SCdA44skHoNEye+kpD4KgOqoPIw3XmxaU7yBL3z3cT4Ub8xcpk//3B5bZ4JdypEsl+FFAyI3 +7fQHqK9DIwrBay88R67IIJ4MgkY/4hzkx9Be0VHxUsgSYLMpmrwjYjNCW7DmUvDR8deB0GIErQr0 +IN4mKphSNB6ffsi1KKHezBlo5oP4tN+HvhGIAu5oHDMmU8kfI5Cxer/Gx4ddDZoq3BtXAijmLe+m +cwg0tYZX30/EBTOtf0bkBCvpYYOisn48zs65AQjvOh+dFq8PUBXDz53CLtmDh+G5kpE95f1Rd559 +nR7cjgre7TlCbt+j/vZcj5PFfrFkZmNgDszGUAC62zeqiruU5ZqD7o/a3R332P4ZMcRrsW7tjWm+ +FMCPqLKi6kjuidDNfpwPywNta7UrvmnYVjHsF5K+C8z/zyq3VGiF7g9G06v8cByat2KRqv30FeHH +9JBPH/x7xMfWnI7196i9joXWsNcJR7lIBZsFOg2YIRJQzUEkcD5+zVMwQCZwLZlSipLNzsBL6OnC +aVLlCIojKkdQAQEtMC8EtHAbcIWogKkMsrzMeHUB2WvCZM+zPm9oZfaD9AM0YgaJZsFFDkF3jMcG +DBh+Hpzl0WWaiTyvZr/VVwGg3XadoGwA4wV8XEQCtCtKDTRV0KcZZ/wywA4UFNt4R+iqSgFqtFF+ +7ecBesv3f86UZqWPgW3U/CEI5KjT2gcR0BY9sLiwC9+eP0Rg+zBUr9+Xdpb/z6grinOR2rqtjucV +kQakArkyaIPMGOqc0d9mV+QfrnH0bXUu0U1mVz3lTO9ift2AB8ZI1yL9eVQriNiK+pOD2rr/+quY +vxccKOv/k/te4KL/Jem8HQcPskIYNZGMuyjIOpzjY/lTDiCIKHUxntfwcJDljExD2ptdmsn2wyQe +NryMkJZQ0VWoOYZ9UMaf5ZVtwFROeAvj5BZfMybR2pdBGmOQhAsbgySay5YXEF/QI+5iafphmJdd +urYnBWtV53CnIC+OgKAjWOtiRleA+TFzO/DI+48vPT4oUxnrIEqqerkzNGh+4CUlu8WpNIXsXxyf +ritRXfQzUbIHlZHOcXCJJQJhHq/EL4i+cpVwxoAilw+BaV8+G9k5/lQYhbfaUSfkxwfHnV0ZL8h0 +zJMPyuG4e9HUa+gRKlIFnsxGm1uojgIPfco8rHQBKqBkkOaHOgzUdrFmHYRA1TmIQXeJ4uzjOJkH +qWTEj08uo3lo1imNtLpDjf1I0KpFU33Ed1ZUYtF0oIKBODb1oPx3sWP7CFiBx61ULAAFNoZuKGGh +iIIv/Zd3kRBc4KwsSZQSpQYqbPIIaKwq++UHyviDMiTRuaqMKz9g2o/CVn0zN6Ou86GebrRPavBe +Npr2T7gLt34iln9+aboEIkx5OYXoT4QWQcBJ302Mio2si7kOYMcYxd3HKO4aR8pkCbuI1BPcQHXz +6DyA594HoxONsJa826l/7YuliDqD6knZS8M8g1jyXEcJxcHVBQN5HpfQGakorJ9iZQXO6YLNo5sf +PIb3GzzR/9+JUe8qRGF+NqI/NlW/qQjrqHHkvFrmE0yaXQgOqvJ6OzBH/v5+HR+hlUiD2r+arjWq +XbPO7+dk4tDpHdairOrAqoj9PaNh5nfVJd4vD/0DdzGmMown8O5t9QU1F7dBosA1GrV0RVjUYEFD +CSxEewy3GyNoGdtNvsuhaLjKA+VtORMWA3Op//8bDSJWd78Q9S5GqbMw19EJJAJhAvR30M0gQruJ +HTFEpoi/VToKO1UDYIsQcH8hUXfQE23DwSjVW+NS7iy2hS1go+ii0c7Dc51vtAuIoIRnsgVWDeDP +2MvKnURpu70wbSbJQOZ3RgeKMDJ0NK70I+P53RnVRBP64WFFDKvmTyhFl3ZEwO752WCpNX/H5xhj +7v3yqGUzu49tz03Zj5zVnXnDVF2jeyJ/tYeeOk8k+qIYWniUGkziBH17+dtjoQ5MApwZA8Uv3LkN +2evtNo3XB/aSd8j4DSI1XeXKUdhKWNB3TiMHAgVeZN95SdCUu11Q++lbzqn9AXBa+zjIlNH6ZEbt +PAk0R5FKuJMNvieW2RXMCiVviUo/QZKgL5Hwwygtwif9H623qzs8hIKKPocR8qF3PdgPo/ISWc98 +buZEftF9iPWyKpw13fIul5RlLwcfI2Aqz2FXtsOu5EGipKdzP+uo16E2TH5VcIp6siiYeN4IPZpZ +Wm5H/oqy5b2hNpu5Hxqx0NDV+ZdbfL6A4EDQa7wZEShkZUML84UtjRjwPIAuY3gzdPjWHJCtqKl5 +h+gaEhFKiLcgrtfOvshvSWrw0SWpuVpJWydEvK6t5VeVsFffpD59xX45bajuuCHpE7up6ZOV7zg2 +WMhrsZv/1UTtTf1+1HkC1cFC8v9T5+mQ28WnCuxllLI0B4lxmxii5IajaPALkLgJFqf487E/JKP9 +A7Ymlnlowy1v65G+elgSFJSvGePqB9/JKIAvzof0wB6gk8M/Eq/LIxyY7zqK0Q8KlTMRXZDg/l2v +A6JWZpiZTft9omx/Y79NK8Z8GThiEpejBPFY8Wzyc10aHzkrOU+0dKcdFLlx/cgoCXBcXQhkuwOv +DjMB4NwKVFM5IsSIao1uJ3Ipj6IPJGgILwHSRKxiHknePjOde5izpHZrGZLvO6tcrc9WgzyFfPRJ +mKV5I6sGeItCRJojeVINuTfqA4yXrv5JwEpqvo4IQN+HLXFa5BE1agg7mxEditlKyF5NQ/kL3dkT +gcseBhhz5lpCkHEi/qLjIcjkMkaJOicAAf/dnNqKO1dgzb4DGC96eEanXMDVjk6okpkXBfabOiPH +gOCf6JCjsdxvbZ/6OFBMWxWl7XqXUvMqURPi6Gim/NVX40//gm8jvScg7yiIcUkW31AZlMOmn/of +ThR2H3SobEEqmo10BRSDYQcOzQH4sLto6PQKOA62orfi8gbE4aaQ1JwRdouGN+zvLxZqWkbKoHWj +CvfvpjlqEw7mVfdSFgwNtcBJMnbEzgdKLgWuUMfxjOJdleWHY+z/v7581+egYhAELPFrE/rEsR5J +pnsBBiSB+PaYgUA4fQOhqJ/jqiL8AIUMvXuhkp3uKLB1oVXD7udRVibVpzFd7Sjb0Ni79YKrYDKk +Ei0mPEzIEaTgJeiUUJpx3TFQwin5lTQiqqCO1bFKa0ls7entKCCzctDBT2pIYcp+v+7qiDUVI9gz +jFAT93Y2RUAfZf0+D2UbQfQYiHKkjUgks0L+6np9pUp8pXrLBSj9vP+SeXMiWC+JeOdVmIuDCUPn +eaj8e6Bok5yn36dt39K2Nwe9Y029j9IHwIHRjinYsbik+fc1pRrPaWz2veINrbXtuy/RqIHq2WXW +pZN0+2r2bitocam7TMmqviXnh+TnO71XAEbcnZ3YXk0jvOt1Lh4DAYP68t3aPlgkvcsRzWgyOexA +Ipv0UBY/WrEMF3Zd8K7ynmnfzQk8wj0pIy7nR6IUkaKhRqNr36g/6zp2WhHCuYCaCV9CegMsT3lO +5SrP9tpp2DurUL5yCFPyRdLBbJGBoLDaHm+N3dCmO/iJUBhcHcyAPeEuRUraD5Cab79noM+jnLvI +EaPw5gbZWZ2BrqA8dup89VNgc8v2ZT7nY93ZSCtVlukK/71Hv4RiUcNowFaztFELY0hmBFTmHYE7 +nJd/9XNWfirO2s/XIg9YIOrftYpRuII1I9CHiTkKkEaYfbAAEF4bdoCXUxOnilwRU8WJ7DBKp7hY +KN7/XrcM8+LMneXTsz92Vy4cW1ugM4Ii5r43PqrzgKrYxRnyLIB9cUns5fdxpQFWUpkRy2ahlgyE +QOPxiKr80nglrgzX4kO4op0LgsohV6uT5d4BAhNBBgj1VbSD1Bou+ohpF7NHsiMabU2Zx/0y0mvf +L+NY5qSXaRqQ1eVoDvn+lYlzT3MI3mc50Mlb6fX955jeRNDsiB61gQgu0+/oPPZ2HQ== + + + o5lMO/dlTnCG82zD1KV0CPmqZJB8Vf2yXgjwTVrWeP/0c+tRxkW9s4CXQlxejC2PwAjkUZ03Ev/F +jAOWE0mlKkNwK8fRrHZ6vJ4vrG6Vnf8Kjo0uIeP/Y+1fdm1ZsvQ88An4DrspqRFyu7s3VQGhIICC +hOqU2EoQSQoQUKkkVCwC9fay7/vN1z5nzZUMJBA8QDL2sjHd5/SL2bAx/gtWb8HszbOP3DnGlM9I +dry3+TfCtUOtgp3TqIEOvOOKDyjmZchrjldbzSiKNQ2KMxBFcsHT3zV32QN7lYzFlFU97QLo5ylE +Fuupt6klDYBHhntRIulJ/piHgFSygb/LpyrYPqBXzN91HoXYZtWy57j4P2Fp9RrYcGHyLpIrk6Ag +yIyi7c7k9wqiAImEGewjhdOPmt/zN1Obv+e2puJsQqK7r9gNGt+triX4vRdma24iVWgKIM4DEpeK +4HyVyNl3kiftdcm9gZfzCXuJHej+jRfETHUzAUrqZnDp/7gODakHnPWP50x7B0qjj0pKooDaWpOj +4VnLkRbq9FPUFrkPyVr5wMcIGTkIkUdd/T5S1yiHvsohTr7qeO7bJvP2Pt94R62WM5lc8xOt7fFd +1CrvbBKqEzOAkAnSaR51jFvNCCT2z3maXrOYt88oSyCh0pWbp173iwi6NkpT1DvmFcLkyxHt2IdT +mTqcs3E4Zy8kBxE5sKqIejL5fCh7o9qDhf2Dx/JUWf/aj0lXjKjrjFRCM2UmVY60hzbzdpeV9eol +/QAQF7kKbMwijaQWBUx9dgIE3CHRP+1oJ82gtJn9QnKOvHyXXP91nqXTL2SCQ8bnRTZKDCeS7sM0 +O25Jft/HW8/WZSUiAkmWpBKhfwcZ0m9dHTn3/bpVa6BOlW0bVFLe8fakrkTxalq570cGXUT9FMNO +q6DRwwCITxPhN/76CplGfwf4lzMkU5TMSVPQsyI9Rxu3W3zV+/KxRtVtaNMKqjFJfZl4wGmjUfKK +s8PkAU+CjSVtN3Bmt1IZewPdJepOKaX2zy7eHmvxw76fG6HnRtf3AOHRKqGgyg4u1BEygIDGIiZy +HX842qLzoGERQEL3C7owBXLePJh1V39zfWriQ0jfXv57Lni6eBPFzRb8PH0U9sYI8MPCcv81ulhw +ntgIh5FKr3czdIctvN8olSH33r2b0pNvhYTsewRw+nYXwSalxdJVmVfem1clrJ76BGI1wEgQdM+U +AmiAhwsWI6sA3U4OQ5X3Nq940D4VxCM1eD+LO/lvgqu7JJ/9IJdjl6xcstJSe3VbOsYPu6agkGRR +s/YotSg4i77rBEbfxQOo3gW8TSXrC0aspV4Srfl1gqyV8lVDzCnA0vYjNt3FDUwWoMKzmerZ8Att +IwPvQB/BNYHzB9eUCsh82Ug8OOdMnVSU9GjFe/sjikvyuIFR6n0d3v20OCXL1wjzdTQ7S4pTJmfU +t67jtlGP7bdRK4+mBqX49DgLeaJ8umu2h8UY0/j+jnmZcc0p69hAwRaK0cE5/p2mRKPYfEpLNpew +7gaQVdnTEy+B6xg/qsfVn6MlxuS2wmYamDY+WLH3dyf3iiHtOzPvmIdL5ufWkfXyFZo64zvVKFKB +8EeBc+RTTVrEHaXV22UTzfRhn9W/VpsOehyC8q1pikGPDzHivGyiEDa7I4auYhbnQd7mJr1emfws +deEE0kG37B1fL38A6/gdH2rpqRHu59gZBk1XxNJVOVAQ+HHKuJV3gxmzchkV/thXa9r1veNaaPNq +zley786mcr/zJbpe8+g+ARE0UztKnnt652WLtbU6Phf16CL7x3xyf/+mc8QNKfb3zlenuXKlrLy/ +jA5pHDfsuMq9iQGguTy5HPt+NuyhXQykSuKQ1mmHPnvoS3QQTxVfoLg16qqnG15Bf3s/lxZOmrBs +a/30fBo6buV0k3ZOsFifcCpdh4OPQLmJpSlv99W+1Wu9A2czo4MgRQnUJQqQk/pS+IRxB2quS9pa +CPQ0kaVnFiyhOXbBc4naqRd9uGJ6boQGAZ3JPNo8ka9oiMLnBFKKcWLNqtCO7oQwnfZ1JqHsO6pb +dATbiTDv1WKixxUSYgOqqkZtS8wQ7RxeEQJujMgw8lnHTQY9X070fO3X9ywK/t1HMWLrFTxesUyO +gi9Yq5Hl4opWtzWSvYWJJzpb0Klo1XzWK8ndU2R2+7bSno/1Dk+PqtJT73VWj8uWGq7aajdBHNk5 +cnnu0KHsCaxI3F3eEVaPN/+6TkMVYVUNXyyloBTQoeYgCE/5mqwH1sqT42hvcKmTvx8K6L3Id8Gv +U0PrPnXNC+W195G9zjqKCEM9ioMwDx67NLV4HK8vJZui9kU9DmoNE4FqRKpmdwk4hAiTFJSi3jIj +kAba0TsKiGui7ISwC1REfyh7DSkYlHy+i4JPGGg9J4C0dE+f8r/pzcd1ClWz5/eJaGdzon6cljDI +Jvteft/LTsij4N0KfmjYsON3zRlpdcTRkFZH8JXsJdIjFLnO+oGydrS/td1pJvEAlBDTViaQQrBy +tqgy6oOI/YWq1CPqCOS6CAwz19F9hPN+vb4/6M53Udk77WmBWh2zRKruj78EN8JHCL+r/n3o18yR +vE/MdcCA2D1hQW+3gEfmippTskBV/+my3e2C+sVyFgdUILL7MFc5e8YnvGrm0GO8kzYhh6g+2GSd +QEP3ux531b2AzZfhWa7MLJ0SG4Bmup5N8XvKEAF+HsAm3Zlg7DT8ZePodxnznYtROKd40N7iwUPO +/ZuPpyPpk9oo7yo4PsXvAfOAGAbAK66spSTlcStk3CvkmamoCvf3eEyRTZtagDO8pVB1Jd7ANrjY +AuzvFhTYvDe/gY232yZrapFykHs9YCU0gq+XYd2iN7gfAkr6VhEi105NRQuPddjq6JjorztjeXxj +jLav4X85NT+ZOuhoDJBVKxJ68DuLjGdARxaEmHmPO4ba7ADPKMevsyUKwuoRtRlcNkJpb4nrxyhW +PeFh6MOuIzNtxHojMEsm4utMElEo+t0nQttY5of++0wkXcw0umneQCVI1OnAsIyug7aibHGsJKLQ +Tedi5KscBkgfKkYTMfNlcU16z0P/mZLQuEdAY9edwxTpzKjsuWuiq9AN4KaBKqNKZIAq74hfSx9m +KitKoSAack50T51V2CTB8YrHA3kZHg8W2p8Da4fSN+OqjZM5cMGK9CrbP/XQWJ5hCkJYAbtN7YqO +6RcZyZcTZ6UL4XGcSCRegCKjXPoc+n8NGsQINRDQ5GKzUb1KsaB+2WwMmthVjGFKPhUQl+eWBKXM +836e4qHQA+dAFokEkwhTJmhS7T28HYB9n14TzKpRqysUe+7gkCP0jSsFLy9GrSIDfMTmJ86b7fXt +BpwESJTyN48KbwnrM1BjpEfqa5nBFH4d4m1tinzyd2GvFy2cPbuyvbtjEFtOfVxBe+XF9ux9ae76 +hDhPvRz8Anw6eXMFO1y2f6Sihcoi2Rb99dajtCNcnux1LCs7e/VATTSzEshkK22ogCEJBOvdpeJu +qV584kEHzunw2o4xApJ4XJ5HnbYROx6EO/dFwjb6EH9FDaGBfXJwojQDuUHN9ch+CSqFze+0jBT7 +Fc09TYlGPV5KqGCfKiCDGqYxWIaDJAt+yn0rPiiiS4jwzxh88Gc4A/kzIgn7g+vdG6mdohzantiQ +vu5qdOHG1AOKs1uuUJbEnOZ8Gyu0/aNNH9AtFmeBCtQhGqOQrFn0m3ESpcoMZbWpSGIsKDWEsYAK +4En5vb3owwDXss2OMbs97/WIKvqOoK2QCNR1iSDTf890RXO/gR4wiKK/gBxqIDwy4gsAAQB65asI +AbdtmQDkoYq+ODlPexmq8k+4sBBbFFCYfyHzBoWPJTgZQKNAhRFTusl16F6AdI0KOZV0GxotMgsv +TZGuKTMZvbwrNiSPcwUlUdqaT48k417g5xJ0PAPKA9gJYFMiYyapfuUpn9Zv4T+xlfrijx3KaSTw +OnWN1PMv9/mcKSzQkWoAFPedy1IbWytvNRFFm6jZDuV7WpZBh+mVHCo1sF2UYjUjp7hqmUHuztRZ +wl5x4ZECAwA/Bpi0AH4x448eqcwsU24S9hwAsG41Fl6dtCtwtaKwjmlTXk2U6plIyvFmImcVGdVP +Ex8DMxkQpYsz69SB0pWQMHHuznNI8KRVLa9hlTZArYjK7PVi26t6v+m56CK+9u3RUOB2VecYlK9l +Wv82FLiPunB5fMt6OfcWr/AZraFbeFhh+xKyvmQ4GBqsbD8eP4T//czRXnhPlAVFk5d2+N4zfG+1 +Ii96ctUIypUGJA2LFAkBQpMxsn3Oibodrn2I8ipyXj2iO5XHWaWDpu7WnQwLPeazr65aUT4+iDG/ +mQrzuKjkq2CyCModcUaQAveQJHjOdJR2aztKI2MmMUX098kvUjaumvwMrdZyGGXVhm8m3pv7zQRj +1KW/0PHk4tKBOE/ZDLmkAPEiQ92zJc+kSp0CfUhDyEPABo0YOy+n0UodGU4L6ylEb/7Q29c6qOLX +3j6u2HZS3aDQBiyCfgjgI0ocIJpNmuUHR3MC+IAqHCfv5hBV3vsjFr3rSPKVUUk/oOyMD2HXug0h +mgEkKnOIWtA70V4N5D8lNfP3fataxDDcp1Ku1TQLFqtaNrf6eb+XduYOvGpU2CNFsUgPgRBYFhaC +vmENBG6L+g77COobKh6jdgupvWCRR3NY00IfeRgC78JYYjQIgs2bDu+6RizXomE/0GTBZDPHdc5i +IMyf+W6LVMaVb7F/vexagm6lJCZIBj8dxVP23DnvchyYDsJQvpgZSIqxv9A4VH7UNrHyZSdgQaeD +gopIOE3lW2XKS0AfezXSATQg1Xpq+meHVcF7Y6+GqaC+m00N6V8kck+6AusEy1ZUiVDEv9nVo16m +5Q2tOZp9iiHUWFeJllixtQ55gjYXD61WBwFJ9nGquBQZJ4AZ5LhZyFktF+ByxPRuTc3BE6kvznZL +USIh/ghF16Del1sjmGBAuW/sDV7hwADUrU64tR4wMe267xe9pTxhHfwCyTBzmOwoByKAR8gXMAIS +vapjgXrTjZHq3DG5osGyhuBqwNrTnalgYvVKxlHflA6ypwo861n2mBMtK60VkcTZlaNmAxeBkDa0 +NsYo+/mibUhJv5rm8EZZ+KaxcvWjwq3+5P6pPQGN4rCdl3au3VCuXyvfRBSoQ/sH9je/kw/QjVI7 +iygQoGpc9aPUat0HPoDUQHCeYNlQMJ13BNFtV4CYYWnvcoJgogJKHS9R5A7m4KJKV/NgL/hUzAk1 +3W+nsGvPNPWJoEmqNVCX9bgZmYQRRdCZqyTVpS7wPK+06yEeFBrcXuAoosIHGTYmkfVSSpgqua/w +HSQ9yO6hxO8hByNSNCQJfrPe/DqTCNALwscTC89pviVQ3iam1nzXk1keetVQUrFkYxPzrin9jK0H +6hZMCAfMPw5ZY19LlBFkkEOqvmXQhR0V+O8ci8oZEfTxiWBxjUv3OhT/G63mC+bcbw== + + + tgAcTqaWW2iM6rFMeRcqLRHxdtNXmOJLqPpHZGPdwnVH1DIA2DxWfe4ndZJ9k3au+uL8rygYitGt +gbgH/yV7oXtzXcovHLd6PLliV9npEw37mXn9Zn4bRoDBgnX8A8+Z1jxi6/urLin/4wDV9lIya/y5 +o4tP1nLo8jWW6NptycMSSjSSBYBMH18ytTM1VOXuj1VjPFHFdcQ03b3kpYToTMSlOVRfltyxVc83 +0DgrEdJ5IUG8Cv9rBhFH60x0K1FHEJ16JPwRebZ8T/rmC5jsCSBzw8Kj61kGyGZ9TZdaDSIQ1ZY4 +qVsunjh6Laf3j9VW8z5APl4KnjZKgmwwUNc1FebCvdyjfXdY/vsdcwpuf1fAkB05kBCQPQGSBakG +o8UdK1Wc2wvIIvUi39fxeVjwrWYY7vpC8gDos3MpB8GzX7TdpIMIDHO/cFMcQz/LICoTfrUrwlQ4 +WB6ViQTRZgH/KlX0OoRSHqy9L/63/yYsNytzNOZux5AhceqL5iuIN/n81xEzuWUKxeUh7LeLyoIv +EPYDOgZfB1ijlqM+bkOouyI3gypMuZIrjEC5lOnjbsWBoGfHxG3MG/oqxN4xo7zuo9eO1G66IJo9 +XmyGQ7Jwsn+ssRxoRo/gwqPP7HX2SehI3q8uPMIeWgbu/zdGYOt0DHYU4CZrJdnpkiRyItCclCMR +Uy41wq3ZtTWQTPe/oMJE7ZktAh4m5BeSvfDgqMs8YCfaZTmhwphfimPL+3C3JrN1/97iRAjWUgeU +fahysPXw6hcXhN7YfPtd12W/aykoes14GFUIY1coGMJlrgMB/3dnIyvlsKKDX8NuCzuigl4J80Zy +AeAaeykU9RyoR92slCYVH1hh0GTQMl+t2RVbkj1JtPtot9Ottxw1ZwS2euT39nF6qiUNRo22vEsR +IJc9bBZ0hSQhpkkDpeNV+mDlIync36LXckTkaWeVBrMwtt8BJ+BjqWIv7S8Ue8F7aUH1qOBBDebx +5xzfPHh8ubHgxC0a7XNMREwRZK9GqTx7+qFk1PRDPY7rDD0x+ugUIf4mDO/vCfr77/4FP/p/9YH+ +hqt8/iv+95O/u6in+ijGjJCfpRcxF/slZ1fzTycokycuIOrh/TnIS+WcvC9VS/1G8TT+vp5zCVlC +UHV1CwRt/t276YFV3FasDq+OjE496xJhnwIbvWdiMCOiBA/1FalqO3KI0ZnHPoexgZ7zF+d3R+17 +qjwWe2yjaFoQVTWdIaLr9DeqGuDAdaYgmjJTl7yP0wPHuHIMleIoHZSXYC/LszLDDKT3Ig/sfGqZ +pHgcgVgg7BCLCYSlKDGMJZoRaqvRiNexhghycSKud93tx7GRBuZN8+VK8hTNbRSkkYNjuhlupnnR +YwUo2+CCStLdBD9CdZiOjmpzUxSOSwxg8fLYwhRgGg32dixUSiXhrtDa82k9JYcqtam943FKpQGG +jxIIhXqI9uQEIAmvIpclrmC3+xlrboFO+ICCa6/hkS896AYzRS7gOP5n8fgI8exr6SLH59o5wWhF +P8O+neiqP9qcZ0Cvk5H5wKtO7srSeR0G31i6quws+ADJjMIZnntzn6zH7z/AdacDDBCcgG7Zeb1e +V8NNdr7KyS8y32B6/CXOvvfvtA2BLZYDpM3Mtpe38gTuxcrEjuXyIaB17ZpTJV1l2b75Clon3J8R +5gwlqTlteAEMH4ex5gmlsQXBChRET66GI/r6DFhcQV/MxqYwp/kIOugANgi4QILXw8MPUEqHD9OE +CXUhepRk2ZE+QyGSDOTbA0ORkYc2evn9KTTTQdXv+aqvI8/fNfzS18qUyF7RE09dqfHnJXOMZuYe +G4oYwKwPigY6zp1P73nTT+vCBzt/LDn8NOHSmZ/OeHtPOBMRBDEqRGfiEANFArff86vnRBAZlAIo +I3Ivis3tgP3bYkq1lykPI+eHiNufNvdP48XgRIP8GsW007pjCkV/mCm02mZiByY6DJaEx0nVUUzb +PH4Ld+s/DfSDPJGv9DLfv0fZ+YbcDy7d7A1JAMAME8Bpc03nCKzpymGA6qS/qPPkPe8T0U7Ewf/0 +Gjei72N2Dx5LILgmF1N7Wmsk+hz9c/ynB/UjCjo+uq1XAUfRFANuKv9VSqLh3Fo3LEOpOV6lKXWT +buhpDVo86wLoKGFnhRA+SsuSxhn1NyoF1N/W8QGwvoXe733wBEYhtBCZqseooND2PrVfp443NYW5 +qpwc/ASeDNiFRF0VGonF3fdFYpA+Jgy4qrB714ZXJXO9MC21in27DgiyH7Aol4LtZ23ZMDLQFJbj +AbvPk77sfYPHffQCu0raVo9iDnmnwOrzLi99e1jUn2BnwVz4S6yfPFLs+2dEilGh4n8Muhm0SrVY +7GdumPVvuu8tzxSlMj0qeJdMXOblJDr7K7dClPXKm+ZrovSN52XvbR2XPhWZq9wcEqel1PAsGsr+ +rfzrv5p0HhrMv45AL8rBijtdhRLpl8CtYMO25Hzgc7RSpWR7nTJBNipd3NSxcBDcwfyfl5TKtKk5 +drHuIZit2UNIBRhnL1L2Jqm+9FBOr3oxHytxahHADkgF5pYRWoSjCktGhJdL171rQqfMmUQDIAdf +ciY9OCimXS+i9e5B2OwouYpGXYHkK/CEltqxVBbpCihz9KPiHfnn2nR9JgJ1zh2xen3F5R/V2ECz +9Bi73HaUKb1Xxd9HzM25GqXHB2jJaUfK+jA54xNOYvLMUy8V0wgz7/lyW7WUvpOkKytx1yVt76ja +FVVyzTka1nKWd8cxWQQey74K+onsqz0FV6WNHr0I2PFSD/9iUbjxJlPpLaZRNEOJQgjLAJG60MSE +qj6vvRmaNcUIWUk7YoyZCDGZtLswrsyJSnrotJP1ACNKYmGJ0uQeuOo5QbvV2ZnNDSQQ4+53DKCO +AOkmhe3eiz47hqJ7Kkz2DowENh+VcXfs1k5XFJhUB6hUVIj4W6/LX/+Or6gEE+Vs94uD/Sj4myhF +CjkaeTmF+JMQQ5M6+CGgZkSNR6AS9a5bogqkj4NDasEhcYWJKKqoK+YRad1gmXa+W9dvpA9W40RF +lwWkkmgyWDKjehzVjK9XfQ1zlhHp+WCu6NXW81HEhTjB9dVM7QcBtu/ftcJ2LwpwAginT06hDnAA +OlVkdM9pClHqBfHXENW2vH5fEtY+IlJlqqcjyiu7fjjMRMqc2Rx9xhHWr5nbUgYi2laRzxjR8IFp +PqxkUal98SBEUUi46DYg4bKjFBukjPkcf13nievo1BPhCj9BjT0xZY86D6CIPhPBzDq14viDxdkV +ezIk/KNEpOjMjrquHCf7K0nG50ywVXbEEockofvReGxv6KJmBJCH30T163dTLI0oTO2h0L8yQyQ6 +MyTBS9Et5JSAnpV+MHgX2JA0xbR/ZBWlaz9QxJQk2rQs/FpTKbs+NvdKJGWC0eoAW6caJcrbXM/J +wSkR0zxd9C/rjxEkNV3JYqiF54H4HrVC2lPF8iqpIgl1ukQ1NUUwhfbsFKuIvZ7tbbyAXamfEf94 ++iKq0VxImivw+3GcA8lEdQAJ7y4w8j4DpKbIiLVgH8O3xyfuFR/7jOKVsNUwi85X8zSpuPhY2wlt +lH699lpIiXEefWHcpdUxXsl40OMuLyKBIK3Alig5o25ydmQ3R0tudZpqe9dIyqMxqiLKi7XTiFzV +hTHbjJqiEnxzUdT+OhM4pkfhAV5qqODDqLnXpJzJot+O6HoaEDHzoAmJw1Cp3PWwyJHy3unLeEUd +XXK85GwP08Gw5IPJq1JONL/SQdyXzlp+jQw+1/7R6+17xKGf3taOX1O9z6jrYIH2XFTPtR/WyckF +yLEprgq2keYRp0puyve/50E+XtiF6yMA+funwT5YvBJGe9s4NHP4GDDtg7xzk3u/xq0fUTAMaMqs +WJSqTeOtfNJCXQJ2o/MqlaccQQSEnCNNuKe1+hqSgbyOD1sbInxg9edmQ4ItwWZwzcFmRL37++NA +8zxls/KkgXP49DD8+smcwMXonVTYXh4gcISlSXTuQMSKzah2hKCVpgSI8qRGuJ8poStqB7jooiJ+ +eqyqslq5Zzk6U88SQkxu9QhQVVSlIsjGtpqKjijuY+wltNVZApIshdMYXGW5rGm3rS7jmrF+1eBh +g8baG2mFZ4mAtUaEVqZXPbrzO3kdPT1cMm4iftsOAoG6I9G+x4Yn961iwJ5ST+MMBTSNFf0EjNc2 +9jqZ7w1EmYhR1otoA7p0R/CTDtByT3BrNRfMcmtVlYPnwPz38yfJ72/nRH/PTRJUJeV99lta7RRq +oQNHuFd5j6Hjl53WAoidHRV/F7Oj2iJb4ldFugOllD4wNDqaLDagkcFRi11N173jq8jYjyucJ8Zx +NT0MrRazB43OZhRHm4tdxX6weRwL0ztiRh1mxCgE7Rf9JuoxqyFCnZ2Xboim3DhVeKNI1yi6zZJ8 +kHKBJ0AiuFPXOpdfYXBA47ycfknEAcWoDwfmWr85ZoJxgEc/81hNoLIA0lLZe2ruM/mAWmYLGRuo +TuU+8u0ANtajNI7SUPt77N3EobDMgNngqTdIBnoOimPb+d0Vlp8Nbmri5729QZeaL8hhm1mRADZe +LYujmG5yu1e0VQqze7sKbrUlyqkjRLWQnJdCR/6ItKJ7FtnS3wjqCtKg7zSr7VfsiPbi/oyC4UlU +Pd+HWYuogU2NEXulJ4KpNYsXOSbLOahvfxMdAM07bearC3NOUNNxuZMesqDdwvYRQKJhg4/CqMln +bPku9BgkMH2PmCchMQV7ZdWNWidKMGZXATK8IgQJSJ2pwXR2qABkK7BmtbPMH+SK88vy93QT+5HH +AXhz//4MADW3w3g7iOqF5zBt9wN6RHwm1lboA1c9dJj0fnsoYjKHHduaKdIESbt/M3w0lUQUvwex +WT18ZNWuu9GNhTYs24FVWJembwF++w+jwY/D1JWuSqd7zAzdUxpx8ZXnbMQ8Ec9rivbqeX0fXKxY +0hueK93UJ27k8IpvnQoe0Vi3MlDwGMfpD+1JYOit9ba5xI+V3zo9Jmdo4NDWNQqUQoxPltv+46O3 +RCLo31C0VaB+8BmA3Vs18bj+6Hb3pxgdQdZxBFFWZhxvjSbd0cyqWse38KFcUOz+Ttfue8D7WC0N +dYD3/RBU1cvhNaXYrTdfc3uGblth0yqZP5aMmAt335sQpvaVbn/gn3uBpPw/2U/EtIL6kL6M8Tzu +7qbAsNCNqRnQ2JKugnyaFeFDItj5frXbbdQ2G+TNKP0NIRwOVYdKqMk7Yu9XViLk5ezjsN0jIs8y +H/CnrJMhQdB8PUKEtAHdJPcBs8GWpoaZHao/jlRmGSOGWeth+3r0JABYmi60+zMiJ1jxI0M62ySe +qHUniuSbeyvTBxSQZplow1ykdVANmCU/I55AcwXLvIZzH1Ea3LQRg5sRhqMwEEggsdkYJ0UBcVhv +tUgeVScwm27PZ4RngjoDBRZwZJ8/HUe7bViCJGp34D1M9LxaTMM/RQQfjc7Bq1LyEQ== + + + QxmaHhf9++fO99U5XT04STynrLPXwwIKmFmRbhuaMWzfPiPeN7R6ZXDPeJ4fjoMXj5w6rNpK1guV +y9AvnT9GsIkKaolC6u/a6hMaJxr4TigRGBuRvYBgeTTnbpWdMaQtbOf28leQRcCpGxWgfR2o931G +5Nr1gJEw1AU/83mcV88TXm3t4yRc/UrChZdUuw4cZSfOypg8d6w+dpbB7vGsB1f2TM9xpmzAHyCI +o3TUzkCFo9gLT35MYuBY9aI24LH/GLH/qF/rzBXHuh0ldMGzu6frlL5ynO4vKEskrGJv7mTg8VQD +zMk5RJ85UQzE0Fx/RYl6lI5R0PdOgCttkc+iNaXQJnMCxSIz6Ik9q6oCIy9Cx+nMwlULeJeIfq2v +LEW4FhAlSoEfUeo3JLcEgjwV61YIbOdNzzDN+B5RTltfL9y3cP8ZpZcT38CqSScxQCETzoCJIZxq +5lN00+ku71/yWBIsMRS6mYHuL6XNcfQl27GCo6kuLGm8sjiIcQwjqAQQgRtyIqgEEvEqCgKtJgIz +lK8TRCeLNAYNTKumuI5hZdrOmZK9PkM5cZQJn67avxILuSn13JT7RFgQ0T7jLJZcP7cbndSqevs7 +6/G+CmCpfrE1crdLUQbLIbQKC6VnchhUPD8j8FCkMjxRGni3Pp9Rd4CdrLF0DqqtxK5tapk/OfOg +wf/87Mfj44sYTGfeHCdI1dn9V3YF/TrqnejFKKJas+eeQM9IK9sSuRGVTC/2ktv11zMJV70YbicU +iwLr+Jg1lMxBMrHVRgg8Fddlzmo++8SGnJrIZ8A/vm28aXF/tqIM/ffD8N6HpetGJzvZFR3kQenh +M+LHBfIjir4nynuI8iIVVZ/xRTGFwHELE7r7MZiDt0czSBbZoRNbIZrlDy7xPS7xvLVw4gAewbG/ +7e89T2ys9lVlKpOUsfRs7U2GRbOLLClLfUe5jpp035BnxlueWceP3p3vY1YxmLdo/+qS851I9BHx +X04Zybn74+N7caCmsndvUa5Z7ex7LiROqijJhz4AjXG0fmQYdx48CFKv9dGV7Mqguk4QxRyCaFb0 +662YIdj/nIiVCOFQRqwTUd8I0P5ElOfLZOm6wnkalnckPF+H8HyHvXSFCH2MptelhBN/Z+fLRKjf +ORFIW0IxeXnQ/XhV7AVsX80eBqo40BIcLGKdqmhRAlVWoQT6TE2Q1vuOiE2iVteIjrIYQBfKCV79 +b9qU74YIQRPNoFuaAeazyLCIQx+nZI0OWVdH0f4e9Gkk63G2SfWU7eQfSvjxn1iBhxG1pxIoHG2K +l9oRmJAQsffk6xzniVd6FQwwnS4YGH84rtPyhabYjC1Qj1sxeUD59WOEDmU368GdX6CGzYXz3bEP +ClkUyZi3iDtrTDv3Jn02eU2wkKv2V0spCCbxFbqUnhvobEuWLUjNJLmrB+k8rvOcU8MKixWQLizW +R37q/oPtBAsf82h/VtP8GjWzz4h9SWVoo8b51aW54uhgFJlqPbVn2MLt8N8iwC70fF+g0g7oca+k +AhNwySVLxSV3iSNFkVpMlnCZgw4/gjjwygueg5QZ+cYP2H1wSu2Y8EBfw5wW7I7pxqNGKyjpkhWp +4D8G6Q0SNeC8S4PaF49a0kekhR1o0Y66QGpdocYRoaMziKYiSijlWCJq4eaQY/pt99MHrk22NrDI +iwXtwLxJMTUD4FugdwNec+XTVosLwt93jh9ZQbBbvN58tLjl79RKjIhgIKTJ6xXFr+Fl446MsYfM +g8WEcluNEVrfWfqBFcgSps2MY+6zFhq8v+BSRzkACOMM4ojck+tev3hY9YrKShEaeoKGQTSVKhAv +KPSySYI9UoQFaeUH9u+OENIDaVS/C0V2bJ0yS/4+jTUU21Ml55G7+qwYFnom4FCcye2rGhrAwGgc +OW5hq0gNyHkCsd2z5Zy/LcVkxyCPO6W9PpGVQWdQQwQZePQ8OhLLRWCkrqYRM3M8ZIZ9bKpSNSJu +HvOrcftxFDitrG60Xdu50ZoOFQT0WpjqPFBg8OzcKHI93r97VFCPqpwUqKnz6zPIEkk+aBFHDdm7 +RhHAntpHBO8CyeHDJP6yYj+iQJQJQEabiNXhGmlbY1fJ9AvhI/JGXVO1eByWdQZmBl6TefjXPi58 ++/uuP3ycB2FFei7KS5SQmG6+BkaKUch0zT88PSssmqUbIsyfA2JYh77J3hewpRoAwZdyHQuVdBXq +rj9c5PwpTiL7Lg5/2PW2mHhUZqjd+lM/MQ+p0DbO0V4oK4NmLPxNOGpBRKT6KakUdLhNvmrwmqrk +AX4yguWVCNX86hP9fqfKVr6+rutLZS4Q699SCgAttsiN2NsoObGvQFshmTKNA1SCEGrvzebT94Fc +3O+Z2cfH91yjHsK+XAO0g1pQlDfRLHo0a/8e4V0cuYsH8/IZBDXEmaK7AT7fc4iIRbuKHhapDz2s +Z7WQ2AXC7X/NLyzNXQ/UhZ0QRaLvUcKpABQCp0ILgisdmFJJC8OJdUSRmolARWq+Y2Bh46CxrlZE +uvZQWG4BF/eBU7GWi7iozw+17o+IOmIvhKjQC1dOFJtNkRvrIDIfkROdioECRtHXJQENLutSc42H +mcQGYVaNWZ47HGScLCOnNoSi5LGKveWDToVkiBX3XWxRcAMhYBUPg1DQOIaYPQPLqRwDm3ZERwGu +sob338fPEgm1hHnoARnz+HENpwoKtSNfD+Q9EQNxJU8AALI8QmqimkpPGtOf6/79GttPrJDaXUir +Sgw8NC41lbRuHZM+Md+oUKrB8T1iFX1/80J/H4TRRLnOOYcTwCJzS8TuuJjPka1AGdEnvlG8UFoA +Rifpy/eILCEzxlUlMgU/HAdVH2qFqPpc4h6HksmfAxQiTUTuWn+DC77FfNPOprN/SYyGyHsHdRHY +OVbExfxuDvVzHgWMPiK+5g/aqKg/La2Svh9nL3nWlundy81hoyuW8A6+C6gZ2UWu9dAG4P4i1WFo +KH71tqqrq/A8ADUxkDxNHheeDmiAi8oS3BKOa3LCVhl6Ie4ACDlErP3r+HZdymmNEUT9hiCNZ4gQ +zUjuqVerrrpdAGrgk7XHAKGI6g1EVW+Uy+r+ueXlOWfC0agFfnL8VGFMV6T1eMLmzpDhtHwMrHIu +wfwimCRIkySE+QKkVJP7oiQFWMS+51LTsMSTsZo+IPUw2nVAHskKYPPdnxF5pI6aI0TFsvoPxxkl +Thl7RrvkUeL+qDAohDByfXp+Mza64afUYI+z+xkxMC+ATFcUWsNx2JPClIm1juPdntzm4cqGGNQR +z7y9pJZG6CgJjKWWYM4w9mR9TOU5TkjbTIxX1L2VgKGz9UQ/Ek8O9CPr7IfDr4cK5YF17KbmSgTQ +mRfQF7QXL3VpPxxnHSEkW1ztIHtvcbXrKj8FvEzWhpXii7L6FgT9ZipMP50M1xGZgi+91iFQUUe8 +FE8u+T2PZsK05OM/XLXPYhZ+9YygrNHDA5ky5okSiDy0IdWT+Am683LCp58kJJoe/syJ5lIPYFqr +kpoUQtl+TN9ZhKiZjw9x2QM7qXwcRqukuXWYTaT2mgwI0fmuriCVDaXJy2LRS9PHm1uZ9b3/jwR/ +fB7oP7OlhDYf9OhdzyWN6q09zvlDAJ0Rpf4vyiRf2NE/BfFcGbT3ANeRexchfu0MT9sy6BQ9+69L +wi/yz4m4wXx9RuSCjWR9CDHI5v48Tjt0Qwo5R6eliqDDa8TKST/80p1Qmk+L585FEaziu0LULTjx +JqFOVL1P1M7R/+35Pk8mf3JYJv+o3aPWABJ/NZgg/n66L+4WT53ozwGUXZqAyQaW7Xed6E9RHfkK +ljepRLdyIdmHwgdtURTUZxYJ6+4Gfd2SWt55H90queewyi7rEFZW450D+MI1pYRfuac07PhOBLCp +PRzvw28La5LS71EIq5hQu1ZOFZo00KvHQlQyAQQPOtS2YdDBNbFni9bqMSkYx6TguMaDwQ+y4yqq +5UL+bDIh3UrLKFeJqIl5KzE/VDUc/XXEaKnlPcqA77xLXfHnlb3dL+iaX4AOEz8A1Y/i/nRnsS0e +07xDOxqKJw08rtzCOy7QYCcguP67fxMBdJQ4aEGLTKfRJdENjTfgB/1opO131guBjnuYRks1Qunr +j6CqfV8Bx3xEvBCmADeGleAfjkN1W4q03hEQURYbkt8DiA4GezXaemEa7yBrPCRFDdynus0uEZ1O +KZJa+nWJg78qGwdsTwY/vbMDnPYFervkJd2U9/56kHKKe3XlWQI6ZrOC3j0Vko6HGFJBz+siNnQg ++PW3MXZ/T0SfXPt/kW//rzzYhVn9+COF3v/xH/b/mL/+m//21//2//6XT1Z+/ff/j3/+5//Pr//m +f/if/td//5//83/8v/7Pf/if/r//8D//+//j//yHv/7zf/r//8M//+//8D/+h//jP/8//69//v/9 +p5z050/8v/7jf/qP//4//8f/8A/7FH/6cs/XN/gbsgD/C/8X4Jn1YXgt+3b8QqnkYhlGNgdz+V+o +V1T6VL75+878UuGjKFuKpON+mS5Ui0hzKDzgVb3/spcGNrTvn/0UUMdCP1kxnJ/ECBZupOKrrmBm +cZuHtf1PGURt7HNwIclLCZpClkpTBRJM+6W6kSqQ119ec0V2yE+JQ1U0TxfZ9PilvrzuWZmvEWrF +IPQXHhTiaWecyUnT1zop/3P/JVBAIOfsxvcgoo+/GOhPBtg5MAAowoGrn35KdoicQSmX/ScVsO+d +YaGW8mjGmtjuu1eQznFAd1gHevcTko053A3XlHI68lFqjsFI238gT9AR5bv6FAyqZfNOoAM6TNwi +3nGaGn7bEfqJ9DcsJyH5Yr8WrO8vAdwCl+6jXoRWwUligb2sFSw0CiFCqkXajXPD9wShr/ie7or1 +6UUhowQtLkAKH8GvDIl190DJa8RYl7s+JGyGf5eTv1A6Zh1ZUEqWA6E0jFG+eEF7UIlrZOU0Z8Qb +Qt75X9IRA2lCC2/ZAPI0MP74+1lEu7udCBgV8ZQTdw0ot/upUpDJJhp2llyU88/M0echzZ/wu1EB +9e4HLIyzwZ8GbkX5byU0c0G+xlipFfPHnXMflFUt8A06Ii4OVQMs1FDqGJ8DAUTtT5UfBrUH9TtQ +7UVsEnwJnnkg5gNC1UsbEOqXyyjVg3q0tNNiQrnr9lMoh6nozIu172GjlgSokzTVgUtjPdVrz9Gg +X6oVHWw/YoPkDrQMgrtS/ZhJDOlNfLfCd/mmLp3kB8paOCoWxVVXI8e2CxA6wzVsVndLVOfvPCvw +YuC8PG+l6h271ZECbUPf6Bf9KvacQ9lQsCN1oX7+q4Dxw7vy+4BvMcDGa3wOXgKcLfQv9Of3Fbx+ +fCqugBDLr3KduWi9yvXo9LMKwwgM3DF/x9P5zjtbpLKfSUkwP9Zpe7Igl7qFAKjdyCoAco2uuGZs +yts1K3vgA/QwYyAzTzuCq6Bz9nyFMRv5oQA1HjUAauXITjEo1PGQrBgEJcOnNFNwAA== + + + OI1tovJLzMsTJ0XVZvff73HUFgvb7Sfq/JDv9mC9NNQAmzNOaxrJqDt+pzshpzD++XeOJn6u/jA4 +qY2t2AQg+ET///cidLls7fQzv1BwQDlLF3LdLF177uBT+86cxU5SP4vddLH7eYl8E6ZwvAu7jp1x +ooZRD3GJkv7eIoNw/CcnDbDFoHUvVp8p5+ZYYRY2ZnvKAZZhukv2XXwW2bAVBLs0IW3vDFii4UU2 +OQXZC2SiEUiGh4GZEXtzYASCrIKhHl46JviZwz6KbdCnvR8jeCOJKOWgdUskojCF24tFDdQppgLI +fU7OVPHN4kx7YSiBTIWVtSP27yCAEvmju/eTgAUJlhPN05ovQ2FKs33YiQAB5R+t0vIm0GYHgI/a +/zxAOwWQyc256TuvhIW7H/bnxjA3M6SwYOT3xzivGlK6kaRjawNhCXxAYT80cNHZD7EIC0VBENcl +0+9EaMASp4hjreffAPzuq7N8uw8sA5QwDUwD8AlkJWbTsgMOAhjS0jAAesUOqFcNQemS2oLGTfl9 +GpA3BFUsWUTfSjl8on1GRMVfecCNDNI4rsX0bFq+SFFhFEegO1/1II0rO5VzIqlgi1P1LJ0BC2tx +Mfc1ptgXYiS7ER0d9urxN16Bv77vC5pwOL3ODtOpqVn1KOx2N5/CfzpR/VJ8Zd0RdqjHOfNuuDv/ +8jg+3myjpHTWV6iswY00AqEqzlRMSyYshWrE/QpzE0WrQ2Muy4KTFjuin6AinsfjKI42QUbXeiK6 +yA4e2B2BHNrjmdIy5Exa992Kc54zVVgNlnFo4yKoCEVmz9ba5qASCTmyp5qLNsYFf7ftCNhP+xY5 +V4/xQ4RLWAclVj4HJxL/FsrHX9LZvCq66b8mSY8oqiUTiNVkvSZME5WRO41vrPhoafO08KnUE8jY +Jg2fDlp/D6h3MjIwVPda9ayvquLNtNn3jhm/AYxKJx8yWXXgUfALnxuPtuCn+eVQoypIlJyjsdGm +ioal7H7HgJSrxjearw5yiUxXv+C+qnHBy3EavYt1Zhxr0cd+xHNBsl64zl4xNY3vEpasv/+MKEVd +1s/veXRxfw8GGkxxhc76L6svFJAR1Fox/gOhslqyre9/92dhLbnWxxhILMtwMHdpNqByjiXk7wHk +JM+1+fpbVRSOSyAEDKElBNOvfYf3YzdtqdypK2slubeLOYJy6qk4Ix3PyN6EDj6y2vlIUx6xM33n +WP5YaNTWvoVsjPdwI4Kez3Fl6/tW7HWCVKdFEUnvNKA2dS87QOIi7vUcjE1nUj7XaJxbzc/B8vaC +3LNXfnlRWkl1O5bsIludf/j7c+z0oIKfvOJr8JkRS30U1Xn4DjeWdV0WJ8JhmETvTy0dx38Y8BXE +9RRezPfBB+ETEUxDkW4eONBSvwfuY3zL8j0PzPj3IGwemgVNz65fj2469djvdu15B3fmIfcskYra +t4xqexfA8dccTgpj8zd4I8AH118Ptfv6wx16SGh1IjsCLXumB/nrMgq20+ewAtmN6Ekq/EzDe4ou +4Ol5kS6ALqlop0LfLnnNO5ciVYbBxLt2pK/ojWmQXIPOJGovDTt9AOJqOdv1ovHS7tOAjrCNtMDv +5kZf9jwAFFysBNKHcO1EvGnZfMnvvCbouDM/q/BEFLnLMEpXyAuJ2v0kFU0whAzVveqURPjSX7al +CFga3aGdrBktb7uNsH3uwxsjClm7B1KOranXbk2DmvvxODcYSRQsZknXSTO7C5RUz1chWf7QAcwJ +wKp1XUprq5keaPsjsjKLV4TldEzElbS0pDth8X0ga57F87++TL8JMMRH7GmhaWKXmL7OZQNJ0Vfp +u0iGDIpejXZ0OplR5dv3VOqp3S78E6ceZpwvandcCDgS7EKaTm7ogQ0jLp9JTHbKy05tGBwapbOk +Uc7lRMHfdQ8E3k3N+ZkIFh7ONDWjrMmLiRhCTavFARb8Z7xejkSx6NNYowQVwKcaViDoZ85Ul9/l +9ukGKztVOO1Nf9Nii5yeM9ifk1pgzXdROr5fcie1ZimgUxpeVK6WXf0WYD5K2kP7zHYd72YKY5cA +wyJyf05Ju7yLAeGWLggX/OE5D5ClRSG8j9NULuZLKvc9nmbnINbNIxP354XSMrOttYXif7OxBFwQ +feVrvjQTytiUPClMpkF1HbGk5p4rde78+cl6tfCO8e9gZDqUxno08m+7NNaKfh8ecV+idKag0qNZ +elsNdU0jaApTR7fVxFIy8gWAu+WHXLhC7q/oM4IO4fv92d2wxsNc0RDi7ifzxAhdN3bcZGAEdRQS +puu50hBXcU34jIge9Pq6D38ehBGOkiQacbITL+jIOj0szZ3BhoMGspa4f1Ghvc7LMtQU+CHCeUJJ +Q9o0+/a6u/44DqoEV0T4p5JzVLt2ZJGyyVZ2xgT3A7bkzE21Em39gZzQk1259DrdL/ZNLrQe3bR0 +jHBjQVHtz+4FcrGKQGlYWgGhz/58RqTaAILigjK5U2BNDL5FcU+v3HW2rUM7DPQmwDg+ALM/I/6M +NH2frj/FNOVWut4XGFbEYnXvUTRvYGeuOcWt8/d+uveukcuOwyL7K/p3nxH+oqVbBz00lNd+iCoT +9ydNV64hhtIWu4qp4Gl+iqBlpL8ZdfuvHd/3KOEbrAZMifi6UrGmaTl8IMtxtAaqzaaFGgApBepL +A+G18RnwPm+TN2Q/b7X0+4fD3IrY4wuqB5wL36PU2oXKVY9zKNPygP4+giQJMIAk43qtSUdmIqIu +F+LrYAuKVs05Dq/4joAUbkQsfffax4akJCObROhE99CJYrIrWnl8nYgKBUEzaLjrQMudOj0KKkkE +oCaZgCi2wcbPeQDoPZIIzy9KHlWi9pITARjnNWBhZ3pkTkG9ij0CKje4ru7Ji++730l/M41k34Cw +/vK+j7zvdX0G5LkDa4n0B2DHn6K414gtc6+XVwZhFt1hMWhoPwUsTRkfxHzKW9H4jPqGTyoYUV6Z +fZOdsEMnEVOAb7/WYlbm8xmRSwYEiMcNqZOn/nAcGhRwp7S/qfmi3RUFOXcqqR8RT7dDgkAwBZEz ++3yLUolT61RxB8Vv/FjjQXXiiaQ+ZQYk9Wmw7x+LEoCXA/eTz4D3VbV09fHpgfIFZYzL/xs8/uef +3QRVhfZZvd7K2/eoFc8VNZMRaOW8efpW3MrGUhgEnNuNP2kBa/swh0AkAMzzPSLXiSItUfg9ykn5 +fpyHwo8yYbOq/md2Nk52hs6LPsoHXfHa6mKMXCAA3wAdYxmUjTKb0RE3aN11ulpIRwEsiLllw4II +DASJqG4ShG9Q5gG+8fSvM92DXAyfrqMomfmf3UmNizOpLxF3FPTvU7qaXNM4SodSu48hrcUN9/tT +UCuWj3PmJSxcuBflArdftb6mbo3T8G36Iv18QcgBGbs0PZZk8n0g2YXwl6YcbPwqPz4+8t50hOUk +j9ExgjmEqQVUzc+IW04yD7sM7Ddv/XOUYgjU0NmtAY8Wpr9Tyw5AkbsyzoaqwIvGFqFg7qVhMuyV +SIjikEPRZbQ36b9OuranQ9Z6g4DmFvpnaCMicbvTWFRu96SZiPVkAESKA/AjGXjIjGnJtpc6bhR0 +vB01eDbgtqfOtLMZxBE4AcppO+JSLHtHWG0p+rG8N4Wrsb++6oZEUPbYEV9yUCTqw93JiB8st18v +6EJhG949kBSXjiYWRA8HUVelUG7/IQCsSrNtQQH/Nb3/HtVuLe1A/UJwqjZwllmostkvboqNT5G3 +PN0qvn//enrnCLtNiNoZ1BmevYXW24/fyb01iEI0QDCGn26FaFayJd0/PIXCnXJyJUwo3bizAJai +ODIPnmUTtI54XVhNr6wgYCiixZbyIfpNpLQtXxF4RQBifw74x7efA2eVYna86r4dZV8tAL68Dk21 +MjzUl4DICQzqh4gfF8HvUYpG2+Xbz9K+Eb8KlM4BbghnFT1l+jHZBNu1l7XSdT/DWGFgkK3Pmybo +je7WaXrQGk+de+8HXELQ25aBQwJGbxA1JZYF2HYtEujTejH4eyvhtFb3TgpQAVmVBjRSV+hXHjcD +6jEuFBO0XtIQQGrFNiKQyqIiz9eArcxrZganKPyWQP2Up0Dreu8P3HM+3c3Qo4X9nusf1gNx/rf6 +WVa6ELm/379NzR6A+RpsCezJtJ2BeQb6OwDrC+uZ+R6NU8WCAkKU7pXVulkbV1wwwsLDb3YvTgyw +Y9bW4oo9hlpzHg6dL/a9rHX7QtwIrACQR4gt1D90MG/+LbZMkt/pE6vm+4QsqUwwNA2WZEt31iWf +83gghU6R377MI8hNgb394pR5GFRCZMFwMCjNY89NdE9A1xYRFSOs2kdm6mRg9hZk3TL7oN51pBF9 +CWoAdcoasqCwKubtyICC3HtAwzoOZ+cVGfspBC9pscV1TDBpFevPI8NU7s4vNhKz5l1ARdmUFrHL +W5O8R06qWqf7NUfdLddOVS+ffBVOweXvjSlYpL1a3HLP4nTZKIv94e8jnlJI69YX9vMOwpsukDrh +HT+DuxZ8FJLVdKDxfKLbUkgKr0CeUIPD+vVBhyrVVDRMCk6OnWfdpnqOiy3kfvnwBHlm0aZTkAmZ +BzMFssAkGgWZOWZsVE8vOun0u0VJ7e3GF3hFWbxFHafb3+k2vwfChV0jUSKAYD4q5KpqlPqkEWgq +FsUFeZUb1aM7ZxLedYGMeb7OxCNIlIWXfJ/ix6eueQAYbv/t4kngZeuyHtUCqCJHnapckvn44ku1 +Ownqocg/MPv3JYXF3/BeWSJdaMPBD7ox5WIGkibTsLmK9wVFTa3dmpLDOY/GHAPb+UU+fqI01KGI +9XgcC4ToT8ArVGMHMfQdcdNq3A8RMIRqxdS5lK/C7GBf+t1qEdWQbsCB8JDp88jAJ+s9Z1qsdRd7 +vHL0x5YDVoAohWnzKw9fkFlBJvvrDpg90UjTa3RE+4b56rrCMdV79EZ2Zt+irwGMdfzNgIxPgfBr +UN4IVeBKcWl6A5GS4jydFiTcWQAzSoXcNDDZ6xWuKflG+wjw24JQAiw0QSdp5fHtKNZ0NHm4U6/6 +xgn9DGhBpOuj+yL+P6N6Dy8Q9Bca5xTQpRXCyMfXj1o5zf0Cs8i+Jb7BCLp9j8h9hRjKDPxYD/vh +OD4ft9O+oHTwxPFyRrd4zyI/REDtbfFxfnm1n1E4uDq5PNga7+NEUud6QnMr0kR5Q73aReVvOFK3 +t9wp844cwu97ctOJ2KljEw5629HgwWBu9TgBdyBHAzCBCLFFj9rmRnSeDkR55zlTjR7A3i6fpiNR +ZgATCCsrD99HPQfUosmEiBCJAkj2PKTUpokgdzeANYwA9ikwVvf8QCsSOtj9dSLLXTboVoiz2UxT +jqD9Unmde9QKWAighXaO88AppHAgWdFlu5oafETk7nzLeD6Pg9W2VMoKZOX2uyCdcNu4W/WHCJ+D +fp6DF6TzEcVWi0z6Rl0A8JvfeOUbP0e0Qor3TUViZ1y0lAAC0SVTuu97wD8eFJMdCw== + + + bE+d+T8OA9yFNZgFQ0FxifM+VwNsjggS2wh7MgVt9LN5IDiUwGYASdzB4veDp9kpijAWhSytKcvD +LyiyfgaoQtlUoVzPabV/BAE32J9FN5PaOxhtkjThPBRwsNt2R/Dgm4vcCEka8F2qvfO94zdIf9p6 +T7Q9iCLhxwq7geUquo2xBvHnlghflwKa5U4EVsI7AmdhIyLDuF9PKPHvmbK40usQtQeQmqmOKlJP ++xVYtRFAG8EdipblVWby8kxsSWHVKsVCxO2KWr/kGgvZj/n8vlLT1dn7pzJgRWGWJ8eiOGCQerBB +x2UWW4f+QwT59gTR2ck/51dj9E9R+3k5+l0F3f3m/CuHRFdeRH4RaVCjCgu4m6unMuTnwD+eJKsu +DXumVeCPqEfEXY/ImgJsmBWzML4DGrO/3Xn/FFW4GlU4Fnut0BHWICKwVQB3+0JdCrORw7K7m58R +X9NGh9WGSsT44TCoKdwxeLhIljEndq/It5a7iLHLfa5fz/V7HXYJ2rfQIAqdRgHgQSxMZp4RFCsR +Zsenm4gb8awdMfIUl7TiOMbOUo3QLmsVHZq+zuR8vE4XCkifGtlMiOV8YZxYADZhWhHQ38WiX5Rj +MoLEkIj93uUQi0eL4vgB4XBBcqKLYjKHWfH/3p9i5tkPDqUnMIpg1GZwvrTb0Q1GpPEzgkc0lwW/ +z7Nf+oxSvHL0iFdSyGD/Ra0I9f3nflVU76OiWsFUTARSvv/dRwpdvLI+xjBJobMIwhjtarpmWntB +NRSBDgT+7C9pugb+3w8yGvRjdYsYrCyFce0Q9hZx78jAtFR2KADa1yERLJUxhkdhqdlHYZoX/3LV +bC4GuSfMJipxMPFoO3wMuDG8Ajb6GBx0roUzisBWhLJSHfkaoNYvjHHpbBU48Nfgo28syHi3q6AG ++mEeCMLczwN1KOrXSBoyUF6g1KQeEyZCAJnDKY5gTDSOiK40CfbY/sRsimmJhCYRDY9zuOU94SJq +wTvA1FU+Nd3u7IEo3FP0q55nYFHoAJvvvR5db4FuduTEck8uRDgpZIPr3AvVLMeGI6rsk8bWHwcQ +g24v7O78ratkIIA1Ivkk8Kh7Db7J+vHP7sHRJZKE8G0QIxMqB/cSbQM3Eggs7JbsfwGx5bLCH0xh +RgP13j8H/21OtZfpzJs0/ZjwCrhbFsCsGittlb3wFvSU3wGEyqfTxt73zZPnfw0ijs36OePd9gsU +HXDhD51CFg/2BQ+baHgxPyoZsn8o01L4zjtgGnwcp9/BmNDDuERnU92wMDgbZaWPiI9FJGXI71H4 +JAucxny9JV/ppiUt4oZilrUi3wmZjc72nGQ21fGIIB+OKIDp4ATA0V5PPFlaU0vnlgeDM47v5xUs +9E1jrKY5h+Kqol8rO8tG+7i/sK3Vk8eY3LDY7dwRcbpbaNPIsWmIsY/A0EWVFajz0NobVcB/dxqS +JFhw0mnpKqRGYQD5dQSh9pelUrwPA2P2SmobkgA61ZA2Qdqrt7BPNtdHQAriVzbje70sgiq+H0Vr +ZG4DFX23jfWY695IdcwfIvZGgo4m+5PR327FR9QVPSFVYEnYUMa5bUlTNB+Kqt5cgX1GXHUCOqDa +vx/naxwRQzXqZ4vW/aN112uo3IB9DTXgRd3udLBpcw2pXo0xhJb5Cn8LzPWivuR4fjIdC8zDP1IM +S5TaeYL3Y+CqSv+UrcJ+mXlT/+lEifGY0GbBmzyvudVgkR6pcYMP4zhS8SiWym0b1m+MaGLm0Nqk ++vX04wQ/KP2eFBMKizgF5rFY1dBe1KoGOjbtATTgaA+gyW62C8weycluGW9JQgTqcJ3SCyalVfm/ +V4HWIHcv41IMhyCnrv1asgARAF2Cp/qxnspGiqr9Dmj8wqJPyTJiNngBM9Z02Wr94UTtsQD6tHrk +Cp1qbiVDcxw7bNxFHiu/ij/1xo2vHbGH/A7IEvt3sK6c4+Ps/UhmerBW2JvIBfGmKEBuv3rPgf04 +jYyG3rIaJECELl3Wl3yWs5IpIc3fUpMF10Bz8FFF+MmyIah/MX1VWsLwGjAGJF27In7/2EDcCRdU +/Iqx1d4DPYqdMCGTeOpwhOT10RsENIWx+GMug2YvVUzAc/2g1hDEmDH0EBiELXh/onubpi93Qrli +iipkVsDDXmZ/9OKYQGhPDaPICP04VIUeiI0DCjcjaGTHfM/+V80AaLsb+f031zEKUGmHwtVz9lj6 +IPJRY31iYWRH7M1UPRHL41w6bqD9BBCLtuJd47WmCypnejMYIZbYSwOxXCfZ1hwTaT5wo2GyLxvt +JDihJAFoI/8HILCXbbZLQwkeEJeaF768e/B6++QIVkO/mkNXP/vJjdZTByg2WFFntoezC8mNeQnQ +FaGJyI3bi3otT+ppIzd2Gizse1XsCrHifDN0TFnA1XoTuLUjSpqZci+QAqDkPyN6jL0Josf36/eF +p4r8C1imkSbuf4H+x3Zs5+O5Bfh+oVnMRoZrTfrp0+VejV00VXakjdtrsFFcER3EaUSYQLPH2gMR +Q40cwKYRFDKtdt7FCHA/RDwgOD0B6tH7BCrgfDX7xVqOtLOIkvk7ebiFw0JqeIxolMCJ0OgWOJN4 +g6L1UY4R4WMg+CCTF0aj/etMT54wlRe9Ek7h6irjtVBmKhZdTQqu1XV+082f4lBjxkAxiEbBAJH6 +iDVlRnvvdhf6jNAz3nfgxStp3Z71/4I56F4/qYwN1cmR2mMnxZfYEXj2gg6+9FCNgV8d2vONo4CK +3rxLFvVvzAGHJvM7u9qPiTaEVblB+fVdB+RBnoZMuUdBOKOCqdjHxyqMbbWwt/UbORzhprfMMV5z +P71vqza++Aft3Td3lv69CJUrMHYEMEi9eQeQCLqdLvupmzk7AnV4fCF21P6N1LkoadkGQf4ZGPtQ +5Wv/wN6V3bqnjqCRXCbqso534fPZjAIXQRTAWSdm3WlZX5GuM6Jxuyo2TQbgMEBA00iKE/lD9yHW +W4+AEkHOAdKWJkW+Dv0ETD8fDyM0YAdA1mTc8jEr/SWMi0cfpAc8rZ4j2I6iI36/xR8NOJlb1nlR +yLNmrseD/t9eDLFA3xHXsXUEn35+iNTEAfye2af2mG5PDNPeds6NZQI9wHrJQtf36VpN3ycLbooZ +VZY/UyJ3OqJmQR6B3CaLUV4ahW/wJ/trYVfytR1ox28zRZIutS/ZURcXOswu/Lj8ZM1G16+/nYe9 +md2Poh304pkw/lXGx0ES4iTWnSh/4YUeAx6RH0n9AE9Tdd+bqCq8l60c2clzuCEkUKRvUmeokdKD +0vPmekHtOwt/jmJgef1MrhVIHqUu0FsOUqh5wL0NPw3AFT7NCjBzHeFP6Cjg94loYr12PgQsTpNX +FKWeBYfw60TPfcRzbIpR3Tsfnv5Zk61HikGOipI0R907yCcRsKcfy7cvil3rU6WMa4TX2oGQg3ta +gXjfgDGGfLAVncMlMhFkWnGHttcUrv9sfR5BxpneEK44Z5s208tFfKFLjhlq/OzjIP95UmJ5o1z+ +6Ve5ZX+R/ewVgkxP4vJ++xCw/WTOJJO8QiQGldCvSKDxjBqF9FjRUuQpZoe1hKfTNAe+0A08EXvu +JIIXk4DwGOzfvnhmeAzNxPNGzI+oUaK1doMrVeLs9vsCwTPAzfkFaGnkNCJsFulSxNqUQNsT2VPf +zBhCN0/eUHYvUpkdRM2+4lRquLQ4O2BJVCNPUaJ5Qc2ZJfBvviJ//Tu+lWiKPC277AcEM/MbdcF/ +yiBAyAidQnTfSyLzsRWjeGPd8YLjU5D3EMFYkS+Ggmdvs72wknEqOXsQQ24Gm8UrUu6evqlOKnvg +2jtZTzM1LHhi0IbcYD2MCEpNYi3GgT7xSQQY2drcNS16ujQ3Wm7XsQEYmiaScx+JhzvwGvYPUR4h +ya1UNFs1r9EMCq1fRLrHL/ZDYPnICa/khKoQvhTUQh/VQepfe5CiIduvxwz4jooC3lNAU/gAyX+9 +dRjk730cFxzGKisGiiXM6chr7ZmMbwAVLVYcJVYcLOpo0heWbgYeHZFh7b18ywsc56gHCQRdja6/ +ZV4sRKo9KL4a1Ivn1z1DEbVSpncGTJPTjoAMoKO1EEdKQyLyBDlZ8KSUTr1x5wB/EdS+5y2Ih3ug +vBe6wqs7PZiZDd8+FFhDa3fHyXFPQWVZQU9zYedrgwxmHydMdsj5PU2eDhh159IwmGIJhGo4lkDX +u9cvCPdDoCUJJXGg0cH7S0YGClTECJMwBoqxTnmVs7TBDdIFRwigKTsByOYrfsBgpd+VH9AemML9 +RDVXfuBHi+V7ZwkF7j3z+VTrDM7/ieh0F9SODNCtY3+y4FL5XWooqaQ0o76Ijp1Q0najg1W9K2Bc +mls9ACgex479UnV0nW0oV49c7QQAs0ADEIkpt6OXsg8dQP3XibwGq8dpyh0jswY7RvxajHhqNaKf +n0QK4xegvYN+cju+NiyssMLG20i53APzLfb6zg4HVR362jRHuIU8KMKkV7vAc/p0Wjpxd395X+lY ++VFlvoEYrPcHFDVfbaNOCul8jcf6BM3O0QKNsOEtd4SnaAZcg+T8xFoQsHtqs738PqyMKDoPwN/o +PCDWw1OrQAPeE5dOkP34NC3E+h+wNWmQ3OtYQU8sXvKSzTBwY52MpMXEIG3A9AUQFofePSNw2rRq +gLFaJmExzUqhrJOiDc8rLdLAwdK9jCTNfZIgTk3yoeLfHQPr2NXbtfhCUSJZFW9ayh3gLlCwecpv +4RdlgVA232/9L3o1mIF1GjRWRtk0rueFLqKM5SwOnHzP4sFTPdksdW3/0Icf8M8GX27YIu+Qs1ki +2SS/05ItvyfKYmmrDbGCfaYMBU8NhbGHf9PIwhDjbMEorIJZ5G8kQl5+9fPRC6E9BZCiSYAu/eiX +6TyBm8Yrm3+/kEukIFHTuzGBn790GRRtVf1q/+LC+/fMubtqKSGrpup7U+3K6s4OcrRoaEbclJ2P +4IxkqQuNbPUn9qtAjW3g6jIPIXuVELKPUBCDXTvuJQJRJVT6VoCYJEWoSkZ3WZUnngdA+2dASUwS +4MPo7+wS6xn0S/DENw9n19PzqGDaVV9h26kwa8y/Jb/Xs5vc9+kyHadsu7+LarBFJxxc76JmvSxX +okgceVeMLVCB0PvA/iIEuFI/JTzRZZaeTFuMfiO+76SYqMYCL8FAZ/1W0Bg1irI9X5/cXNkNn3sH +blVVwThlQNn8NY84rH2b5z0arbcMDlRs2cs86nHg/pfv8HjV0Q1fDqi5wYCy2ihwfqlEwH6R5Jsk +HOrWfkQW6H6+HN9eXVJhtxM0rOi/RobDMkal9zfWswXHTqeekpZ6zpC50OJlnUTlBB9MCqtNkWhK +8SCpr3snJ6z7FUE5gFnMmAp0/ObFAMk7UgGIlKQHIjMSRj9dEnAqt5R1eBIy5KZkrn2VbpR4xUAN +hFbA6Q+6wTggC5a7oygU/HpNRUwPlXlk5mvAJ2H337CTDqlQExdkV+cB2xXRAhjORQ== + + + gwOiDyq/V39L9tQyhyAhKELVe5A2zCzAmIPkZXZDo3OgaI6I7v7/92+mpe3jF4EZUu6DzVraHEUq ++VLQY+h6iTg83w5IPU/+oB4kvn8FjYHg/nNqqdN9JwDNEYk26j/7ReWEt8hOPq2bHxK2D6CCrtE4 +FVCh9h34V94AtBGVlrPAO5CnqDgNREcW9PoEoNtpySr2Av1Bw+BH+aj5HsWpXjQ9cJb91Ewy95tX +2S3rChCGjTmbFfARBRIJpZ3A/LnP53DkLbN+DgKmeOo5HBiTJxIsDsyRDbQrNzWE6yhUa5TJmwTs +p/hSzsZr7uHucGG7hjQUavf93l8gr5gGCewzQU6f11xZkyv1CmvvcAXYve9HqUjOvZV1wUoayRXq +JQP99gdH0uN8ex+lDy8nKw6XEyIUak7qcQK5ZteC0u9+RmBaCpkGhi93ZPV3SmX2YH5m7PGRWNFF +QMpGT9vX3/xZWqztKUQgBGSg8htF8JRUSbA1552ENr4sJYd9eyvEw6u7/LUgtZW8eZyeKdYdIvHD +gaVrziNLAk4HGuR1RM/Qta1HHyM6E2ANFefD+omiF6JiJFb7I03RYyrD/fcmRRLszj3ZlSPp5ywJ +5UmI/CHlgMSdghNL0jE9q/ftu8kB7vDiOy2dvatrb8MCtQ0eT61ftGwpiGDunRmsNE24TwGT+jAy +Fv05ipdsYQ4ZtB8lGl6LW9G6/V9Xd/Mv5rPKCClzUtBQpf7Kbx+Rc0GgCaU1ZERd8/pfhLs3ATcF +0Yai/QwD1jdAgMgKbciferhCzUA1finNAgfae7jrPnotvLR0oem08hsfPQ4YUAqnMV/TFvrL/R7t +yvmfd9/TazQyfU5cZ9nCKBwJ6D1z26Vkpnv5pr6siifMsqmpLdbN0Ikj4I7fEoqRcGpMW55jStCd +5n814VARIrq8XnCEzurebNEUVykke0lb9imhrO7dyMzh1MfFeXX5pfAoWNF+N29qe1I8zwSDYehW +lXIZ7PSaAEtTWGAg9hmwJKQzpwbggCshYiCn2GHP4oxZNG1IXXPrcZqNr0GkOwBcPvl79c8tpgIk +8s/XseRP87YChsPjh38DoWuxQBgW6/l+dCpY+yFxgQWSGM7e/O2vXAGQkYip38NWYRx/Aw1rkC2W +Mx0W642uLujs2q/21W76i4V95pPjYXMfUTJ4FstpMiS4p0W8skU62FqfLMR979FSY81XY3Y5l8Z8 +CiwY3MHk1Lz/R/Y8hfyGNWKNW1VsrHa+Mw8zqPP+AB+jC9HUZ2V/JGIq4Cdyz5aSH8s8m7pMFlBx +s9F5VMHJXDSSdrBAuk9Cm4d6Cy03KUOXUOpA+4Gliedo2cjKy5h0VsnDa48BNt547ej4kxbZD6Kf +LFBN0uajjRPzvHjQ7rwv5txvYCEcOQoh3e7me3bzuocjUCxcAHXA6xDf5pHjHa8w6sS8qFkyCPuv +6zSJZqhmcjfGE/vK/ZdTMRCxvdiAqa8aSSJYQkXFPzr8ovLbnnGugLfVP8X6jy6I1FWLq/RnoxMc +/CCmYGcX/XMU0zRR5S7nOO8A3ikMfJ2A4kuB7NBOBAKUvu799wnoSuyoeTBbN5kDz4mKgOUAGnBC +Ar9ghJqbN6K0+QYHIzz3rYlOI1JRRpT5dZ6J9MF+ylJ1RUfszmEoPsnJNNdFBwyxByIa2KqFRJ7S +g0j3+4uaRlPqPlIMRfcR+Zu/npS20/raUy7AuKgPkxKgPmzJrorAlLyhn57wnEeQ36WNJPm7kjIU +vfZ+UngzhFn24rW/K3PVRbMZBXmAqMB0wWrQLqySL2FvtE7tgQippCzFhdz9ZgHLCb6IDTTGJeLe +NR8JPMITC4HXebynlYqKBKlNSeO+io0vM/DwFBBrX6+RUFFVlm3BUgbMglK0O2nf8KK267TngFnc +7RMfyebodvvkfmJ8Cix7H1ixwPNNUAA9+sxqjLbD0Np3bAriv5ORwwtu7Ob377NTSCWovDU0TXm4 +YlfMv4AHSp1cQPvh3O2NiXyJAWVNN1dWpXb8bC+aLStyBQOxcdLCgToktfkd/xrXAgXsgGcGJWmt +jZ9M7EyubD8/YVf7OB2czE12QVtHOSiUWIGgt9RfkD3DHnm/WYdnhByUKq8nRdREmTn8BpLSI5MS +7NaOcCIf9UzLCK1eUS1KxxirTbYtox55ewQxXz1lBKzsQ3WyyJyJPpS3ratthAU90KbeeqihFdWO +W4dOvqLJsX/VWhn9nbdtjpmNwjIDCe34y0ICAxZ5kwPZxVJzZPmiMu1GLpXUljdFAXwa+GtfTLZl +fajrCAvtK/UiKtR9fK75sT1WPwqVg18uehUjaISXVALS9WFz4TNwK33qANeMATLV9/huL4Q50HNc +XrA8OWn24azUc2IBl3CRewKQ2uDRajlCe99nwdXoiqCiy0y8n2WyTCCvNJaAvFbSQbT20yuqQzFi +yP+KDMy9ItRjbf12L0zTwApiGiUi/2LTCDlnv/ZwIeuKotWk/SywbwYIc+9kGiiUJJZMUDT+il+N +whcwewEhmZDKSzhCOIgS5Hprk2AicyYBNXPBW1yyHXdqSD1jpSSiECtiG4PfVs0QpvtuFNtOvlL6 +CDBu6hlftNPMvhQBXH7TsOQzMdJuItZ3hoDoEklZReK1+AKgQbCPpilAv4J9uKXnvkIzLYgRpvVL +Mls/byhFbeaTUQIBotUtTqGfZt29U0txx30F7DErYGqdkFeKrwWPvPOTaniRSFdI8Rz1WDTzrAP6 +aC+gFD/x59SNdWZcVWEphBcWekrs+cDNwLz7Wi7436JNO2aFI2bK3mVa8jO6Dbf16Nfe+qaA+i8c +N9zPPfuQH74nyMqy52YyAGl/M7Q/Vbf5FO2X/U62ax1iYFKusNSJEPSH6LE1nfyheoxSXrFIfW2L +/as6koSiXHInr0LVskeCYVK1ZCLp68jKT5UQXF3yXZgjhldb/419tdcXr7odkcI5oKf71JuLIpf4 +5AcpwDMtZsQ3I0dpQHiHLyZmvahyPAK9cQwqLiUVuut5yJ4AucfD5W1OjLZ10Dmz2U4KoqlnC3OQ +5SwzZqWXzUexADhWr719LYYqpuykdT+/z9mLU6GhmQokA5NhOl8IJjBfyRUL+ZjCpaztk2k/CGVB +fHyEenZlxr9yqYFs5ATkuaJ+YHOTTnZ7MoGopjldsmaqNibsiAOEKN21Sm5H0OBWfuj3on6nrOlk +jwm0oqCYtfitejgAe3K6VBan/wOGacAkbnm5qSrcYmRf/XaigOMQVZ2Or3ODmVVq1ATroCM/cOlL +hAhAWtF15kzNJRO4/siZDsZ+fm2IUBUU0KyH9UzQLaF4dnVlpR4gEsdS5jyD3WD1MGo2GuGXHbcG +gkQk37inteGcaUG3IMpSz573bIYLPoDIrq7XJcaGZ7RHq1GwIAV9OizClwU4XULMd8S7mQQYdmo5 +QREBsmQpnvHARShY9NGzIpBKNtgBoesTW+MIgcrLJca1HpRyWwj3hQs+glfaOdUBFulBCtS2oQya +xXqh9MCFogwP2BUA20N6htcHQhaCaGmgViGnj05lEjEAu+472F6Lj8tqCOJWqr+QpbFxIUsbU2CU +5mB6+7Y6cpRsJgEAAhTFfw09G6zhk5bcYfMB02xf/hI0B8Q5WiN1UyquTwI7oOfrxV1Dp6jZHzMz +WpFZK/pTEw33PoUbhKs8dI7Dg/D5gkUvtWkniKdulFVVbio4VSVBTcyFEqwc5wloCl+3XLvuPvzR +OM0IbLKR8enjPVM/6pJ4Co+caWcvVXw/ViFGsKLTV2W3Q4QKM4CVKJd4JrWqcEFLwHXROdoTVx1v ++aQEu9TZX6Jj0CDMVftAlCrUS7utqQMhjzNyCi2Aa/sTwaahUlvcCMkazG6pCbw28uU+oF+QhuVY +RN/ag0NlJhtSFFLMGrTk6d0W1coVdet4S4VT0mlFTOObodLXmYRjMRdL8pnW5SgiACX9Veydk6YC +kJbaARsNAGjPNmdo7FrkfCDfCMOZGeEAa++DlAbhJzUcWBnNaoRrDw9BSF6HybfCkUSsjAhmAIVb +nd/6UgoiRM8bZ/r9CvBovxDeygQBZfFROIWLxjR44Y0ZUVR3g6ibDLndz8u4XrdYOjiFPRZJFkkW +ktTvXUFGS8gtympM+WArRZGIJO7eXVf0jpNGi9dGDJJ2/ONb2s77BxvQLes8MJLu/H2mg+co1e7V +bPSDXRX30rGf590pR1R4gvmL2xF/BwUk7BwMXs+O1XQAzdvxJTj2xJGD7qQ+WDa2lx93Qwmt7e6x +PXKa2REQYo3IiVecZo2QOrdgSZWvEwin0ZWgxNjoOnKy9H061OWWv+Mvy6fBIRhAC6HLSchXBDlN +QPnS+gWBVMSw7lwfXhONg7ZEaCBrclCubBdZB0coS8EF8Xb42A2UCIbKhUIguIIvAwBwFjgbxK8R +t2CQeZQHYqddj9OtDCLE2Kq/JHAX8ObuX0EZ22q6SZG9yCxg74R/HT1tcbI9RFEdlGhP9tsnJbUw +OlUAvdhroCe9f5pLI6USm4tsfK0a7cfosJkTlCHZXDxhe3X7t/8mhBJ1aaGUqx6sZvRtlNAgZsPo +6U1SmZHjSIn3sYyo9R3uyQ7ma9IFwHdce8aDUYA5YE2gW5CKCALQVEUQqHjV3pJRNFY6plT0n1B7 +Qf/JO9lOf7vRcOS7sM/iXtMkf07VAHJBRUSpI7nEmnTdRyQX0cM7Lwxs/g58D2+o68oiwU20PPn0 +o6xKgT86xu6y0Aq7v8R4exyEQKKiF0E7GOdlNYV6Ci7ZKHcMZSI6ai1zrzQYNZgwuukb1EV4N34U +8oBBygZjBwnnoTSPvQ4KH7Ix9jXj29vrW/rQyoV43OuBt9QcQfF5SjYHFgv1Fb4/un+duoS9oeuy +N7TYV0N9XVbV9EBM7T+WyQcW+u/O9lcK0GyqXtlwCL65glwIeF7cgLyGA/awDwLZw4BxVHL2q4Yk +X9PuRBDOtV6/ckpt6sHPPhUm7GrTIcvYsTimDt8j9tR0BW3yOzoiEA1rbYQlJmJMjcwawwBYKodL +xCJpR+RwH/YY0lDaMqarHSMn7Ke1s9Fm4zl2wDHOKaUfVPgUcRkj8urgfspLWogFRXM81+05+TTP +X/8i/OjviXH67/5FV9F/5YH+hl1n/iv+95NxpgwaxBdh0OB8Q+XFZj1mWvtV/6cT5MQIgIJ69vcg +6THC0OGnqmQzLTA44Oq+B2bqOtkEQVF9t3Gag1xyDWPuWC0m7iwHFXveHjwNAd6O5p7BN9yM6NH8 ++VHX22bTgGtXg7AQff2gPvuy0BcWUCpmgq5oRrHuE4XqpMdpXVDNnknvADWmyIoy3Vh7CFm1cNZG +FBPRk6CAUL64rCW9BtAeVZnxO4shFTYd58jYLN7u61CP6KNw9Ycq38xPmtmrKsxqgMZMGGSeVRe1 +YuuRVxKl6IEiznu7l96vLHvpPaVDrtlHELC8877BEdgfP+I59qW8juoluZ9bRVYWiw== + + + A8UWO1B/HY5ZiVoyoXIJXvhu3QH5Wi7/fvchpsQCHovpi357PTTWSoUMmne/9EnSVUWn+2a9TQFY +n06KQVcJIGjpozOYAEJgG1nNqH6p93yc16FZtK+FKAm+zIc7URhU02SQTFm6vHcH1IsfmQyIUHMA +Jv2t4wyGFCrTi5D+OkEI64VSfE6QX7KfWJWIiWiwM2Hkx70+aI7hFjtfJYtljy9WP7MPYOwvqVv8 +UOGOVvhuy459JjVWaoiH9TnrDA1EVpDa5TBXDRGwtsauBcLJ9whPIGfiyYu35g9R1cIn5M696qxz +02Jv0iAirh8iWH4LuInO+nzO9Bk1XLTp+CppWMeFcdHcS6pSdnTZB8x+RWJJT3YK3bRqykB+AIUw +sIk3kjX3Hz5Vor0A6GOsGPSwE6V+jCmIac9+ZvloTPM003izWwahsO/BrhEG1gdBikw5oEawiyDC +GQiE0oA03GKxS4Sbsx0Bgt2IADZbhInfM1nb21FPPV9jFKD1bQoFq3SkKZo1eYNx/dgpn8dhQjGC +iq0nIOHVqfkFHLDkXjGrClAJ1DWfaqfc2Kx9x10JaOgPA/0AOOJqfl6C71HzUVMXyGkBRlVZ0JkM +sQBFc/pi/wxrGlvF/b6QPfWp1w0R7US8qBc4JM/nWMU586HJW3QyEVNIP42knaN/jv/0QH5EPfSu +eANx6YFzizcbfdidmCg3/uh06gOJBAMvzfDlfpYDfz3PObvE/dMuS7+uBOIC6YmQ2KNZDxdzpzV1 +iGhrqWOh9HgfzIBRe79F1BXMYztYKTpKPIBETB5RfENWaqbICDPAnp2B1GKo5r4vzNAX1+NmTYCz +i0SbCwem7FZZux/HpScRYgcxGGMapetzn4GmthHP1dm2QRwmkW5oHtwuJzapHtnSeXEG+08cgeqT +RTke9nuXQNMaHnNUAa4K6/0zIpWgQ35lJiw/HocNnkUppMsp6SGjat2bxjDkFoAdtzxfM4ckLBg/ +k7D0V3FP6J8k2vakibTTHdjAwGogNRFhb39nTDVltBm1YDKmQkb/txKv/2q2+a+0nj8sVqANFtu1 +GopNRdBOENjaSfYKuym4T9cD2sQ9QrYaXUSTQIqD6QDGNJJ3F3VHS9GfUwQtJUQb3HEzdDVDa7Ee +qpggZuQrdxRo/UjZTxXXZ9OJUw15nH2vJolQOXyS9YKKC/BFzqReqzCvnEn18h0hbuU9U+A0aHWh +YE7UFRy1IirkcnAAHQCHWdLLjt5rtAdxkjsR2DjsiNXPuimIBZwA7utISrGroHFM27YqFHzHsZTu +jMB4nBIklqIad5hg2oAic9v1mItIim5PMLjcKlJDoHiOVDnGA2IctZXZayRq6Goes/o5g7AC6nit +mR0b5Eftvlt+T6NX2WIzB6H0sir1CnG2bJrhFup5AEnkUgQjLi3XWWo5jL+ZJC9+MEhDFCPkZCj1 +3fUrxK7qHL/bLHdQ1lFX8Mx/0z7ewU0JW3CumOXudGsiB2GEJIACh/DFlh3btQW2zod7aKjJ0+rm +mjUIGRye+lsqbqUuQsTfei/++vd8F4H/s9sE/o9cDkCbqJ/VnQrtTMi3sAK5hge/nygsPokCQEbU +0GyH4/BusFFBOyYgoxaQkaYzQEoVzEV44wnoJ0Alp/rfkJ4CO2IiCFAPDEmMGGQGnK0A/ShVSTnl +KEdG06hiZRSVYbc7E3redY6Bdgdnur7apitIL+uz45G+qmxvWrK/CtQkNFl4+21iPKfvQzEX53ec +lcNnQygDwMH3iGyKxml+tqrQ3EcUe5wuIR5jY9ROwKlRIF/Sr6MPc2jr++9YWNM2sOpEVXa8Rc8R +vrgszBKmqnJe1CWfHpMXZ4Z+xImJcHXfEXgkGhExDATJWqQ8lN0jov/RGOaKqctNnVjBD6UdML2+ +cpxsp/Y9YeH2OFAQdsSiB2wEtERaIfQR/Lbs2NiCltcihL5Xmk1oLELZfUU9yHJm1wDkUsIGG8R9 +7fpB2u0JePS0vZQJkbWogX2NIPOinXX9XkVpsrOKUt8WRxdIVn90g0cYoJ86+o1J1kJVo/5xABx3 +V7ISqtU57hlcYTwpACdpBilFMUpFv17k44TpABoE6umanO7JfjPtaXyL+MfT01DnAT+Wev8QpeSB +oM0nCaL/DuAwjNubCem93O8gBCybApO95rmKeMGwTxopqIdtucqekqv5jHq2sInI9CBFmq2gsVpe +OTiitD/Zqa0CwXBvyLsRqAM3ZEQaYA2fZSO0jlgUIDT6OfAumblWwG8lGoi46tfbgLpbN2qKroUD +OozSlMbjCOTaEU09aiJmHhmxbB17vfnSRxFqBRV1uBfVNYMHj8xxxRXd8gy2dl3HxXm6fSuTu9cc +fWKuOWW9z4hDvrut177eQp9R10HvMEueiz8oTcNEW4qR9QOPUd0inlyqsw8m+vszIHPVMQMd+xaJ +c/w4DGAGK06DotS02UfV83MA5CxeFSBnXymsH6IASdE2WTFlU9wBmwDqUavnfbP/uSZGEFFIlCQy +DhEaPdEIdw0qwAeyuc8k9gYwuhiD53pvP0zCEvjFEJZAA+uHB4QS+yl6NY11tbav9prY/Txfvvf6 +X9yvrOn+MMVcQFdFSFXBICiaq1EqVcsNbE5NgW8/NV18NwxjF1YEZk+DFNCVhXQbbzMTzRIETJb0 +CDbVnGdSBFNEFo07FW7ijyJOFT+m/dR021X+eIwIAJa/kKWRphlgVsCxBF0iqOAI1MBdg7HCnxJ4 +FhEwnYjQ2A1whCC/kZfVExUld+uXHZPAJpp4AJuQSjIKMWO+Tpk5k6W0yerRQpa2/XUDQAPG6DG4 +IG6zphHQiIgYZb2mBDcgJY5zYRgcOT2aNgvZb1OXeRDKg5LvDIK6RCQRaMGvv50k/T23R/0V5dj7 +dgF4cK74ORKOkX+7XcKOtoMc1/0Hntw7gg22kyt3YxzfbP7cfG6Z6I4ZE8BNdbjM0UsGYbe5Q18R +7FPgHfUHNgFDw4EVAaaaTyDy+B5O1wcx3hwWmEC7XzS4mO/BezcsVBzUN8YLqESs9UVvYvGPBvdN +YhFyP79YvZ+dbj1Fpb1XJeOKfsq+ViTUMkWe2HjTOi+mmDvRQ5YOG/uXyH+D6HQNhyP1hPHYxVXY +ZMXYOLMiyFbeEQd9wSn+X7KW70xiMxBB5pV+BoR83TN1/z3QXiAdg3IF45tDvlB4WfzUOBh/sjZW +Vko7fDkFyxlIK3zP5idBws5L8xAZSR2iwt74qu4BL7ibENjnZPOkCOA7ME8CYDZzCk8OigkGMiNU +n+WooQA9ml4LFBNQiBFEcv5pp0xK+1cE+KxbRA40KjoFFy4lyDWUKgQNqkXVPkCeulQWXSDTsglq +FEwItMwnnYVWj44PZae90lP4LAdo86cBvtGXO9L3wXkdxe6O1pDIZ6CFZ2AeO5jDDz9/YtUJRJ8f +8sjGDKWAzI67ggQKYjl3RGf624th4ClfghS3JRgG6Wk4SCsHQEHcgVDbfFWyi7LWbHR/iLhrGib7 +7v7RzefPQUqeryN5jm7D/QqNYzWMEVLRk4D8QAXYb38/t3Ytp+k/j+nQ3ALIAb2CLtDOqMMgZklc +89B0WM5/k2jtpyiYrNo3VQl8odp5znEwVWWNdKY6QH/Bv4sdwOLxbK8QY5f8hYB6C7IFwArfzVab +A1I+gilhII8Mh/N1VtNvfbV7Z8tbQ+HrnuEUi0vAbWM97IVCGX9dG/404F2mY34AT6L0GCTfe1jv +mYCQXriQ2d03EK3R3wNPoJuiJI4dzdegovhtRBR/SHBbmTLGWbIAm+33h3KD7PHvA/5G1PDbD59C +Bf/sFHSTZqahSvr1d/apwEqveXbR78i0WwHWH+695+9HmjoI0r20okH4QO7s9XPgfXarbb2GOsIP +H6eypRQgYgXxmVKgZs/lYLg/xkmmAyZBJfZ3dewJ627H9OjUR1Bm785vtmZAKSM7ZJ6gXityaGiG +0hXm5quG8THgNVkAQH4YjPrZc9bVfmVd3bv52YIKAAym4PnerrBHyPzTok0gUmx/XcqbIXrRbWPn +0QvPmDr1gCQieT4ief7uhmxTlHyqmZVDjFl+ikZfxHjMPDseofxdojh/j2NHB5+dgy1q2yN6wF45 +gJBNRZYOBoxNurkL4E1mz3HnkctAzUA/e+9xfAA/BqnAmgxAB1XI+LYY/nsAXxgAfHrLnfLn70EE +R5FpENwxhHiytF87KSQxQa0LMVHQqqj5azp0Gl984Uh3tWOVQs8RoMYdlQcGRtfJpGKR4cBDclgU +CWDagy9/v4dTcoVBio9oNlUPcye3UMyJDvXCRJmKyv3+inY2lbTNTjl0QMfXjaUgDMQNwCWKBY1c +qyvdhK3trY283NgzUNkGgm6/oUXncL8H7wDR2LRQGrVbsj/9ocQ/KPw+P0j0v4+HeaSDKtvtwZ1l +wUwmL+NLuK+YQGN2TrDY0N/j6IR5eZaslL9mjpFd781WRQ2abdw7YpIC+9bC0TLPIPXIF/g+8I9v +4wHyDzuYR7Hab1Gw/cIrxDFNUfQV/jLiDRU75Y+In6btz6gJVqHKUe8YoZV65MyF5IYyNwFTMgnC +4dYWpcQWRZB7PzxId8Oz/MEZtB1n0EfqDiq78IBv+xKt6kOx79rSY6yjqFVloFwD6ggcH3bAc8Ut +8q7sr9/953WMR7E4NRUi50Sj62GrHJdsE+TvA//lbI+zoQ9i74eP6xmNz8XS9TQygyafO3+ScgPY +CsG3vVVXSk06ZOfZoh76GiO0+BQaVN4gNqcWTe9zGBE39DLWiViJGP090ToRJHFGAEYmojxfFgx6 +PSP1IXD6jkRJSqvhW9CNI6BpdXi/loqLXDEBFpMm2NIcQhEwuJxf5M3IWMuTg2y6/y3uDqlZryT+ +IhK+S3CaFD00aoBHn1qRxG+Pdr86obDo7+N5iOag1oYthUzZsnLEpRCc2tyNN2ZMxGlNUNEQ+D9f +DhZFpz9UJKNHDaF3Rl+fphpR8Pw9DiVBqSjaEnicJ1af1Y7lc/AnT4RBiRh/OIGZE1xKS5ETaxTN +9fYULfbohwitSiDT01PyBKxvnOD1GhALhjjEW6zCbrYDYrhmkKdypDXGWL5nzG9Dk3ZpfGPPxfLj +2cWed/Nu59neVyjiZXB8oFOIjqhSXaybIhb7Kq21akpJR6P/FAEdmeft1tH8q3YXvWeiwF3XU1oD +ZtwOOSfAuHHLyMTNNZgszEZ6aMdmYBRnsBECJBtHQfvoh0k170OD6vmiD+BhmmPzCO9DtdHmgmyD +hRu6o/j3CVUJ8B7wekV8upg37EIRTzgk0552xwADf8WcuF5AR/Zs6Xs6e8wGsYoBWUVEEeN07T0l +N4Wkqp2PCtLi1pwCAYPqKiAtXrQg5msgkrG/Rln5uJUuVbfXNCKiVAhU8wpzDB4y5cmBle2IyE3B +8rpe0dwRqiig41u1n+t4Gt+WaoXrdiT+Bav3ABdIw4AVT4zooXfKW8ZWyeIu7TeaLw== + + + D0CPl3xgsxie/1417vFGDaNYawYqFnCldkY8a6yOfdMRhnwkibbgDSZiQfDI+CY8tQ9go/L7PK4C +dNWkz6FqT2+TE6gDsE/Qan4IojJElBx+aEO3v6DsiOsF/C0I/L+dRMTlI6fdJOE9UbVA06qvyCJr +9KIHDp27OETQ4iIxdjzAaKZXChLROtp/oy32ygx/PwrkO2SYaAy1c4NdFDv1F6m4MQzfWyate/L3 +QJDb0VhopFX96zMonQhgpi67xqGb1nCSFUn/iGglmRvf7VVE/IzCX0EYJEIozPztTjcNXAjypGDG +I6HS9VCJpRE9aiyNlAE0Yibiy/kU51qfkr11UAfy4zijhWvDUyIzrxxxl73BB7n1GfBnN9mvh+iP +MUr/W1sBSJbuK/MSPQGIICGZsdcDISZf+WDguOTC9avOar/vh1a0DbBBdzAi5FiieDXai05HMzoR +yuaAZzvErBdvx99MYRBpmvMMchP34dCg8VOYJ/gldG4v9B1S4Re44Av8RJtKKeIdsXPU8vV9XWkm +2rbLH+vGF4jLkpVMe9LbAqojFqxM7JDyEBuy2ZCSeiF57p8Rue4nU/v4+LxCi6fYvqSd9ZS1kFcB +I/IZ4X0dua9v//4jqKD0edklYwd5vmfP95xHGk0nUPwhNECfcQ3+v5l70yc7jmtP7LsjQHTffau6 +VXffb61Zlb3vDTQaC7GQICUKgkhIgkSQehT1FHreYiL8/Gm+2I7wFzvC/+r8TmaerIvuBjUTdsw4 +1AKB01lZWZknz75QiIWNCwhTU5eFGGckbo/SASCqGwSVjtX4oEMuEp1RRM1WdNIqKWOJ6hpMGSMm +lCU38SMUjRBq82Su2qtSGFFuQkJU/9CYNAdx20Z5e0SU6jYEFHVto7HVKLJR0CiSjwIKCpXKMaxK +wahKK7qko2o9pCJiVAUnwmCSb0iGUCpMqDqVqxg/U64JvD3mnrKm7xUJGnmo6+/pZvRSlx2hEVmo +54nSUBfio/hU9QsK7cUvdBmwTBcRVrXTkmJ+xUSFyhZWec8kLEo6WsUPAt2mQlANr1jX5aP4YBqR +Ul1TGkEdAGhErGpgUiFA8sBRr4AgLy6zUOoNVdRSjDZS2eOEMcSJVISMikmlqm5kS+VfZKHqzqdJ +qIGR2i8p+JsIjbqhqVGCYtUz3ItVqXSqeRBmuvcpPaLSnqlCNIk1N0do1JemmQU1hqF6kbfmoXhx +EtyJ3+Qq8Es1Tr/jF2RPU+JIHkWF5/TGmBs1VENVbJakL+pkIHS0sQmMFVRKVol35NsjdCAv9q0B +lkSoVsTYFaqmcnsaqv+iit5Qy7pAh9DqGKhcR6NQZIyqQg1JieJNzK5TCT8VScxlcIhvCzWKvPl6 +FJVPpSZuwkTYqJitVBWdVr9QHZTUC5SoEoSqPx+NIIWXRtj6QDSIIgBU8d1QDyILi1T5qIFep851 +CkKhiqepdnuJipQja5AaoeJBtZqjl0ImcJpD2t7XpLirN1ESpzpZuTLd1SgKm/qlkL5PxV8pJvf2 +L7LQfLmw4e96kOpSiEFU15JM2vQUZYSomCrlStItKhJVeS8AMwuM41oVGaUelrG4PUKjlKkEd+tx +iv6gaBlwRkmGC4o+1hX81HWOVc6vLkoQkWObisbqcPlI53xq1YdOk/LQIopC1MH5OgQb4pVQelpg +euEQa5Q6OF9nKiQkKOYqakEZQFJqCZTqwHwVREO5PbnpqUrzKPEopethiv2p0hRS9S9QQQ9RHOh2 +H9SdlarURZRzpnKLKWGfMkMzYQZkegAO3gYh6dCWTJVIvGOa0NRpoaBhUvB1+GGuwgIzcpXcMYKT +5qgKaMBhwzdHUWKAULWMVWKOSttUSanUqojC1zPdjk8qw4jKv8UXSb1TkUoxIVqbcSRJRJ4cCsui +Kvu6nrMOk6RIbh0dpHpXJ6opoClOqAI2yfUp9PxUJVaNIJuUypXQWS6UOBPaF+kmMuTSF6Ynogog +hTZE4ThqKbGpKC1UFg3VNE5vp3urPBuqdheoljP8AtLHVEgcrmSg6zfrGtyqHWWm83e1RUYFBOh6 +1wrPyYoRiLtGUEVaVSAamB7zm26OIuxSoygRSHW0MTGsZLLIVW3J2FTWjqm2VqYiivQI0g6T9PYI +bXDItZRH2eFU4+jWKAoK05UzyLhMGUC5ar1Nd4ragWWqv4/JflMtbdS+6BNOqNMMJ91nJg5Hx3Tp +UVFuRkFKvzbrkbrBZ0aqWKzcfBHlCQllviRTj8LBQLkiKMUhM4YiBacSTWSSDIBridiwD9EvE8qg +x0OhqguRq4oFOtw9oTKYWLmqlxgp/qviI0lcUxH3tgBcovOLYm0qValwxNxTFb8d6iwvSF7UnMeM +kHoE8bFbHFTNeWsU9ZJRUjIlTqjidIlupyNUH7FIxzTrpt/UNIDqQ0ojrQPbRJiZitapqWjNTWID +U3aHmgvlKno6VyEuitGB1qlyybnudZSrUrpUVRjCL9npVOEuVe5Z1c8UqvqFcaGrHmCJ9nNRroVQ +UgSV7Sbxl/rXU7AcpbjSLJSsSy0kKU4oIY+OyqKhulHYktxUW1JhoYmqa0yuIEpylaoA1M1fmPgL +bSG48Tt1noEuw0tFBsmOr4xi9hcq4VfFhFAEmj4R+8tUMc2MqhJRnQhovLlKv6RSYar+GjW6VlFa +VNZNx1zihFQaQ06mtlMdXpNGpot3otpEUQXwVFUG1BUGcXJUtfaTcTj/Xwb7qMzbT2bf/hdOFlCX +2HQzoVb95TtyyXiTqff6y0+/LPTWJz/++L03OX747O3PP7/76Yc3D//65vHb9z+8Of3xL/948+Pv +35x/9/7ny59+/Ntf9EvvfuL5u7+8e/vzu+/e4BUfLU7+0xUE3vr5u7cfTUiv/PGnN2fvP7x59u6n +b9/98PObR+/+oedNvPXDH36+YzT95+3vvn+nF37947fFM2SgNL1TdUTep9748j2e//L9dz//UT+Y +fuplz35696/v3/0d7/r+r5/cl43PwJrev/vrxoo+Ofr63e9/foPtv/jpxx9+/meDX/74l5tjoQf9 +4tc9ePf+D3/8+T/z857/+Pe/3nmc5/eGxw/jN+c/fGeepH+n9O83T3784RmQ9mfg7XKpwSfv/oBV +bvzi3pO/0G9y/ZuTn/721z/yPJNXP/zw9sO77zwxvRd4x/j/67/fU1nlfyv+c3bvoxTywLvCX/4E +0N+9xHvs/eqbwPuOnnx+b5mo4jye+c8HACjJJdR6uoJdfwwLlAU4UmB+9i6YefaHYlVP75FeC4GU +Yn0p8h8KSkA9NKkzJfVjCkjND1RvNMqoFSQmg9BTxT3qmCpJwiOfP9YSqzKkgXLk5PQQ5UyLnGwe +KWUAmaZDPCBWmfX6O8jYRKEGQVZ8rqqzFOnAvszTQJ27QAKVCk36eBPATXQVVA1OVG0rNZZqwJkJ +pAoMI3JP2SG33n567/fqcdW0QcEpLjGPzLIAVgWraDhtjzkIMtBJoUcnlDx1ffck12b2dKV2yPwi +SMzsFP4UhBqsFH4NJJuVBgbQTjz9wjwOzMwqkuvUrIOiBM06SP7j5YFRSL1q5T2/Nq8LLJgMOOZ1 +mWoboOoUUQX0O9fL26SqLZvNp/Iq5kNIjIsNmDxyngaq7ApzImlmgNAoUjOBVClDBpzq76OgbmAK +A3MGJsA5A6Q2gBoYxfb5UPknNBRfbIAykgwU/PyNLyg+7eOJP5iTy5VBXQ/nDyu+loJzf3FdH0MZ +IaipRGbgyvfC+5ir2DQCQ16LzMGpPjbmHpCQ5ukpIqrQroFxbGChSjwlWERNyE7N2yjV0wzlM6Ya +kLxlpPd4d67r1C44JXlS3yQSbT4YcEwomuj8npwXTOa2xNwyqlxm5k4obFYDA3Oct+YtjkM1SlEr +kVTs4p+8kDyBfNFjnjuiJEsFTCnrxXxhFpsbrZJQeIug2xn6Q0XXeSzFnpnPsAh0Y2HFijP7OorQ +tWdqZDZF2QK+BqqptH4dhc6YkZKXlubpxt1Q+cAEpgp6jNtZaFCCymx5d67g1NKfUPIlJyeSpT+k +dhGYgsayzNKJLMl5NNlcGZynkaFW5DYzlAJMJtJAYXbo1tt4GXLjQqpuHh8MOAoZTBWDPA0M8tRs +cx6aGy0pLd7gFXW4MDuUm8BVNTa29A56QCIMhmekiJk1kAFS30jKp7xzYcWKb7yQV5zoZh50plTh +9ZpHq1xoi8wGmPAUqofCJz7E3rOU954qGVskkmbVhMqZtGivwsQ0nQ5iC70xh6E6UaCvgaYDhGof +DFiHcKqsISY6VFomCM2mpllcgG/MwZOrhgFmPIh1aCanUgR8XcjH6WmgasenhBbVV8lMkOfxhiRz +aibIDGOPddcIDaSoI7Nkg/5RRF4xpojUYZQnkFHOKyBd2swaipApJbb2zk8wpxJFG79QSPPBgGNV +bVYjbibNKqJYGqAqUvULS4tMC0BN2DP+DDIwmgkys2O3VnBqzzQIc0Yv6jfOZxqovjCbxJaAUrN1 +kjy0aBGRjMSvUzWlT80Eqp+HmTeQ9vjDsKC/+k7RvCILGZjG3p0LK1as8kGMCJYUWPiJF1J4jgGT +4KeBuFJMxKkllQFS2IYGqmweHiolDw14KHWhuTXpjXUVRIApPq1MRpYIkDtpgxWZrw5YYFRf/Ymt +4LGJWYXCGTsrryK1ROvGCnhpFBQpzMz0cR8MVOWbakGPMhkNjTPfLLRYrUdmAZMKqlBvCSqFrpix +mZGbKeyUpVtKxvfuWsC3ds8o2NDA4zgpCGfMK4NgFVrCydhNzRVy3gloEeY80zRmSk2hMoYZxikL +wrded12cnUwMX1eVzj98arwZrRpEqQRgacX9W5MUNE+1DddkPM6EpXnSAFV1RUMAYsZuPmt103NW +eoS0RIGFuJScdEzvVJNNnQOdMxEUOa82lllq6R05j3lWzYUiqjfOV1RJ4Hcuv7iiUlqETUVsvyuw +JxIKJqRBFN+8XwDGvGFhHmR2ZZD1WBRiohtsbC6VNvXuXACvTNXR5yko3uEDgwO+IJERyaPkI+0v +zxmYR+YbyHRmlkbg2yMzXgNVRbXANGTObx++sagCP0TKdEpFn/M+6qYJGrMlbyTVSDFjifkYoP0u +SoSwG5lECQsa1NfEHHHKuxvLf4IiVCiE38XML7OUi5yHd66/YIjSCkxK4mKGaDqgqfApc8AUfsLf +EAQRM7nMyHyka7K+RGDJUp/UV54mFbFh1RnViLtzAad2ywPVpEFNTMqxRV0rRAepVkYJSH0qNTDJ +LO6KJGNgXGwZxWiYlZGqzUArhcviRny8gn+6tNDqAqGVhaI4S/lSyPSXkSEKEuYYucWmMORPY3vK +L1zL1IJJ2+e9SfiuB0n6y59G1Ub1BaKWLTK21zI3OmZGJRdic4WokrUGRonWI1Tzu4hHZiHTQsq6 +CM1Y2hANo2hyw4eyKP4n19qSgJRJ1iZQkKdKA4Xg6yepChlPkBp9U1gVMFLhXrkGJg== + + + IU8apolZFdUDts+LRBgLDcWimrHAQGM+Ur3+NDAzchjVBEyKL0hlzBOEZgKqABcbxS1MtLkkMiYu +BcxFXhCnG2dwzWDqp6nA9laluludAlKjUe/Os+VDJzMTo4iyJXwwYF0ZVuu2qeGtkaoGZNmSeSHV +IQ2smGpuIKUcBUZMJYdwcZYGz+myhRGfZcosLIxzC7xNpClpyJJHipW+vvsjri2JU15o8xlxaklc +nvL4TBhtglLMWH5hgUuRKGGxJClk/lSFbiqDm7GVURPZPDKKXEBRxBpIRRBZ7Mgi+yGhlRpkoR9E +ActhbACjT4ik/bYoL1aQZ9bmIllA4VupkmN51rsFFEpcuMHGKTjA0os0ZLXnU1TeLjbI+WNZ3SSY +5A8Q0g6UsthCIe201m7xETgMAmGnsKpCEN4FTNJiXhFZQmgXJlJLnmUg7XllVj6RWTGBZbehIRb0 +rk21hD/Wvoj6Nxb7wrNaUSjauCIU0e7dRs6w2BjV8NpQ/cjurO5Xqo5LRv9kBQaWZMXyC1NelvyT +/SvGUswSA9P4jlO542A/SToi+wWxZBocZExOFG7feWc37DhGrqCCa2mhBjBTz1ZsoSaYYFgkYgvU +FyFTK2CtIzQ8I6PaYlbPypk2U2Ez7873FwuLzU5S24dE2oXFhsOQvTLhmVlTz6wgFXLKugImfEfJ +9mUMRqpwm/2KiGn+hm5596dRQIkZarAuVO03zKRBntpPy5kZUoH6Ym9iay2kQ7GanpFcVfp1aKYo +NMsokWwALKyQFKVp5xVGGiT/Qs4TUKq0WUNqLYg3tnZTDmOeToIyi2EUDGuYMllMrg04Nu4mw8At +WGZmNHU2s2Aqd2sWYrxQUbiheadCWPnqo0VsKDg5a38U13RLwSGBQGSWixfESamV13dPwkxNXXZr +g2f/DYFj9iVQdR0zjcoxMoyYCg5Z8I1JzOyCshcVDae6VyHb7IU0yb8EpsBxPQ1VQEhTA1alLwxQ ++wMImGqB7fa8ZrOox5zGcvpFwjxat55Tn0+9C3NhXphbAUJqw7cBRrw4drfdnte8kPIUEmveSdng +osrSs4OGird4GlioKJG+QQQT1oxHfYBPzfN5HlmGKMwOqWktTwwkT5sKq06R7HPnusyCU9Xl1tAM +SrrWC05VWwJDuZStVQNTydQwp9q9BpixYJ6z6YqgxhJA0mPCQxMjt1GotpAGGMuCxOb2+SSLzLKo +VhK/ytitadUhT3rjA4ovY5cocCZmZKNyksYxIikkJ9dbSV3DjHhCAUCaQlAEb64NcNLS79vzmhdm +VFeWMSWxHikqM6AtYAArAf3agGMRWbD6FsBSbfALA+38vHNa876Y8kSsNGBNHdTwN2ZPOdX98TRQ +BGzQVC1/NBCEn4EBqyQ0gbTSseEC9DJr7GD58fYKinvHjqN0w5FDMWtWdU6MhK4SaEMzljJ1GWjX +q1SwU57XmlSFESB0OBdbS7RgeXsBvGnJhpMxCFJzQWMqimQV10TfJALGbAQMspCBkQysuMLKByU5 +RSwzM5mI4w3LhHIF/uKuSyNbJjqt3sxq5EVFQYR35yfob6M4TdATQwZD6hPygcFJbumo8mgpYKbC +2QiYK4OhAmqplYDCOBgVWBMqRZ/tUMFDjdh3xwJ4ZdJ6kMicatR/dQMzdu5mPLMkM3vIQHWeqnFO +LI3gSpUlzcqkvbVWU9fdeayqox1qd6zAGKJ1d3jmYezAi6iaGvuPlIvSDDUQsvHe9fDpnVMyc83I +xGAkIVWu+wODjV2OSIXRQIissoU9Y/sMkc2YHaeFEYPCrDnaJGPbsaKbRmOkrHDvzhWYXYjJYi8M +aVb7+4HBWRhvgBnIsqpFysIJbYCnPEFsJzC2JwWUPDYzBObWCk7tARWCfBhaK0K+oeWalUXUj8qS +Prbm5Nb1bzzhfEiRNWoFRh3N7XXbnPPG64t1hTZQhHqh2HUF5jTJxGkxJwgyJgSsoVAHWRYKZBpG +9jRlwkSDsgXsWJYLqA6Ud+cKiqWlNjBGJhxORBUyCnIUx7w9ccZhHqr17C/uWazyy/RYu0EccUGz +huKXL0Zmh1KKilmVDV4BIefnb3yBQdQ8t+5iQ+I/GHBsgijIqa9Vn1zliEoDNN9LwChnYGi0EWpv +ZWwxRhMzQGNFkxo571wAi36qdr2RC4T1iShwkDJYIxoBDbJLylIWDEwlT6Abv/HYLGRwYCcwoVoA +am8NwUx0B8HYh3x7XYYcUaSzsfBRNLs0wjF17TE6NjnjJM/N6iIJ4Kn85RfKXOMq9X2URrO7/Tpa +h4o7nP1NSURUpS1nlkLi3QcDNvonwCkRk2sDpp4NnophDA19y8ikFhpOxUZ4mldLmCra8fTudxGQ +YrFTE1IZCy2REzDImHsGHDKVqZYGZlXKqH5twFnAHDDKNMoQUCfyhqoeGwOpo4sBJmx7U0XKIsOX +pdSCt+rCEJiN5oVBRGJjEClKiSEfShdKBR93zjIWWwaoPJb29t+lNRnRyWI9VdqxylGBspmOUhIU +xa7lOXKMRlb00pnrBOSrTxqT0SCp2vKGyvUJTSyIcovz2sdJBRpMMCNVQddOLZFpPqbZvv2GzFoR +NjaMYuEzfj7UUXL0fM4jqe25nYCD56R2eVwbsMoGNddAkxn1Mj4dxZX5ZamZlzpJ2Hlj7VcmrE0k +TxCbyAapozQJSGUZA4PKykGjJyAbCuMd4e21gRonAE2ba8OiEKbIn0IlwmECUmfXyFwGqu1oplWl +baWZIBa8hCxhdYQKJdtZQz5IKsfK6wrDKGRUCBPzMsUBNVAGvAI2olIrNpHbFRivNL2M2ltrYCwZ +SD0RDNB4npQJIC4+QWk7hfKktybZ+Ig00HI1Ac0uBNoap4GpSM1qc4sJiY0HJKMAP26cUXQIqWYs +whxKnrG1lTJLteOODiDTEZSCCluo+Wj1mdlpyhIOEn6JKCYwhhQV6WwuHSX9hQaNWZYQkY1aI2Jg +7wH1XArN9VIMQ49VYYbmqLRWSxNoWYJ2JA6knUAX6TMknvEttAZ6qe+fAZpALGllPQImrEIXTieq +epPxWGGiAmhsxJjBTk1RxIdJ7ZjlCYCRqWEyqcEMuhK84Rz1peqZ8vWMdNqlBjMtSIR2UaTShtHS +ojS+EzBgoLRut5TCBJlwKRzVQGpqY04h0VIa5QWb91PLYjbAftoOkZq4LMXiEzMFx0/lbCm6y+6h +wZmVw1NjEiKThWQXH1NOMm4YwYRiWxnfyR5j0ItizoWx6VHRNONlIDNnyFNQGW89Bbs+PmnQiY1W +R2G+Ka+LY7cyjmShOTM2LMfEXfh5aNXWIBSaoaykZdola+Y0GgclO2eiMChZJyUzfAIaRy8J6II3 +9m6DFjMPmlbTaLWvkTkXyqpjoKXmSmrkCfLQSqgy4gmyODCzykjyFwij2aiyfMUXCGNopgn4XdQ2 +nsXWmHeQDdXEu1QPUQMWIuXbZU1yqSaaqjUtP58Y3xVJyFIWJ2jkfHPnLWJIFi9V7LgGiw3Zmdp5 +GnBqndhyFRjrvC5NZbZGFbAgYMLcS1kQM0MSATYmMjoHHhmHfOKpYRIEjFg0UaTTPm6czLkN+aZm +49b2p2QADRRGuaLvEryLqXW8qBhfM9RwKcXRdHwEgIngfclDFgBoAQlPq3yj1wzO2KiYmZgw+oaU +15UaSx412wwZmAcisvNG9sOUUEZAcpdJswlK/NLAILUjOUgkja1nX2p/nwaqUu96AWHIk6Ym90Ol +KGbFBBlb6zmKlootmNBao25rIMf45QWfpWLZlvBRdrIZKgIG5mnIk4qEv0qFqvEEscm5yYstDKlL +Js8qzNGE+gWG9HKOCfVCDRNmP4KjpVUqLktysdHHqUSSYEFQURkN5Ggo6pZsNoagiTB7QEnk/HzK +WmFi9FVVd8neMG1qWCp9KskEm4KoTd21Aac2Ikb1ydPAMGElK4o0lfm0YsnWJGnNRgmpbCmjl5Gc +k8yG4EmV5MLPF5iYSH5/ZCkq2+1pYMQnwww0ybRtTq9Ual6ZEJEUG8q5hkXG9EEv5xDUJLMhoYXQ +TGMTq3oaRpeobmYG3wpNKyEfKY9VJdfN2JilvSTTSEQj40zwPbQTCJ0Ioj+L7vq1AadGNsqtaENj +hSUbkRaPE2FzSswB8LyRsThJtmcnqqsyn1Wqo+8ATALW1EVidya1XiGpRXx2FsnAXubCLyRDZss5 +bxiRGMlAwRJTQoHwqeF2xo5MQKr5yseoCWpCAToR+01idvkmsQ00yAm3EjM2jBMjbwhtskuIQkQc +ihxxhA4VXZc2GFl7LQlMrUc1UMnA12Zs4VAPjChGdbNiS/qEFvCoaZ6lyCkJ5LzYyN5QFUCogYlg +uZc6yPKsIVN6aUOOk4iT91iBM7Na9T4xVI4KaGnxjICEHDxBnIYGXMjeBJbZDfE9CXUEtAFqdz4B +TWgYIQKziiTijD4lJcd2WtUKxzA27VqhXcyYtXKYAfX/jCOWsKxqm5BCy2Td2AZ1xThGBKMAEjBl +2VsV+OXnY2HtTkzPAoooYCk5M4augEq/RLfQK7QXelPkwGhzdZSvViuASWBdO8Rt9IfFdND24iUs +ucXSRv5RGIHW2WPJBs4wsNsVWzOLsqiwSSYmvGK6zgGNNGvERvs840nZFEp1xaxvSdpMvCIFM85t +mFimbewaGKfstk1skGKc6+AqfXMNH49Jv+DrzGYLmtVuQSw4qILAEauB6pKZl5nkIrKE6sMlYMGx +s6yYQAVHap4dJ3ZsxnJTYpA2Vg2TGGkFe8AJbMJYcuskiUnryJkDRZrUxoqQmWWpCBKeILETKMZp +gIGVqSNNEKh9ZFrIJxwTHWdsXwhyjgWi9ispx0Ny2H1cpN5lOpGCXSGhDTfhXJ5YWD9nxumjd3lC +CKzKm5rnMyNyxOSLEuarApNzFyfWNZKrC84eyuIuRwbjKbzSfJGhJLEqB8NilNUrldeS5W5FjDRQ +iJzZLXt3YovEdL6xfZ5TA3Kb0UU+TxOORhzUrkmETLWUYZcnSE08TG5NGXEhteY2gzcuggpzLbDp +CSJrC8m0Rd0s1mS+FmpdHFtSmGuTkd2CLDaHbVIZyQMeWtnMBHbEkY7P1/dVsjmIGlennKPNSUXU +3UMyq5Ox/YKgCFcKLSFSNm0eK3TkGJXcjAIOaUu0KYY6Edp0QGUH1/4X0hhsOnhuvNzBhhbN2lcc +2FRwuiIysitgTyPFCtuX5TETncBkudGyRMb8N5fFJ2Q2o1SFYV/zlxntPKMo3NRMwcJcZi3ZcWiN +rZm2wPLehgG/jtNdIxUrZCZIjVMnytlvEKj65dYzRTWQWeQJ2DOlNEe9gMxE4uY2NWzDvEGzBixu +qNbF1wbMCfxEPST7tgLrxd1ww7FSJFRpKZ420EEiKuZbsGeXkyNVMDED2WujstrZY0dHGhvfMnUz +NOvKbKC/sPcmyqzor2zPiQGq3G8zUhXJ0eBI8gSxcShEgp0fRbQk9a83ViZBFYM4wg== + + + V5BMJVjCkxw1R42XOW9FGjEZwMCGokY02VLFmBkHDgV4CHbLRKku+ZAoP2lq8qDSjQ1Th6OB0rA/ +UzuCJ2DjSWo93rS5NjYjyzXpVV/LOTKZzaWnrU3YR5pL683fSD/nxMrM5i6oJuChnSALOcU+59yd +bCMKnUqJGeCnHMi5jQoLA0ZbRoS0SIilG8CZaCoNv8C6kCOSIztU2HxRQ//v8o3zWA7HVSUBP0bl +VBuYDbDILIk52V7Na1OijTFCAW2yvZFF1RcIniBhUZC2wOYlqdBODcwzjhiIk5DvTZ5woFGSbtCD +IinbZlXkVOyN62ME1n2dFynWNq1D6lhyBbWZQ7llIKlWu8zzkrPxVMwzT8A570Kbva8ZnHDwkKpO +Ych6xLl7Nl5fbiS8BFaYVT1TI0aOSCSWAHO+eaKzUzQwKeprGPoXBxbtCT2tfAYKHnMYQWayN4iC +53ZhRuGLVWCrDVq03DXcyJtQT10zWHDEtzr1a8PMheV6qkqDYeYR30g+tE/Ha6U2/zmKtD2bpKmA +70OcapMGyV2xTbiNLcehJJGA96HgZKk1yyfay60lujjg+gOcukcVeE1IJpEqNrNSm3QT60w12nUg +IgnwNuVbxCHL3ywoJVp8ZlFb2XgMVYiN2hiT3F3EpViNh63iFPCSM1CVcDP0lu1rpB1lnNmtMg5Y +veJUqzxnnY3zr5SBQhqlz8T4EpBkTdbZWEVNrb+cFER7jnEUsjIbB4zPRfpTQn4rDinZUFs5TJC6 +mmoaTNYHmxOZRBw8RbYK+7UclKoayHElnDS28bqhZU5JyCkRieq2zV8W6qwIAsYcxKbkp+VHdpW0 +iKRXQznzl4Vo9S5mWbGJPyOgzapQI61dJivSWCNeANtl0sIQeEcUsBkrbEIyG5cSGzKQWqWTgLFd +gZVsaQKbJ0l9JMzY1N7zhA0ClLBl8+1sPvmn45tzyUjD7o2kSDdLtRvWAG3Qq0oiYVMYG5cI6SO2 +pRVBg7EJY05UnJNgMmy3hsbaPPDMPF6EF3KRhITiXzkJB9y3MMUlEWejc049gKygUjZDzIZH1mTS +jWSwRGgVSL8s1PJMktnqS0U2PIChTU9IRV5YOYtaKyaTN8lsTpywvjgaaIQkoVVZfj7OOI9BFSLW +QBHkRakAtpKy7ZYom7Veq/4vvF0sGJNN24qrEDpjC84i/ogo1/lJVPI8FVzwSmjRhYzXKTPoVLKp +JZFW0BI2UZsimmzWvjX7SRtBJTaK6RA4EVZJY8FU1ftkMZa/mPpNRrwNmZEyVHlztuEkAQdYpDa2 +iPArTdm9Ic19pM2N2cET2XBmYXOn0tiWeBAGE9PE1p6yaXLp5k0qIvfSxNrACWXUyFQHeugdNCmF +aWIdNkRL7MtTq3ybykMayCdrenAtld+vCKRWFP+U3YFJkZCuL22qyrZy+DjvH1m++FVKCuQJYiun +sfiYkqmdpaHYOP6Edd8aifBb87ywGSwyj3ix7FlJ2N2QFpWXiFYlhfczSDi/JjfCIzmgbei6KPzf +rE8LXbCGJzDoE4aFB1/IjLmU9WnzplIwMGMP8X9OG2I9UJX75tJKYWqdv+xmJrmReQRNkPC9sC5W +ZY20gdI23oFjsukGWfe1ip/mxaZaFqRC4dKWAREcA8FCstjwtghyCnJSdmz8kwAyOxHWMCoC6xqj +kezAB1gETIgUo7824MKqYyN5Qsu+xcoogRRxkvK7qGZuEYhiq+mlNlVURBvpW4Hx8wolorIybcrx +USNam5atNNlTM0Fmr3bGxWoodieOOS3G1PqiboU2QY4TIEWykRNmEgL1WOZzgmoJ2hgnjlbLrMJF +MU6W4nANCAqSsmpcZK1zgu4UIzJndorEZiQU3FckOsApMfqDtBMIQ6MTLRuZCSzzYpqnegrxpc+D +sFiBEMxVE2MfpJaMob20HOqU2nIRyUY+oRDWwJgUqSFiIw2EEzBEEfWhmkxxRFFmg5NTnS2ogUX6 +uIpP1MDUpE0TcjCJoE5nBeswqeYi1zG3er+M103IDWavgpP0BHJDM8qDjUwYBip7LAPvSI+RG+IG +Zy1kFODK5qYg0kY/aiBkyxYk1I5VTUBRrRFHlHMSShZt1A2IjI2TgLbsUmZ96Fm8YejIbYIugW1O +mnL7MjjPWfDkXE3Vc50xTCb6llE3OcPqxMqmM1PTdOsZj/RtyhLrlSBpQetPBExtSnzOWjrVj89u +FnqgmvE2SYk3nDrq2mzVwuxIhcdDtsiqACLO7eKaUsI6RakYvq1MyNFtWW49nXTkTOwIbHWVLA3t +WKup8HXKKPo+2eTMeoIi3UVwUjm1zrWZCZEJU8lDG+IhKKPXLCCnuD/mF4ng+NecOuRwtQphSBXG +ypBtr+zozKmeUGQoXWqrpNBYYxchK6b2pVFJ+pilPhPZRG3pIjZVq0oT9vmU2YgqqHJtwHlQcD1t +esxjCiLmZBdTM5SAAdPlIniEmkEHtr6CUYRVA3TWoVJjxMkzK7OpVpCGj+TZRqXVItF2IwVB6Mpe +DE6EfZ3hnDmFIXABChPTT/24QxbS1Jmf8rQR4yjXjMzJ3cWoaDMgMsnXRinC+nFpI10LFYbWVNgo +g5yzJbj6a6o6HfHzLE2QbsjGqVwlCbDSS6LJtRld1KrR1upcWnVJ6KR0Dcxivs1ByIFFqs+GLVZr +uG5OEbqs73GFJBppaZLS2u0EAZsjObxLKl+wrXCkTTLUiqOYNQyKCXJb1UbZLq4NmCPEhM6pZLAM +pRWgdJi5DCk/kgmQtK+T1t2rLoMSVTE2CdmgwMkhsohSELb8hlR1Zix7Y6VRFgYBweUQZJEqLHRQ +CAFJBmDyFdvQVKlUaFZhUh5K/VGMiGEMj5L2M+faAtHG8xyQlyoZlmDCMhFl94oNUORM0RKrNUvl +UrA1dcwGZJsKuollo9ZOttRPaosbSNXFml8Wa2mExsrAcm2tw1B9/Nxipn44t9EFqtiAGkYBzWwR +x7tpRVEQ2MjgVFd3pOcV2NaoMJl7BMyspBvoYrpqZMZOlIhLAlEWZVGKLTYaKEEzez3VXhmgFdYT +HQFLLUhUQQe9AClzM220YX0ycSMELBQLU51NjbTFZiIOvdTFjG3xDV1l2AjTTJAjk2xJMRW2qliY +8wpyK8KrYP/MjM3tpTU5zzpI4I50z3xDXjB+GDU2YcU41NdFAUN7BdgHrINjcltH0PBrna3Kekyc +6WRYnUHE9k7tGqbsiEKPio3DhIZmKTvJotxEDuoUD7F5PZYmkp+dkkamVUATobcRcqAjR60jX4eu +6EhfznMwmphxtXM8C9sWlVM75HA2apNsxnJuvjSBAMr/HhVpMCZwREcKcKpAoMmsjiHhxZr6Qjp8 +ITexHKo0jp4g01xLv4tMixqZjRBlRhtMEJZOSy7zq+tNcARRHicWFRlpTJjKtQGnsY2q1PmFukgq +pxqkuhyYrnNtQ+fY3KeKxUbs+TcZG0olijhOUujyZzoNk0NqlKORJ+AUS3LKmJdFGyEVuj6zajFk +3AdS11q3l1TyYu3eFrqk1IKlBlInKv5WUUwQ2XSFjOy+1wYcSBvXQwHMTFTykCOTksBsWLgSNuPF ++IIUUH8YhTZFG6nh7MOkDJ9UmLHGYKcSzlObcH4zN5yJXWrAKraOKSvvuJQ5U9DMZuyFYW6f55Rd +qenPtSHCzK6KrEvqUCRt4pC2tygOYvc2ZqM+9RJMOXEmCtntpBiWNPiRG2sodbgpYjuNl4vauJva +XHK1yRmZ/lD8WGTEQZluBOhymIBMN+JIpSnrTRw74aQ/xUd4Xq6yKjUnMSxf2rBVY/Mh3h5y2kke +FhIDswy6T9oSJKk0HS+WVXKZ2ITuXHui9ASxFZGklj6vDVgYAYF8p5kRWthAlNuYQADDnAPFma4q +oSfjeE1TH4DaolH3S7MvOhNVqh5+TA8y9qVhqDHQqpwybZ+jXjnGkmjjFCVV6+EsQtWmiQU/1UJO +v98omNSWzSbAcVacDK3HiRbFMWM01jBCCjuJ+GV89XMtb5oVGIq2GVRJK5Acn6SscRrI8Z/sAs6l +NbVI7cWyom/KQZ0mgkbBGC0MF1aSb8x5IBt6hkrx47w0HR1FyoOdMw60LTMvai5IXS2Q9RSZ270y +VaZJpwgZaBir6reXciqNZAZE88Y2Rl3ZOK2mIXi3ONyV9Kec91WjVU4JOjbCTbA1mnS4lCMXRZSz ++hXa6H2V2Li8O9tbgwMbWau8BGbWgKPhmDiQXmiDUm24kdIWma9yOj+t38Z4g23zwXKkjtRl7nkB +ecTBxVxNj75AWprDiniunZJ6ZKD6UvEX2MSf0GiQKpmWQ5ZNRkCe2cqbUvcy4U9gA6VJsLs2YCji +m+kpWpHObVKBQcNc2MrScsOBk4uNWiNRwP6XnAItmX8Jk12SC+4JQwHSJkwkT5kjUV61rWmYC5ZP +CCwzHsveDk0M9cBIMi1WMYn6eVPJUB+u6f+Qp9qSrCVAEyxEvblEYoBKPWILg7C0KDXqR55y1QxF +oMyRq3gkmyjP+V+5LfSpEkcNeiVsb1MipJ3AeKRVyisbq/KYbUI69jznCYo6MCYLgjr32bzdzMbf +A2yEOdpDvvnUGJ0RlLtP5LHVIIhGRJGdILQBvxCz2W4AKik4RZcLfQG4QXszg4uRrVpryMGpmSCx +KSK5ZatkQ4qZUin9msFhVGw6twjJi1rGFD6uzzKk+E/mllLHyeUh96JR+cdBYZoKU75RnAVGBjMb +zcxBS3lgvWlyozhkXlSyL8KhyWjHiTcmzAWgsLhNCaeNUDNFmz2Um4zYnLoecZmeiGfk0pRSJ/fy +44Wgzbn8ecDyYVElSAG17PxRZjp9lQ5NIqzLYl5rYJGW/bEZEYzUAtnJqPpXpjyvFPwyE5ikCiro +4D/agdAWXwg4vDVT/ctZ4LFBmJm0apjJNzBji/QOE+qTqabHfBkKKy/R+KIunGYtmbRBbnRHcjbR +5laqt947guac3xEY1CKgYHrAZSBpVdEGPSuMwSLlM+TE9iznoIuN65xZ3Sw07Tk00Nh4KT094TyQ +LOOasqTVmkz0zPo5N1KoyZ4tmKKyS5GAVqDnljqZdf8q3DAmebKj2DoCOdcGylS8G9MuUwYos/1i +lFJtDosy80PeAVsygDwFlleoRFX2KpiSDjSFCaqnTrO2MggnIJD/IeEk0YyFJnJW2JR1zhGlSS3R +iI1RC8DE4qHSWHmC0Kaha5lP1SBhwqXMrBpoeKUqt8VOjYiyc63QarYlIrHcFkKQDLxRxIRK0YTe +mfGHscuFRIzAFMoRqqYw43Icck0HETHDYMGBqj+EnHoj06LOQ2rvWGIqQIsiyHcjm//WArgwn7CB +WLlG8w8GnJt0QrpFOXvzi1yMLLEO9pBFxbRIsCbJITPyG+dZ0qTCCvuJDTG4sQAuDqdkqc1Ayg8W +zAa12LQa2gibN8XWDdCGiMUbsZFJbCvcJhxgT+1dNYyL7t5+/6kqkaMONCpqmOoydw== + + + HxhqY0A4DVIB2dWkjtsAUxt9ZiVJAkt2jXG5H4oSjbjzCGeGRJIplgpRYrlERZ8y2AbeZ9btaotN +31z/BrLKYCPg17YpIaVGcCBz4UyUSjA0X8f1rZUCw8fBjtpb09IrZ694RylWIkitNp4LW/uSrepF +upYCcpagSqpf/lKqP4cUSutNV0Cbfp/YAgo3VrBRS9JWf4m5NJOCMjdX4XcGmHJBEWOb/jTFtrIe +O+kzGwNDQHPUd9WcvGtVppIUJXKFrCJAtzf1xmJiXCxem5KTpPLbhMDUZqJ9KukssRmJpjQ+TZCz +8ZJdxrffz4XQSOrnfnfCduaJxEbgvIr95+yDLLfebyPfEjDKOJyWS97fiCbi2H9y43AXp9z04YvE +RicpUzjp9rqKkvlsrMy0nmNL5occ4CGilCtcxza5RGSmGnlMQiQDbfs6Akfsjo3lRsn9JLNFOUyt +utjWqs1suuPtdRU7HNmWlkrS5x1mw7HS88xHc3690NUOljphQ7BfqohzIbCNzku4cUa64c3kLJAi +lPLjp2Pun8JpfSqNxIZLhSkDbyyfvyu1Ye5Cu1u4EDJnDwlrE6NcFBNLLgoanNqMIrpMNjlDEVkO +DeC6juQ/Yvd1wnXxbq2gqO6X22hb2yQkt4UOUlu/loCSA/izmPMNuORIolWaU/M8FwJJtAXNkGzb +H4AtiDdfXyAC13bN9OVgRAhTLoGugmL4qhWlytOkgN6Y47qoAWlRPcrC1FbO5OAak+7K2U1cYSqj +AB/OoBGhzco0+YOqSCbflshm4FMKjl0dB0+rNXDuWxjZrJqP13ValPr8eGJesKK7GmzTUiKbqR7F +OaelREUDj1QUC2NzVGYD22nShC9syHTgji+zJNGWr1fkjs+Jne90wbkcu8ofY7evKjFwffckzAki +W6nO1KX/YMBGZaQTCXmauDDlZtYUTOmbNv2Vs/Yo3yPgYheptafT6yQXnE9MibOYmlJwPqLyddy5 +MJb5QqvHmYoVHww4tEVwuEsfAU2rglx3VdBAk9JP5lxmlXFoiziYLOTru99WbBxnbptSQrxxsTVg +cvBDXPQ2krbaW1xUVTFCB+9QURXFliC2FYGVqTPmCW6s4NRydyk571VxQObuec5nmkt7psqBaYhh +nrFSdnsSrkJJ4bScSK/iRbliehyxsWojLaMoEMaaPOUkpIUFq8hpKMyTynGkgSLmYhWZMSZQnkLI +yksqoiItI49sNThjeU9MYxktaJiik7e/oCgGf2Nm/rTEemVstkZihUNbdsT04tVAG0mukji4nlli +KnER0JbiTKNPfZcqxqzMM7YTC6WKfjBgGXJXHVl4xotGHtZhdccU12buUCsziQ0y+MBg264Nf+PZ +TWNyClYURWPyIvQN0rX2xYeaZCc2aPTOd3H18ZSLO6hihtyNk8A6C4s+lRjqNYOttzI36TMiZZWN +bAjaBalCV7WXiIAZxzzefl3R7iDP2RIsrMomJAstysyT2m4HpmaKMhLloQXfmMNMnsVc/pN2LOAa +vwAbx6XeyNzYKdh6oKrpsUWDLS1hEaTxyQlMWu2Gpf32Cmj/X92T3mTqvf7yo78Njx/mb85/+O7k +p7/99Y/P3v7887ufftDAk3d/eP/DR+DJqx9+ePvh3XeegnoAe+GUCsXi/6//XnSqD71A/e/1P/CP +K/zlTwD93QsD77H3q28C7zsa//zeMg/ymGr95YEyz4WKfkG8T3RqaQG+/hhMlQdJ/7jenOJOYDHB +D3jn83tkngTLCKh5HLRSzEYVYGUCvoUXhCqhkVAQ4lAa5ylkYbA0T9nfgXVknUpS/MYjax2U+yxK +wRxD8i8qDQ/yQE5adRoAL5XFARNQ1gfwBzfn9THU6ivsxZ888glgSxLvMS2XmlrGkfoKqiuv2/vi +H5SPnmyCr++9KLZZ/4cqlMbkSwQrC8ifRFSZlhniCQiOYHW0ugg0IoQMgqXkVCIuIF+hpJbDZpH0 +BdlHC6YvUJ8S8KfRF+BB7+/mPFRCC1YntAflg9n6ANd2A/z95qKf/tde8dtbOGgWr+ySWGVKKTIW +81QNOwv9GO2E7sx+E6g+8tsbKGrq0X48KTVuDxjI7zdAPYFpnvTx2FT31ft41gL40Qo2wXa1xayb +n/XxBnz7EYkw50XnSTKN/qaNncpJ74UYvDmlvYnFmzdAxRotsPiajemK79548+Ye5dQELU5vjY0S +Ed6YtQB+9P5NsF1pMWvxQTc//dtPklFF7r67Jz7ePvuf/x9QHnVvLcGJtBCHL6Oway0NKDBEnFiD +E2ob9L0hT8pACHoakFIRMgJhswEk5xMZZXRpFIqV152d1WYTR4f4S1OS9Evq70f0jopNQsL46ga9 +M2BFzDOqa5qIj6cgVxU5e4vX/StTHwoP5lUJVVQ+/HjpmemhWXzm6T0NVlJEsSm3KNd/0zN8e2+T +ghG/z7Jsg/PpIwx1AIMCZ+TMJCA5TjQim4MnYKIVLwVM6Iy+NTiQJkGqd0Hpp9+beQVFYqq7AImC +gSqwQ43NzVVUwZUJvyyV6hxur/ZT9CZTWvGt76JTTsWN7yLfkZDJx99FchJpeze+i7JHKBXyxneR +C4wEYP1dZPhnsAq7/ujLMsrvjOTHX3Z7vf/ZVOL/tfQFBnlb/gq947/8FwlhqmBCQjuTR8qkasSP +nFR7qLabv7i+8QtKnjTQYpo7gRtTkCy2scaQ1oiPTt9cvP/+3Y7+q/r+52//ik+/h93CWi/vrc/e +/ev7b989vzzxXj+59yuSERI1w1L9TV1/+/pvPPL3hoGgZ//4z0fTb/gJ/m/uxVhdmKmFQi+gQfeG +Q7W2s7c/v93xyBYW3nv98L/zerLlBE436g93B6P9wWDP83c77p4/OBtOL/z+Ybebt1prv7+zWD4c +T8+GkyPHE00nxFOuL7o96fd2HDccjXam85MgvpoHV8PZ5QDPjk7H8+uWE9Xqg1qt127NeoN8PD+d +B4+n6yej+VVveuL0skZ7tQ4vZstj18un86vV+lmUftmfnLvdvcH0gdc/6Dhps7Xu9vZ6o5PB+GSd +PHMHe+XatOUkbk+2naDRXLqumM0v4vTVdH01mB63nNDtZW4vHkxkw1n0xjuBeBHJb7LD38+jF3i8 +1U2aDljo8/zot9HOV2H2Rbr7Zrp64o+Pmm7YHx36A2xCUm8uavWJ4666fjQYyv5ot9aY4F1db7fR +jpqduOWm3mC/PzrxB3vD8ZHf33P9/Sz7dRh/4fYOG52o2ljUmsu2Ey5WD6fz82Z72WwtRuOTyfSi +NzhotsJ6fdFxosn4WMrXnW7idtPh8KhWn5fKA/y23Y7bHfyk/eFZf3zu9U+8/lGlvqg31wA6bu66 ++WB43OsftDuJ5+8121G1Pmu7accRrXbU6oTj8elseoG9bXdEtbHaLg/wU6lOajV8SNTzsz4QoLVu +NGauE1Qq/e1St1ofN1qrVidqtuKut9/t7mC2egMrX/eGB20nrlT7zeYKi6xUxp1O6veOut5hv386 +mlxMpqdnZ79J5eNWe+p08/H0chU/mSzOG61loz7ttBNM2Budub39eiuqN1aDwcF6fb1cXLoOiPqj +wfiw3Y2BEk5XDCcXo+llv5+vlsf1xgQ/QM7F6tlodu0PgV2XQM7B8MDv5c3mvOuLRXCd7v1qGT+f +LJ94o5OWl3Z9+etv/qeD029cP3W66WzxJN97H4rf+IPTtiuAJK1O0Oqsm+1Vs73G93b9nd7wpO3m +bTerNRaV6hTLxgBgeH+03/Gybn9vtrwWO789On339Iu/dIdJu7ueLC6D/Kvds/fRzje96YPe+Awn +8uUX//bw6Q+dfl5vrWarp4dnP2T73/XGl/74otPNm60VttFxU0xea8xLlWGjFbQ7IQ6iXMHpjNpO +4gHhhwceNtyTne5O291x/P3uAIiHu3CIPQQGYhgebLYDIGq1Nmq1V74vcBmbrWW9Pm811u1WAAQD +IrlOtiO+FOnLcnlQLvVrtWm5Mtwu+ThEfKzrH/aHl6533HEPxqNHk8lVrb5odyLHFX5vH0cGgtBx +QR/Ol+unjpdulb372w6QEzRlNns4nTzAZaHZavNmMyyVe1vbTqXsu52o1zvqD469blYq97EMx0mq +tXG9MQUuNVtJubpqNKNWO+x4u/3pQyIsjSm+ooJNqAwdRwThF1H8VRh+ORydZuLlv/79/3z+1YfP +7teni6uD0z/mR28G07N6c0WXqJMC4WvNebU+B6TtpPP1g9ni3AeG+/LFi58WwYN6e1Wuj31/V8g3 +UfZrvyc9P6rXcRHixfIBKEzH22l1d/zh2WL1NMm+nMzOnc56sTjL9l4v4qveZK83PsbOj2aX6+jZ +o8ffr6Nr10uBlqvwxTJ+1Ruftzt5t7ff6RK+AbvK1UENX9RZ4wJ2fdydXb93Asrm+0euJxqteddL ++6Md4LzTk+vo5dnVvz549rfjq3fOIOmNdubBg1l4NQkf+ZPzIP3q6OxP+e6vLi5/n+19AQrsuuli +fR1mrybLR27/2BviE47crgR5AWpVahOQgmpt4Xp7+GejscABVWtTt5t3ulmttaq2wxaOtXvc9c8W +4Zfd4V61McY+T5dP6s2gUpttlUagMx0nabVBwQKQqXaH/mw117XqpFIeVis4ymWrGcxn56PRMTCq +XB5WyqPt7R6hWaXfaK1df28yezwYPRqMHi4WL2azJ80WsGIfZA30oePgCE5c/3g6f5KIX3uDva1y +t1IdOG6CS+f39lw3AynAspvNoN2KtrZcoFa9PnY6oecdOV2Q0LTVSnq908n4tN+X49EuLkKpOq/U +QlBp18twcTr+aQdEu5tg2lLZJ1rnZsPhMQZ4Plje0Wr99PD098vk0Wf3G+PFSSSeT5cP26B73j6o +gdOVNcUIcK2wA14PE2ZtOuJsMT27fvx+MN5vdoKun2Oq0fSB42Mn5yAgnpfP5xfL4KrjpsPpkTfc +94dHLu714AjraTYXcfzk8OztKn4Upo/m0cPe+Gi8uJwF1/jTHxx0/d08/2IeXFYa42pj5jj5ePLQ +8w9woKAhQPJGG+QL139Ra6waLdEfnGOrh+MLf4Cdyf3ebm+wO5ocjedng8npbPV4LV7Po2fdwV6Y +vgySp6PF2SK4HCyOxd5vHn/+j8Pz99h/3BEQk8XsDBS1VBkAhWbza7n3DqczW1yPJ6eevwOyA9IK +ygbaValNgQOdjgAD6nogUym4Xgsn6x263ml/+ChIfosr03YhYb6YLB9XG8tydVauzsGtMAmIXseN +wMW83j7ue7OxAnVq1Bf4IRyrDDvga95Ovb4qVyaV6rxeXwIT7m93q7VJq5MMRqf1VlirYyXregMk +VAxGJ9htMESgDfan3g4cb7c3vMQ5gqb1+3sdZwH6A8RutkGOYlDILtiok25v92vVebU63tryWq1s +OLrogt56B81m0u8dROGj9eqiVOlj8dU68b5GE7h9MJw+W8evFqtHIG7bpV61OgLt2g== + + + Lrmlku97+d7OV5P5Q6d3UGuucCPazsTzRX94hDOaLJ44/kGnCxSVEAZGo712e+q6odffH0weLFaf +r0Mc5YHbjcEcj87+2HEznDW4BpjCYHQ2HJ1hHlyu+eJRIl9C2inVxiB6ILaj8Tlwe7G+mq0eZOmL +f/+f/6/Xv/uH0087ftyfQCR7FMSvRP71zv43g8kxfQVmbsdu92A4vp6tvpgtX03mzzDM7Wajwe58 +dVVvJ2DWjVaCnZzOH03m18PZVZK8/OLLvx+f/bbRWfn9/VX0Qh78bufonTz6bhFeR+GTf/v5fw92 +ryvNebubOUAG/wDiwXR6CfFGSSkLMJdefw+XCDPjp0mMAPLPjuPJ7bJTq+Nz4jZd271Kbdlopu2O +nM0eTGbH2xXQllmjJYeTZ7Pli9ny2WB86XR3gQ91EktmtdqwUsFZDOvNuQfO0j/ECTod0WgEjQaY +y7BWG4MBkQBTnZbK42ptCToJ1AIHAcmqgIBUeve3WpDBqtVZvb5utSIQChwBcAZssVQdVBrTthsD +aSez6/4Ql2If244b7XnAnGNMDjoDllcuj8vlSaMRuh1Zx1fUFk4nLpd9ELGt7R7YFsZ3OtE2UctR +B8JeG/xo0fWxLdL1d4eTS2xar38MGczpgHZ5eLDVwlOiUh9vV8fblQm+7vT499X6AHIpZAbQ9o6X +O97+ePYkzd+k2W+Wy8vxMJXZkyR/2RsdAcEgNvvDncXiQuav5cGbRiucTo9Gk0OIiyR1DM76o8vp +/Jnc/y7OIcdmEEuWwSN/sN8jorS/DJ6mO6/PLt/99Lf/7erFe7cvhrPTyep6sryGyjCaXszWT/zh +CZAchA73Yjg+na8ez5ZPBqOLyewKvHK+fPzo4feXj3+st9NGO/V6h+PJ2XR2iWfHswdx/OLw4Jv5 +6kHHS3v00kPIgWH6Ot9/O109CpPPf/jLf8wOvwDCNzsRaN1o9gASOygq5GFQgFYnxd/BMpxOhFdj +SaBLxEq8fa93VG8s6nTcI/zUaqDnoBUnIJtZ/uvx7LRcHQFPOk7ecmTLBaPc9fsn/cFJt7vfagn8 +drvsVWsDyKKt1gp0aTI+Gw6OBv3D8ei81U5Bo9rgqu2oXJnW6pDBFrXaDDhWrU5xsl1P1ptLcLdS +qdtqhZXKbHsbHHPc7oAZ4c5CSF6DcbhgW90dYJrv75P+5e0BzehovJ1+/wAyM+aE/IY5sX6gFoSu +KuR50KXqhKT36qhUGgKdiB1XRppSAX98fw/sab68hqgG8R44hmlxoG5X1GszyGyYsIur6oQlbIIn +vf7eYAQ8jKu1IWg+6RqepLOYPMp33+2f/nmxejIY7E5HO1cPvj0+/223l/dHR4Px0XR5HsaPd/e/ +nq0fVGrz2fxsMjuFjBcnr9bhl+vgK9zZRfjKHwLfgmF/b/fwq0Z7CWnc7x3s7n93+uDPl09/uHj2 +/Ti8GE6PTy7+EIhXDQdYveP1D4PkVSJ/k+68Gc+usKTJ7KzTFc123HJATPaD+EWS/er08vtIftXo +7LqQtfwdnz4EJPdkvrqeLa5Io+xKbOxocgKx3/VlmLw6v/phnb5cRE/l4VeOn1XpDu5AioMmAs4L +PgKRfjA4xYvAOMqV8aC3G8VPofwCJXAiEO1mi2eD4VmrjtutKE99iRN3nAwiWX/0EH9CMPbcHezD +dnlYrk7AtrA2/LPZhGwmK9UFWG25iiPrt9pr6OA4a0iq0/GFSL4cjS7qTejRS6WR7QE96jUoU0G9 +MccjjSaUNejIcaNJ0j5eWqtBJF41wBPrS0j+rpIWQB77wxMcOvQFYMJ09gB/QkDCP/Gi2fwh2AeY +ODhgvTZvt5NKZVoq9UDHSKirTEAJ25DYyxOiijWoY+DFswoQrDbFi5xOBlyCUNd1xHh4UqkDo3xg +Y2m712wFYMcQSsF2y7UxNq3jBuWy89lndUiwPkTuVtjvg36e0vWfX3T7O01iyulsfHx49JtV/BjT +zhaPIHt3B1l/LBerw+EYPCskW0HyChJvlv9qNH0I1bjtymoz7rg7kGOD4Ol0eVFrzbw+MPNgtnww +mp2OFhfu8NDp7wbpy4vrvwTiRRvEYXzmDYG3j5bRy9n68/H8MdRtjG9COOkKYELLicazh4vgi9H8 +WXd44UFX6h9DkgGxHUIi6u+0OjEub70JYWZ3sXzh9SRke9ATMGt8LyQuFxett+8PDperJ2n2VdOJ +mp01xH7IRdD6QTFK1SlEC5zgaHgcho/buIYlH7I35ldKd1SH8FPFoYfQ7EBA8KfnH05mz0fjx1C9 +PXevSrcY+juOrLddgoLm1hthp70HCZkOvRVUqtDrl0BXUCQghtrzY7e7W2uEkJ2AJIPBCSRzz00m +g/1OZ7213QY2Aq86nbzdBp/KwaA77XQC5bo5v7/VrFSgSILiBV26UJBLgWbz6fThdHaF0wEPhcxM +cr4r6Ya2w3K5j2XjFfQJxMu6+AEBbDWTdlsA37AwCNhg/cQ6q+NKZQziBrENNwJsdy9/+dXLn7cr +/c/utzFV18nnkJYXB467pMVUwdOXpbJz/7NKpeSArLVwQWpTiJGQMHEc9eYEmj6E6unkYj57MJ2f +41ihPk/mD7zRXq05cv2wP8gm0wPQq1B8MVtdNTrr0fxB28sqjTnOGggWxq+i9OVoelprLaAuOb4A +f2w6gdPLoMGNZlf5/u/Xyevx4mHHF0H8OdAMZ91x48H4IpFv987+PA0/7w6hL4TAK6eX1zsrPLWI +vp4FX0+AOYPDpgNcCuLk5Sp6Cr2D9LjGHBcTXAmLxz9xUritYI7QLkeTsyj/eh4+90fHXXB2fwea +3XR+MVk9qnfC7eoQkMHwCLcPewVxCzQcyOa5OV6xTUfQwiFCImq31p6b4j7ixHG1QZkbrQW2FNiC +c3ccXEkBnNku9UnwBtVqr8FhSyS3TMBfSGqqTkHZwFXBAbte3iSdMSbO29/HyDqpohC0RsCrZmte +rfTHQyhHp4pT4xvn26VRo77GmUI729qqu07Y82UTqn1jXQYDJSIzH/RP5stnoMnEhesTfA5oDsTI +TieGbgsyBVS5v9UolV0gHhTergvWNsE9gkIK8kXUppcvoSx7u8r64d3f6oCC4Vu6fgZFCXsL9jcc +ynpjWCq3S6VmudRuNhbDweFifuG6q3ZjtFocQcIEyW02lyTv9fIa0MBd9Qc5Dgv8nTYHynV9Ssa3 +6XlvfNhszWbLE2+QA0KGGgioLSIdYuftZHEFqSAUT5vOEhuOx2tgN5BafREmz1bhk9niLNl92Zsc +eYODweQcOmkDmODl+e5v5eHvHB8ceT8/eBtkXw3nD6F2NToxuGSUvo53vwLRg5w2Xj+sd4JqfVnG +KTQhq++F0XNQWnzCdH4KNICsQtJvY91ux8H68yz/uj8+bLeWO/tfTqOzanNYacyq+LQO8cqTsz+c +XP1Lb3bhdNMweer2wHcgjYwg8eIowbbS6OVkclau9hqNUbcbl8pd3HQcNxAAiEdWEQcstddxQ2iR +zVYE0RrcqlKZlys4rz0oaI3mrE4/ZBark/RCeLhdGmDwcHgBIQEaR9sNG+0FDnFriwSeeh3saeh5 +SbMx63lJmjxsOSB00BpCRdYOW82oUQflnJXLXs/PnfYahAs8q9WKcbNIBGqsmmTRxf4IvL1SG1br +Y5CgahULG4NDQXyqVPEVw3ZnpUQsf2vLAR0GjVI6wmK5ePDjT/8HGce2O9VqH2IegMBbsMIqJm+F ++/tfHhw+B1I1at2+t+p7MdRPhS1rUCqvKw6OfgVdDNoo8FZRvACiF7BuMT9VppVRrbpst6KOg49K +B8MDMj315NmD3w2m+1ulXgW6J4nEQX90vLP/2+HkbDG//Ort/1BpDMjG5UCPznxfjsaHQK3Z4mJ/ +5+UXb/4xXp1XFGKARPv+wTp4+fDJP3ZPfu/29oajo7V43vKSRicE5+pDjF8/lQffhvJ1Gj1+94f/ +EO08uV9yFX0GkScBYDp77A9OoM4fHL+F/FwuTyEz4J/47XxxBTUZJLfXlQ+u3/dn2dZ2A7QCSAUS +OhgfXF7/+fLZv4wWl8vZ2eNnf6x3Zlvbze1tx/NzUDCIEOvVYzAsXBOvlzpuqNiTXyeSQnoxsL3r +J+3OfBWBbgfa0L1dgq4HDXdvDBmsC0Eoni/OeoPd+1vO1lYHejr4iGI62Wh85ZP8ELfcoFLrK3oy +As2BtgUKiZsOcWs5P4nFVaUxVmYxKBoQ8CJiUpVZs77oeflyftEBCnnpcHgItQ6EtFYHUxvjFR0n +Pjj42u/noF24EUBFpyMb6tJBOAdG9f14NgWOAbV6IMjVCoQuehBsHRrl56/+pdaaVMu+1wmhgIB2 +bW/T4mt1MJc8zV6sgstK2fGced9fd1rQLKCnzPzeznR2DnI3GJ9CTKqCmdam5TL0l3kHB9HLx5ND +kHSw4Hpt5QBD/IQuJmFjHgXPjs7f9kd7IPIOWf9wwUMlMIs22UvPv3zzb/XO3Pez8fi419sFHfN6 +O64nXC8+2H3x9v3/sowf1UgcTXF3JuOL5fpJtv+rwfS0rrj5YH5cac16wx2Rv3B7ux0owp7sj08u +L97+h3//f86vfov39v29LmhaawUU7fUfzFevposnkfym0z+GOjabQEIDpQV/T/BeyLGjwfEqfNzo +LLDDYxKc9lqdZdtdgfZ2B7Lby073vvz3//X/bndX29udrhtEyTUoLc6oVMbdmUNUW4cPofKA5jhu +0OksHTcGU8DM+PBwdfX+p//Y9qCt95VPKsSfjiPA/kBqovjRm7f/49mD78BTtrfb1aoPTABzKVVG +oL04o/7wAMQBch34KagNZONK2S+VPEh0s/H5evVwMN4r1yfgmKCTWyUfHARMedTfHfX3ZpOT9fqh +103j8KrZWoDsbG21G/hwkpMF7mkiPh+MpCaDtdpQqYcj0hPBvp1wPttbzI9Ai5SISJgDBINAiB8c +EDZwu+RAo1lML0EeP7tXLW1jciiDhyC20BqgQpbLfoNEqSFejb932glol3IiTDsuZN3FVskDjQJn +7HaFC03cSaGtlMqEwBUiXCO3G7luPB4dZeKLyeoKQj5ODTe3RR6xueMlQKrB6HC6uIAKOZwcO162 +Dh+H+Qt/AOV9dzA68PqyP9wNwof98UG5AXa2IJG7sWiSHRI0dgJePBwdYJ8xf8fP/cEeiGGljsnz +5frx7tEbcfR2Hj93B/v11gqEl5TxxqTSmPqDfWijXu9oMHnU8Q7XwRfr8DmEq3prhvPCCrFvtTq0 +rZhE5ea61gTCuNulNv7sYp3Ri1R+kWbXcvcphBxIOBMcZdUplTv4J7ZiNns0GF30htA3I4jKHSeo +NUZ0m6D/jg+AqHH8pTz+bYVcTmNcqHIZm4zb7VUqfqMxHU2P58HVYHxC1qf2ol4bVKs9HAROv0MW +M1lvxhDye72zVfC16++SStiAxIXjmEKwrzfIdtcbnsfZN9AmiFN3cHbjEkhEZdhpzg== + + + m/V510mS6DGQodEIQJOdDvjjtNlYQR9ptMgvNh6fYswWxOxSH+9ttZbgjyUSHfuk7YJOktemB8oz +GR2SDkI/ffw0mkvPPwCSgGQ5HWijC1w96Mil8pBU1CYtZjw8A6OvVSaz4cnWtnfvHuSuHuQTEk5q +YP0+kVAyaIzAjtv4Uv8IZBPEk4weFaAWBIkllgR8BqslXjN/MBodtyGxuNFkduT1s2YnanfzlrPr +eMdR8s3O4R+jnV9DYen1d8FGQUaAwyDRYIKNdtLqCHBtvLTrpJPxUaOzHI52x+PD0eQiEl+vopdu +fwcqPGR1Hxq0nzmemAW/CuXv5/EXDrTFTup4e12yM4h6e9KCcNg/3Nl/N1s9dbr7jXaMq931JWgL +rj++q9OBFHfRG5w73Z0aGYjGpIPXp6C0/cm+20+7g9z1oJFJkqtbdBkdN3L9pNkGfkbQLKCxuv4+ +uDB5FbsZmDVETXyRUu0PB+NLt7vndXdx9OCnjTq2sbe93QT3bLRDyJNtN/dI7lqCpOBAwSAq5T6x +IeiJLUy47/WAe3mjnXv+8XBw0u4sCT2UsRRn1OnKLt4OydPbnc+uGxB4yj2nHTgQGqujRg0s6aTj +yE4nbTYhbQJhIDAL4K3rQYA/Xi6u59MLkIhmfVWrju/fb9y7V4EQVSGZp7+1jYtGptQaKb8J1I0m +6Rrj+9seqGi1uqhWsexVFD7CAQGru+2o0yJHKoghPgRPgbV5zkG6/hLK5vY2BLYhVOPP7ndAwBuN +JRnowG2hPDZBS3eGw1OQFLD+amWGB31/t06mjH6N6Ezc7x0vl4+xw1jAcLAnss8dPybDuysH40fL +4Kts57vp6gkUMexGnDyHTlFrTHHcg8HedHo+nT3qD47ALCrVydDfz9KX9TZI9Bi8eBE8Ozz/c5R9 +DfxptML5+vPB5AHdx+YqEG8W8Wu3f4DD6vp7i+D5Ov1qNIYknE2XZ15vb7q4artJtQ6eDk1/dzg+ +dVxs1ADyHgSbejOtt0StGdUa4GhyMID8cwg8waVw+6I/gmR12YZ+1w4qlUG9OhsTJUxKlS6Y4Hh+ +PpydNtqgV2QwnC2eLNfPm0Q5523yBoLt7kK7d5y8WltCTnZxg5rT7VIH+le1scQPGDdtXTPsOmAK +olZbbt13cP0hfkMaKZPVCzwoHI6v1uuvFsvnZCkannQ9LMAjLa8xA1X3SKDam82vWs25014Me7Jc +crehu5WGA/8Cj4Bj0t2H9NtcQ9hod2LITuBNrWbiubv4021LXLTPPquBu1XK5J28f79z716rTFon +SEcAYlIBbekI8Ov7W77r7nY62L0dx9kLgsejEWRasZxedtqRFh1rlTGwzmmn0Fm6Tra97ddI0+yB +fNVr8+XqBXZJmS8muMhAsyo5GsCXFzU6pqTdhqSalrDI8gicCKdcq5EzAsJYHfLe8Hy+fkLBJ42Z +3z/w+4ftbgqVZLvSAz3E3QmTz8HmGhRYkrQd8FAgJ/jCzPPy4eB4OrmczCHV+x13iVMeTA/9MbmK +RhDgF1fjxaM2GYsg24CAzDFtpTYCQ4RA2xtfdIdnrbZ8cvqHpy++r4Hx1efAZLCwKcUCgZ+GFfqi +mcye18iRt3a949Hk0iNH6oHfO2k5Avv/za//+69/8w/oaBCrShVo4ku/m/b9nXT92OvGbVLkd8Cv +typuqTrsDY6W66dR+tVs8RhS1mAoB6PdUqW3RSwgIbrhCPpphxSK04n6ffx2SF7+1go6PkS+Yf/U +dfbq9RB31mlHteoAqhmUMqxKRQWQdatUhT6YyPT1ZJzXaqCf61oDCxtVqmC1GDx2O8G4l83Hh2BP +NQj80ImAolWwWsg8PsnALjbwDIQFKme7Gfbc/T5I6+DUdw8a9fn9+837hNgDYAL+Ui1PoRRAiGpB +nccetpPh6AHYSq2+wp91kMHqcrsCNXOhHBCHy8VjsC3om/gi/FAcDojVlksrgQiHb6f1APkjXL0y +MdyF58YQqKqgTpUh9MdeHyIH2fxBWzAtlGV8e4POCIzYr0DCry+UyQLXbVkuD8HsWk68TaEaLpmd +gQNNPLUGcXOggfp7/dEp5JxKxXMcLABMPO3gdcoRD5kzjj8fzg63Kj64wHh6Np6cAE/qzRDXudGM +mkSo+25n2e+lWHCtuQaFGY4fzBbXu4ffreUrCF3An/H0ApID2WFwncs+FuB2M8/fq9XXjrvTcbIy +EB6nU5u2WpHrZWHy/OLRH47O30AjcB0y+4DpA6OcTgzxtdcVAy+fjA+xISA7ZJKFqFYnxJ7OzmbT +k+H4EDisxOCJMu8nwHwwBYhS2CIgDCgVZMLl4gL6FDazhc8hQ3pQKgMTcC7rZnOlmMUE+3z/s/b9 +z1qV8qDVjMA4BmD37XWzPhsNcRA9UgHAXuvYrjkk50ZthmNVbH1cKjn3P6sDSwFs1pe+k41GR0ok +mw37uxAdwZ2h20I5xSuATtvbPbyCvAbEBPHe2vZ9TN7vdSPfjdvttNmWjTa+8XK7MtwC765Dl0+B +/IPB0WJ5NV08bHXIo0FG5pL32WdVsNp2c9lqzEsloDc+DSoh9sFR1tHM6abt9ppIYguCQeb3JMVH +OaT3Aceg87bJlhuRBYwuIJjvslKZ4KZj/UBUx007XlptLrCBwDc8gsPC3yFVroPrNH+1jj5vk/lx +CbEN6mezPWk70I8S4P8EMmoIgX+/1sLjE5F9MRiROYjiWEBCyQuMIwugEs7nYFu5ss9DdIGAd+R6 +O2T/7O1SxF1j5XoSlArnC/IISZ4QiYjGChd2ODoD58I5QtrBgeIiQHn0hwfL6Ml8deV2D/qDMzwL +CaQM5AfB6e212xHQA3sCStJoZxCJcY6dNjYqHo0OyIvt7vb7pz1vr0leACx+AHajfM0jqD+QWuut +ADsp88/PHvzuPihbHXJvpmKlhuBT5Qok/6XyLgU4lHIJ17+PP8mjt93b2vKr4GWNFfAEPA7EoQ1Z +tz6GLIeLDBaG42tSABhQC2wIoktve6u5vQXk7EOXL9OXrrPky14//uyz8v3Pqo0q4RIWBrIAjllV +/kTITvgVlA78BZPgLS4FnFwOx+cQ1UDG75cG0JFJ/VG6A5gdVttsg63LrrsLWQXUz3NEu7nYug8V +uEciIrCoGUJwGowoCqU33Ieo43RFt3egPMXkvBvNTmbB1WT1oEqqKETWiCTJ3i5+6JhqwNvQwVOk +iK0bnTVJ8i7JOWMKodx3u2I4PFgsThars8nsots77A+P+mSJOu36URA9DONnUJC73QzHVGnMK40Z +5POHVx/G0wNo6E43KtenW/RpyzqkBXLon1Ak5+CwS2Eb4VZ5sl2edFySlKBbgXqDk3Z7+6Ppebcv +t0oOdOdKdQSaCTbt9Q4hLXe9IyBzvQENYggO3u3tHZ/96eTsz+PJtd8jHyIuDoWg1Ml1okI9xyrW +Lne6e1CUoLCD9OFm1Yl6rFvtfDS8nE7APlIgHpkdVLANWbC3e5UyRXvi0+aLi+nqAc5IWTJXpKeX ++k0ohs2s0YSGQqEmdbKCrsrlydaWBy6m5GGg1qQGyadNJtCum44HB63muFoBWYvBT6HBgde02hRQ +6vt5rdL77B5QqF4u+aDAwH/Ifr5/Av2LFIpSp9+l8AYwr2plrCKHgwb5wfGNPj5ZOaf6kFVapISm +bSejj2pS+EeN7PzDe/ca9++1aFXEwlK3u+NR9JrEX/pAiW4EtCzR9Zlr1Gp35GT+MMperqIny/Bh +mD3rj6HFn43mDyeLh0H6IpZfi/03Tu+oQ4ElUAChCB/jcMn36uLW77keqNmKyJGfAT8nc+jpRzhr +nO9kDob1cDjeXyzPV8Hjwfh8OD7rkdP8cDZ/cHHx/uDwt/PlJRR5sj51oJHtQBaCkAxtaDA8hNpe +70DwmODuA3Mcb2c0u5gsH40XV1DWII0rn+9CRboee/39BiRkb3cZPhe7v/bHZOUG66wruleqTqFO +ThaPx/Nn4LDbZLQEZQuny8vJ4gKrrdSgiCUdl+JXx7NzcFVol6DkwC4Q4TaF90ABuca3dzwJZIO0 +M5kc9gfHXe8ASAstr+UCSaAFpDUyVhNNIIYIxu2mfn/fwYJbSdOJ6y0KYICc2YGm3MRVlbVm3O0f +TucPIbXWGyHZGBtzFXswgNQEsRaKp+vm/d7+oLcHvMJ6GuRDJ75DrqUuzncHmniV1F7wXJARiCuD +RgPaWQiq6HsgL+Dv+XJxWqsPQXiHo70weYaLAPoJtOyPjiHutkg5ymazQ4ptbixx0DhBf3Da7R+1 +KIA2LRHFA/KQ2xEMhciIE4NQrKLnUfI8Tj/HcUODbjUJXckV205wjsMpdvjB/tmvQ/k5tKEgfTZa +POgDJYKrbO/rwwfvk71fj2aX5OR1wzj7fDg9B33okWVgD6czXz8Yzo5X8XV/uD9bXkbyxXhB4Xnj ++YMwe7l79Jt8/8tV8qw3PgULWwdPQ4hV45PB6FSNOZ+tLvZPfjNenLU9gQ8ZTK8my2ez4PPR4rqL +sxvsTxeXyc5LEKIoex3v/GYwvXR6u4PJRR+IOjoGQVB+yazdTbyBxM90eb4MH4fii3X8YjS9HAxO +/N4hWGeTTBb7LgUuriBXtyFb+jhZ8GVIFwm5UfxdTIifwRiPUGx8ywGdWQxH+0Bgx8uGk3PooYPR +cRg/XUEZn531h4eDyUnHl1XwNWCgv7uMns2D625/9z+R9B5edlRXvvA/8D2QOt4cK+d8q+rmnHPq +2zlndbdyRAEJSSSRDQaTjG1wxgkwNmB7HHGOYGODwXg8Y+M0nnnvm/e99da3S16rFotu9a1bZ5+9 +f6HqnF3WHDkE6xlowPTDaXGggDIn14NEKoDF4Tr9qA4qwhPQSTbHCBUoPbgMHxKFLwJ6hQR2ODi3 +i/d6wEYJKBJH0SQKQQtC2AGEozAiSFcbKFKHAB+BH+Ffea4CZAFQP2YXrAU2dgkYHNwKjicFqaRF +WmKowiv5bG1ZUFvW+h9XKIhlELzgR5I4mVSkgiJX/GjU4VVhZu3WMjAKzg/DsUjNA3qJdLoYTsx4 +fBKK6QSVBAkNPg4MO820rIVzFETPBE0C3Of26kFrgopKpEPwRV5rKWaXEgq0ANgVY+V8LDcbKywy +UhlygBMypcYmxRd9oA/pHJS8oDZZuUpwOZK3vF40PpmtrKBk0gUQROWlUBvyKhTta9EplC6jZAWo +NoCoviDMsgb4IGkNQaszUgWyxe5RSb6MUimETOJMgRIagj4pGZNqeJpT2gybK9V3JWPC5laCeFrW +J2UDft/j5FYQj3uDOqRKwFobLwHbYngkHJ9M5BaN2CAcn+LEOqCKzSnjdB7Bk05rBaN8fWkED/YN +xPb1h7+0tbnDFwoiUZzIymqP4ksYnaK4rKjVMTrh9is4k4Uhw8FIdQiUGZ/Rwn1BbwTIxBCYd4+G +ESmSLTJSA/5rDZDJSVqrUNs0UtOkVFEjE1p0UrWWcNfM1LQabkJ24VQkkuwm83NquA== + + + ff3J/j8X20eDRJzl8r4AsCEFxHd9R0CS5qvAJhahaC0rS7G4HwM8h2DCB6OcWMsUVlPFVZTKAdT4 +0Tg4dOuRvZv3B3ROKkXzc4nScrm7M71+PlZYRagsxoAWSo3aQAilMDInSvVsfjWSmocBEkzefv2G +gNerIHgM1BFireBNa2YnnJxSwx1ezFkbdvyQCaUgmnJbS9QSvNKQzTbJA78UrS05SCSIx2ipRIk1 +Vm7KRjeWW0hXljklx8oZNdKUwy0p3NLifU6thGI9RqkSfB5nM4AkKBnHmRQtFOFTkfhcZ3CiM30s +nJwUtAbOFWEuBKUiarVwal6NLaVKByEm/iC4D0APNYhFeLkMdCyZExhbRpliJLMiKHVWLBAsJHZG +1CdYpUOLTYqvm+Fue/IYrzXHnAJMXCg8LekTFF+l+AokOfwxSqU5ueH2y3YXDdkrKAVJL+sxayxa +dACKMYDHGbHs8MheC3ItygYEgBwD1MLItMPaEWP6g2G3F34j65HpeG45kp0Pp2bggHDBMKGC/FgM +ZdKsUmOVeiyzaCZmYLJYuWxzcj6/hmEAJgZOFUSlAxVqJqazla2plUuJ0gqENxSbkvQeTH154lB5 +cChWmBe0WsisNSc2W1N7+cYqpAogIS1WCL4AXyGqVZJJJxIDgFBILUYow0GyFpUUGtup0qpitPOV +hVC06fTKPiTMy7VwYjpWWI5DdjE5l0+XQ3U/ZozZ0CBmKAZAVi2WXWhMnZjauBTJLcUz0wvrN4lK +0+GKsHKfV3uC2o0m5sudo2pkBnJ1ZAz3eORgIMQKOSMxkMN9PT5T7h5OlTdgHvVIq1xdxKisyw3a +DDR2jKAqsjEVya5nqwd5pZVIz0KBgKFD8IRkDMKplWLj8MLWHXvH3z+7eGp+/ZQabfNqJV6YjxcX +1Wg3np/vTJ+c3rhFi08gZDxIhHEqJusNAKhsbbPY2tZjE4tbl8u9bYRLI1RC0iqhSCteXFLi83pm +mTO7XKgZLyz5EMXuInEqbsQms42D2fbhdHMv3dgz4rOtwaFwsi1o+XBmVjYnAKmU8CCRWyj3duGD +rAi5Wnd4RT9m4jDLYllUG2q4nyxu5Gq7GJ0kmISoFHyIhNMmJ+XDqdl0dT1dWS83dzqD4yDhGLFC +C1XAWxi+Fh6EEzPZ8lahcTCSWgGkBa70BnSaK4QiE5HsnGx2ea0hGm0zOcUolSCdpuUaq9ZFoxvN +LEKEy92DjFD0BxQUNXweMAICgmXU0ER9cLjY2crVtyoTx5KFxZXtcxAZYE9aKGXq64PVsws7F5d3 +L03OHdXMmiAXE7l5jMoQbAGl87zWbk6eLrV30+XV7vRJKHyXVya4NKCoEu5nyuvNqaP1qSPl9tb2 +sdsaEwfEUDWAhUlrV8vASM0VunuJ4poZny53DvqwsM/P62aVZpM2O04yiUx5dWrzlqn1C1tHb7v/ +g8/LobagTLTnLsbz6wiRx6gSr3Vxpuy1li1JgFQujwBUGIrUjUQ/mgV8WFcjgwCeyOTnnvnM1/XE +5JidUkP19sQx1YD5AmDc1RMLALxrmxcROmVz8iwoq+hkrrpTqB+qD04Umlu7h287evP7GbkSTc72 +5k5PrZydXD5dHxwcrF2Y27m1P3n8oSeey9QAfuPhWDtb3Sy1D1Z7hzpzJyfXL1Z723NLR9eP3QrE +2hpsz25eSNcOSJFBY+r4/O61fO+kYlSj2RYfygcwgxarcnjCzC6amblcY6vQPqDFWtX+SqKyIIbq +itkm+Iwabumxnh7tdWcuJAvrCBWmpUw4OUGLoKyKFg4bPTU8iKSXio2DpfZeKFLVI3VeKWvRXqKw +GMvO56qrtc7m1uErc2tnAS0ZIZ8qr9S6u725E9XObr62nShu8HJzYuLY5OIZX1AjmDikRLG1l61u +xAvLEwtnZ5dvvnD10UZ/z4tGIee16AykvZmYk8PzemKr0j3N8aVAwMDIFMGk4tkpJdKOZme0aDec +HBTqG7xSBxbTIhOcVIilJwv1tURuTlKLBBUDNqz3j0qhViwzA1fLiKV4djZbWzVSUyhTUiLdcns9 +VZxlxUy6sqSa9UR20BjspcvLRrxXbK7ecf9H4FScVOzNHp/ZuFSfPpGprUfTM4xQB0FbLG9sH7o7 +lZ/1I4KsFcqNlYnF45OrJ9tzp6c3rohaW9UnKa4wZsNBHoTiC92FS63ps/HCZry8FbNERT9fmivX +Fzx+0eVVQGlzoY5skfsgkpy10FXKVptrsfQU2HMh1DezK1piLlleCacmHV7B4WJBfWGELshlzZyI +ZRcztY1i+3CudQh8X8johVMDI1HPVGaSxflIdtqItwe9jWc+/Uqpve5DNCPaHsxfHsxf6c9fmFy9 +EM7OVmvLjzz04Yc//iVQKd3ZYzObVzrz58r9YxPLFwYrN6vhibNn7n7fk5820q0xB8OKdSM2k6lu +9BZOrh26vdrfnZre+9Azn8s31yAHKq2tbHUVUm75wNVTFx/dOf1EJLky0duaXTgB6cHLJcWEpJpI +5Fea06eWD91z4MwHahPH19ZPzy4cpISMFmnr8YEYasp6K56dWTl4bfXYfcALergLiUcwSTgDK5XB +fvrQtBdJRZOLjcFhlAiRbEwx6jDFIC0kAyRoq9E+cO2+p/szhzAmVZ88W+wcS5fXByvnC72TUmRR +MqcIKh2OTKNkIoDq4WgnkZudXT+7tHNLe+4EDeqFzjWbB26/56OMkIqlus2JQ83BCUFvw7XFswvx +3CKI0nB8woh1XT4BwXUAZxhUNLM0s3zTqUuPAJivr51e3zrDidlospupLOVqm/35U0fP3Xv7Ax8C +DFldPnLPQx/qLx4HTxQkEmAWwC+ni4erE+dqE6dDZmd9/djJU7dEYxUUJlqrC/pAjc1F00sz63eY +yQU/YmrhNvAplICoAuPX9OScFGqm8nOX73pi6/DN3qAKogslMtn6brKyKZt9lMjxQvXEiTvvuf/p +kN5k+AJkVKy0lqoc6C/eTLBZb0BF8bA3oPgDkqRU9SiU2CZMU6511EyvYFii2zmoGkVPkGbEeDI/ +X25uNXqbtfbyxMwuK2dtLkpS84XKVr66kyqsAYuJRq1YXTxx5u6VQ5eCuJmrrWbqm9H8Yn3qZKq+ +pcUmYZZPnbzj4h0Pq5HKqJ0RFECkgRJuQ9I2Jg9D0Obmj3zp5W93pg6KcmFx9ezBmx6a3r66cODK +7sl7p9avCnLzphO333zLIxiVVPQ2fGm+upkurhYam+3Zk5X+ISFUP3b86tLaCZJLpctLueaWmZyN +pOZKzZ2Vg3e15y/o0anpuVMElxkewwDzBQVsXQ1nK+A1OLmTLiyk0u1KbQElwyIQemwCOJFTapHE +THPyqBJpEWyqPnVK1BskByqihvPFUbdm85m0UI9n1tx+FfRkNN5TjXpzsNObPxbNL+AgJvFMsbhy +5dpTslFMF6cnl8/U+odDiWleKQlqGaXTGJuDUZixQQDTeCWrGA0NqsbshCLNTGEehNPszN784lFQ +PtX25sTiye7cye7s0f7cwWZ3zTDqDz345De+99O13ZudXhUlEhRbgLRJFncSRYj5FE7Er1553yc+ +/WK+MAESrtw5AqVR7p3ozN8ysXwVRCBBgfY6la0s2609xRLJ5XP1A8nCcnvy6J0Pf3pl75IZaxWq +ix6fgrM5TmsSbB7oJlde3z546+rmBV7IVxpL6fIsziaDeJJiK6HwIF3azBTXAohhhGrhaBchIhA6 +NWq5M07pUEzOMFt+RHa4CZqLxDL9zuTe6t6VTH0N/MW4g7U5KYTQMDKk6NV4ZjFV3qr0d6aWz24c +u6YDYXHpQm1JDBV4Lb9x9L7ZjVvyja1cZbXc2gI88SJg6mXJ6KBUDCMjkfQ0pEFjcLA7d6Q1vSOF +qyihGtFaIj+dbaxX+ofz7V1B76FELBprRuJd8AKCXNHNDsukgkFN02rV3m6hvR2Kd0vtA+nKKsWn +oqkJSAZGKrByhVUqKBVx+WR/IHT82O3W7p4RJIhEoNwsncOA0sgG8QRKxiLxVqm+DBSQLy8tbN9W +n7hJjy33p86W+4dFs1mqrZ697QlKzP5zZweCpxmhoSdXSxM3h1OLdreAU9FcaRE8VLq03Jw+1ps/ +t7p1+/L65Xx1O5FbkqTs4WO3NrrrLp8YpBIIESc5wN5ZLTYLgBCKDSg2urN7LpebQsEnitVEdl6P +zQBzhaLT2ep2JNKZnj+RKs5D6gLkkkwSQFKWy6XKYq21QnHJIBpG8Qikt2p0QrFpQWsn80vR5FQ8 +MRmNtFk21env5Zvbotll5dr120qmH4lzYmNm+WbZaHgCIeBHMdSq947U+odqvYPN/mFermeyU6fP +30dRYVaqpmvbUBSV3pHFQ3fOrJ1NgVAkEhcuPzA9v+uyDGkkFJ6j+QxCGi6/CN5KlKssnwdFSgs5 +PtRJFFZyjQNQsNZCTcRkuYwZrtqdhMcnWPuphZqg9XCqSnMgaWp2J42gkmYUjERDj7cTxUWwRaLe +SmTn9EhXkrOV0uzi1rlofpoW87RQ4JWqqvekUN9ILKQqWySfATrOFhbK7e1Se6vU3aXVqp8IX0/X +ST8mJ5OtvRP3bp94oNg+JGqNAArRMMGbW7t+3PLoKOJy0jSTBGrW410l2jZSgyAVAVTpTh+H2aS4 +TCw9U+sfA1Qs1JYVvUSyEZdXsNlpl1sYtyM2B6mb7Xp3r9jcq06c0TPz4IV9iCyp5Xx5IxSeRMk8 +iHaSTyNkuNpaq/W2PYgCF2CYA4yIBVGdEku4WAMMtO5XqFVZq3v8SqG6NbN6SyK7nCvOt/o74eQM +TJyulo4evTWWqNk9rJmey1R3mlNnB/MXQ5FpgisjZEKSC8eP3pZK9QJBI1NYmF48U2vvJLJLiewq +yRZisX5v4jCChsOR7vLW7Z3ps5H4rKK21FCb4oow0nRhjhNTMFMEGQ0nBnq03+ofml45z/Alp4NW +xeT973sqFKp5/SGCyfBSmZeq0eRCe/LkzNJ5UOyZdHdm9QwjFb0B0R8QUEz3+UIejxYMRJCgdW9z +YelMIr/o9oOnlrzBkMcfcnlNiq1ycmvMxty4zwNeW1Z7I6MBa22bVwDlyckVmssJbGZj7Xy0MOlB +pQBhBPEIZLUc6spaiyDDtnEMx6Kq2eND7UgKCmcmiKWBgt0eiSAinJCkaCOR6inhlqA3jdRsubNj +RNqxaOvA9vmZ5WMkF8ZIM5GZ7E4emZg9lbHsxgSv1oNEFOKZyc0BoTM88MX27Orl7vSJzb07V3du +4+R0MdfZO3olU54FunFbjw6tG2vh2Ew8BZ497fKoFJ32I6rLRTFcotDcnFq90J48DPZq+/D9g7mz +iUR/bfWmzuRRViqQXBoCAufxIYYid2kq57IeaLIkHZG0IihqNT4dILMYkwPDDiXAiIUAplNsutLY +i6UsHGZ4S0U4nEwgqAlCwTYWGBlxWygR7mVLa8X6ZgzkNxFD8Eilsd2ZPA6FgFFRkA== + + + AenSRiwzb7VPYWLeAMQ8Fk72GTFHMOnr4j9vxKZL9a3e5EmGK3h9MoqahtmEWoZ6Z/g8aBUwy6o5 +oOm83xciqDgvVzA6i9F5xejVe4dnli9OLt6cq2wAF9gchMfLur20P6gQdEqL9pO5eYiDLOVVrTQ2 +TsIvoXwA1TmxiBNJgkzRdNbvESfay6fP3edH5aEhp8uB40hIAZlktAIB3W6jeDb58r/8YH7uwPh4 +MBiQjCicYd6MLqSy66ncqtUsYhwPhzugo8bGMQisD4QW1B2X5OScFiqtrp3INKY8KIezZijWUCI1 +ToUZScEA/V4pGulpZgu4DCFMiLnHLyOYiZMJXioxVtCi2zsX8rUFJVwjxSzKRDHSkNRsBuyeVgwG +RUXKlmpLhfKcHCr5UXXcSQP8grmLZ1fC8QFUiqjVMpXNifkTIFSy5VnFLPsxsdOd3zt5WVDTw2Mo +QZc4tavofVEuQ3xcPg0kayq/yikpj4cQpWSptd6ZOTq/fq4/f7LW3dIjjWi0durU5cOnbh9zUCiR +5KSGILfM6CTL5P1+zQeTiOkYbsAsQG5zoSYjt3mtly7t5GuHUCrpcNOKlo0meqyQgPGCLqWZDE1n +aDLt96rjIz6nLYAEZYpJKKEGODVQFx6fyotlJdQSlLLTwyXz04nSkp6cJPkkmCZ/QFW1cqWxBfZw +3IbbbATFZKF4Y8npYmUjHB1c3wJDYHgkk18YG0dpLqFHWqXWFh9q4kza7RVdbg54MIgbPkRXwv3G +4GRv9nRr4kgqv0zQBbfPgMjA9bg9lM/Pk3TcTAym1y82ByfN2AzN5+DkASxECSlaSLJCVlGb8eRM +MjUvgIIiIxyXHB1HRkf8bgfu9zAEZrqcrLWY0E5JQu7E0cupSHVsJEDiEcVo01yeZQskmUCxiM1G ++31aOjVLURmayzhchNcPNWuaccvyN2dWs83JTGOiPphfPHBk7ejJ/uqOHC/ScsqMdVS1Zpodkorb +XaTPzxGEJkqpkFkxYjVJz8lmPlXsnL98//z2iVSlRwhRSkqGk9Vqf9Es9T1BHv4+l+2ZkYrdgdAM +IA8oHyFTWCp1DmuJGYSOCnIsVe5piaqWKFFK3EeqpBgOpTLNhYVMdwYTwxhjWrfHmbjbx4+Mulwe +GhI7npmp9/Y4JYYTPCuaarRE8oagJZRIgVGSZqLan1me3dwNpSsBUlOMZijcv75PQRge9owMez1u +LpWZjiVB5ED5qFDIieKSGh2AS0KZpB83UdqIpCu8FncjrBcTaSlVbG7gZMpup0eHvUEvzxAmTUYR +RPN4BaeH9yOaqJS1+ABjM0AcKB7aOXJ+eeeUnqyMuxGnn5eNth6dwMj4yIh/dDRgsxNBJIRiYbvD +6oTgdIksD5TaiaZm9XBfkPK7Ry+sbB/LVCdwNmxzE6AQ5EiVUXMeRKA4M1OZZ8Q8xecgpYGjMTLX +6JwYzJ7XjKbdiUNq0Ww8kuwJapaTC4JckpSirBcLzcVCe8mIV+PpbiIzl84vR2KTtjHixhts+/d7 +SCph6A2Pixra7xgZ9rkcgiiUSuXVTHaJonPj4+TYKIKgKitl9o94h0a9I2NBii2lctvxxBJNZl1O +QdHKopTI55tLywe2to+duXD1voc/8OjTT3/qhc9987vffuutd/72H//57r/9+dUf/fz2ex5tTmzB +tY1fXwNGYJEsaN1sq1YeNDsLg8mFtc3dUzdduP/hD9z54COX7rv/+C1Xzt927fb3feCuux/+8otf +ef6VV9YPHNk6cKpYnQIlgOK6HCqqRoXmo6qaLFe6M3PLaxvbx8+cunzXHe977ANPfvITl+5/8Oxt +91576ImPfe4zL3/ja1//3g+/8q3vfugTn1s5cFxUUwimeLw0jsphoxxP1CTFjKcK/cmF5c3Ds6sH +WpMzU0trcxt7O8fOPPHUR37+2i9++7t3XvrmNy/dfs/E1EYi2fR4eI9T9HkUHDUT8V65vEQQpsNB +8lysO1hr9Jdy1alksZerTx04evHytffd9/Bjz7/00r2PPH77Ax+49sgTWqQCUgrgzu1keCYt8EVJ +rgliHieMcKySzNaLlVajMze3dPDYmauPfvDpJ5566lvf+/6v3nzrK9/69oVbr80tHipXZjgh4/Nr +Xp8EEEQzcVCzcEKXi0fRcCwxqLbXE7luItc6ce6WD33qU49/7KN3vu+B+z/w5B33PHj1rvseeOyD +X/nO9z767LN33Xv/8Qu3sWLG6+U9boaiTEWrRqITklhKJLuhUCEebzaaC9sHT0/Pzhw/ddNNF69c +vv3OF7705T/86S//9t5f/vTen998++2nnvlksTgxMoqOjpJQdOHwVDa76rDzdhse8PECnyaptD+g +BwIKSYVpJppON/f2Tl24cueJ81fvuO+hxz/89JHjN/dnj9W7BwQxa61l/R8ejjK69amNlZ3Tx05f +vXTxQ09+4OWXXvzVG79+5/e/e/3Xv3zzzTf/6x//+N0f/vUr//L1pz/+ya1DN5Wam76AGfCFIuDK +pUQynO6Ahdg9efammy9fvfXxxx9/5Wtf/+q3vvPZL734zLOf+vq3v/3ab3774stf/d53Xv3HP/7x +0tdf/dDHP3/83G2JdC9fnO0MNvLVKc3IZjPlxfm5m8+ffOiBuz72sQ999guf/tb3vvXWu+9+77Wf +f+XVV7//s1/8+c9/+T//9//+5T/gSv7wvZ/+9IHHn2pPbpjRJgAmgYtRI1Urt9fW1uHY2d27evvt +H/7o08+9+PlPfOEzT3/2M8+99OJPXvvZr3/zqz/+++//+3//91u/e/eZj3/qwqU7c/kJkS3QeCZs +9nPF1SBiIH7RUFIA3Hu7h+6489rDjz3+8FMffujJp1762jd//IvXfvr6a3/5+1/++h//+Zvf/u53 +v//9S1/5xu6hS5ncLMcVQ1qH5fJmvGdE6q3m3PLy9pGjJ+9/332PPfXBjz372Rdefvknr//yV799 +67U33/zNO2//+a/v/a//97+hWn/8818//8WvZ4vTDhcDnOh2c05rhaRCkHFFLeayna3tQ/c99OB9 +jz70iS88+9M3fvn6m7/5xg+++/I3v/bWu2+//ft3fvHGa3/685/+v//zv3/37juffeG58xdvTWVa +NA16G3U68UBA5NlYuTg9Pbl+9PCZu+5+4OHHHvvyV1/62a9++d2f/PDr3/327//0x7//13+9/e7b +b739xj/+5z9+8Ztfve+RRzv9tXx5WQk13W5r8fP4GMaSYZ6JhI1SpTIDmqTbmz147NR973/o8899 +/rU3fvXOH/7wte9865dv/uZ//fd///nvf//8i1985PFHb7/zXsNosGyZwdVBa3pzefumoyduu+Xc +vXfd8uSj937za1/893/7HWT0W2//+pe//NEXv/SpW2+9sLa2lsk3zFgbQUy/T6KJEE+phqzXcqVD +B3bvvnb3gw+97+FHHvrUJ5758U9+9MMf/+iVr7386qvf/vNf//qzX73+wovPf/HLX7zltruX1o41 +O8uynImFq/liL5OtJ5Ol+emVrbWNg1ur91w5/y+vfPHrX3/pO9/9+ltv/+ZPf/v7a79587Vf/+rd +d3/7H//5t3f//d1vfv8b9z9yz9L6gUiiLsoZQUrIglkp1OdnV06dPHv82PFjhw7efcfVl156/o03 +fv7mO7/90WuvffO73/jVmz//1z+8/fY7b/zuHSiW17/00otXb7tWbc7hmIGjRkirxhJTJBFjKSOi +peuF2u7m6hPvf+Brr3z51e9/97kvP/+z13763l/+/Pf//Mcbb/38vT/9/vU3fvbCC5967oXPHj55 +XjPLIIcArGS1ZEYbkWh1MDE/Nz1//OixDz312Gc++8kvvPC5L375uZ/94if/8T//61/f+9Nrv37t ++z/42p/f+8Pv/vDuS1995YnHn2y2VwLBEBg3p53yuPiAX+W5dLU8V8x3Du7sPfHBxz/9hU9/7ksv +/PT1n7/3tz+/9/e//eT1n7759hvv/fnf/+2Pv3/tlz/+7W9f+8VrP3jqQ49dufW2VLrBC1GPF4fU +UrWcoedj4fLq4uaDDzz4la9+9aev/ex7P/zOu//69nt/fe/td9/59W/f/Nvf/wLn+eGPvvmTn736 +i9d/9NRTT546f+vawYu8XBgdxbxuyetm0QDndqAkKvU6szedOfu+Bx94/stf/OLLMJtf+MlPv/+f +//M/f//HP/wUyu4XP4GJ+uxzn7x06ebN9T0z3CyVN3Qx3ix3aqV6MZ2dnOotry7OzvQPbM5eu+PU +ww9fueP2UxfPHy0VkyFVoAg6EKCQAO+040475nZiRFCIyvFSvNSptCc67d3tjZ0Da0vzvTOnNu6/ +98wjD95y69Wbb7vjttMXzg1mZs1wSpSyZhS0d9HnYQJeBkc4EmVAuBw/dHZ7+2A2kWzlUoc25m45 +f+SB+y4/8cS173zjS78EuHnz9bd/98tnP//0uZtPTM5O6UZcC+VIsK5BEUEkkTOPHjxz9uzVenOy +XG7MdDtbC1PnTmw/+7H3f/fVV9586413//Wt737/la++/NkvP//RT37kvsceuHRkZ7vVmtLDZY+H +xXHdF5DH7eBrUIeD8LpJhVGK8ejB1cVH7rzllReeffmrz7/04tM//8m//OUvf/jC5z9824VDR7cX +uo1msVjFMNblRClShwNBFThIQmEIPqonGqXWxtzS1dOHn3rs3k9//NF/efnZN9748b/98Z2//u2P +r//8a5985qErl4/VqwUUYZCgSuARpwMkjbVEeXw0iAfkqJaPa+mZiamVxfmTJ4/ecvHcHVcv3nfn +5Rc//8x3vv3yl1749HPPfvgzH3v0y8994tF7bj29t5NNVUhK9foZv5/HUI1mIul0L6Rl8CAbN5K7 +6wfuvvOuZz/x0Y88+YG7b7v1mScf+9EPXn31Oy9/4N7zH33ojmcevffms8d21pf7zV4m02n3dw2z +NTaG2sZJFAn7vLzbgSE+Ohsr7q1t3H3rpS+9+NmXXn7+mY88+tTj9z/37NM/+sEPP/OJT9xz9crW +ylqlVGUpBUVkj1dyOSiXPeD3koifJlBO07LJZLPdmp2bX6c4MRAEbcl4fYzHQwcDIo6HXC5yaL/N +MR5EfBKOqkEfTyIyZR08Q4lRM2uEkkEfGvAFg36MoQSaljk54wkoNgfmdtGotU9Bc7ixkVFwtQgW +FAJeGg3wkgImxWRZRRUUMogIJJWJRoq59NRE79CRY8trq/F4HObR4URtDgRMB0hlt5t3OGmnixKE +hK4XGMbEMIljtIgWBjsa0UKZeDQVTxSKlcHUnKmbyXCkV6/XshmdlVAfA64ZRUM0HTOiHZJJ7tvv +BLWjSkWJTRtirJEtleKpVEhLaKGtpeV+PVdORyZa9USswDIKyxgkmQwGNIcNt48HbWO+8VHP2Kj/ +n52saCoh87lydpCOFEvx3LWrt5w8eKCaig1qlXquMNdpzrcr+UQh6MOHh8ZHhz32cQ== + + + dHi/c3jIbRtHAbsCPpnCTEXMhMFmRTPJeE5g1aA3KDJKwijoUjyfLE00p6daUwrHp8yELkRIRHA5 +qZFxfGSccHsVUSzKcoGmzYCfDfqgcsORcBWKWuDS9cbmwuqFyeljshhFPF5TlNNmQuNDWBAAE4Ms +EqRio3tMDXVtNvKG/2cUhCiGhj1ulkQUFpcjSiQdTibMaCaWB/nOBnEeY1U+qUk5QyuaRsPthkqR +zEhLkCv7bnBAqoyO+pwOPOBlCSLGcZlifnLv2G2egOT2gLZMMmyO4wvgK3E84vXJEAEkYN0rGxpy +wDEy6hsfQxG/RBFRTa0KQp6jEyQVtRpJOQm7E/UjIX8gDDFnyCQaDI3bAm4P6fHxIGxwRPJ5aZeL +wqk4LWZFtSDLWZ+P8PsIEhdRhCdJTZDSAVQB74/hMSilfdbmPi9oXb9fRVEdwzWSMlxu2umkfD7B +bkfdbsLlwnFUA48sCjmKijNsGkFUVYrxgjE8Yh8Z8vg9MkXGgNZJOqeZUziRHhvDQAP7fdz4WGB8 +xOu2+Z3jXue4J+ilQnKWZ3QCFQg05HZL4L5tduqfW8udDh5FTJ9HsI+hLmunEm93Ch6/7nRLwHEE +YeRz3b2dE+l4wTHm5DFZIMI8YZAwHMCoIffYaBALhsdGAzfeMDo64sMQ3eGg4YCS9/oVuB4GMj/c +CQZVuCpVK6ez85pWM9UCGVT8HsbvpiY7GwxpANzBqRAii7MVhq9KcgXFI26f5IWKvt78VlZbqjmZ +yG5kimvNiZNaeMJmA47jC+lu0C/tu9E2bnW0kDSlMZg80WgfxonU0H7v+Igvn5pAEX3/kBdm0+lk +kEBIliqp9FwsOumyU6NDbswPpMk77KTPI/l9IQSNgWuGr9P03vBwYGTUMzrmHhv3jI95/eBbiThj +3bieJIh4IgpaaIrlMzSTCQYNBI0Q1rJ2NYCEPX513z7b0JATvtRuo3DEZKkUy2Yg/Yq5hXJtc3jE +PzLigUknmZSkdgS5DqcN+GWeNhv1eZpLjY76x8Z8NlvA75fiqcVQdFJUazQdTyQqupnz+lj4rMMB +gBnyBSK82Mjkd4MwEWNBnweMdBNO5XCSNjsKWecPhnixIPBlm9UYjQAoQxANEDIYDEHE3G4Bx2Ja +qE4wsdExn9eryHJDUWsEmfQGTJzKO1zS2DgO6ed0EvusnQtO+5jfNuZ32lEc1aHcggEVQNLlEm+8 +3u7D45F9PtPjsXoOEETSHzAcdpAKmi8QsjrpjZFjdg5iZYTb8XQ/iGow0vFRP4kYkIFD+5xD1l51 +DMy7z6uGQwO/1xgbQ+Cw2bDhIY/NTkKErQUGWCxkDPTIrMer0HRYM2o4nYDcdo6TI9b69gAWCFUL +qwwVGRvxUUSYYotub8jpVlxWt6iMok+IasvnD2GYDial0joUTS2gWBIjUk6XNDoaUIRMv3cECej7 +97kwIkaSKZ7JaHIxGAiBet9/o8Ntx+anD+F4dGycxIl4AI3gZFpWOqnsGs9XbWOkfZwIBhQojdER +r9/Lk0ScFWqs0JC1HssVrRaUAVkQo7QYGx0P2B2M1QWUL4mhuhmdqHd3k7lpio2zYp5mc4rekvUu +weQ9gbDz+v5WKHaP9/oe/6EgjkZRNBoI6gKfl9Ta8EjASoOAiJJR2ejgXM7hEeDHRLS8vHqMV8pj +EEOfhKCQ6jp4Ipgat5sFfjy4c3J2aRdSKwCwhicoKkeSWY6vCFILsp2lo3qo5POxw8MemItgUCGo +OCfVzPisog0wNJZKToaMGozFomAPhyA6AAvHFaAS/X6NQvVKcZ6kkzCDY6PI+Bjl9Zlur+H2aEak +D6Jr/5AbHAoB1O8g3C4y4JfGYdKtFpEhkkwDCLg9cFVxJBj1+kIjYwG7kwlgKVXvprIzDJ91ugSr +v5nP8PhCIO9JKg7VMTpGsEyBIpL7brAN7QP9oSlKj+MqPq9u9V4eJcBNsEwcrsfvlZwuznV9IYrX +p1otTRCITHh69mi1tRTEdLhymsqSeILEkwSe9Ho1+BSwqt/LuVwAm9ZibF8wFk+vLW7cU2rsuX0a +BIHl0whqNUwL+OPWBiutpofKklAS+BKORVxOaw2q3Ups58iwb2wkODxkMZHXw2taOYiYkKssl7GD +/HACxfDW1rN98JeI3x8K+EM3/I9RuAAsKGOoMTbOjo7zI2PsvqHg/mEUZOTO1rnZ9TMjdtzm4kiu +Kpkz0fx6urIZik+yQn6itXbiwr1BKmL3sHY37w1Eg2iS5RqqMW93K4AJfq9y3VDIFJWiqRSGQUCi +QSwGSIKRGsVHcTaFUHFKKAhaGaPiJJeTjX40tcJLVYBuhksEMGsjmAxSRymghO5HNWBeHLcwamjY +PTTsdTgZSD+aTol8niSBbTHgFIBo4HHAdrcv5EdTBF1lhaoglkW5CsMMh6seL2uzIXAqwBAMTxBk +yghVD2ydY7nkyGhgfBwJBkyCyNB0gWaKGJmE0IHtPXb0cjLdtVJ3HPF7BNBUHF+CMvR6JABVUSnj +ZHh41Dc6FrQ7CI9PxMiEHGoEUJ1mU3OrpyW9duN+9403utwuEUHDGBZTtXo0NuF2CeMjAQLRKCax +f8h//QjA4fdHNK0VCXc4PiOIBY9PGh3HHC7G7RUxPAlfXaxtT62cpznIMbHV2SjVNgMBfdxGjY7i +tnHK5xVJXAfGHBn24kQ0npqPpuaDWNzafuVVWaWWq+91Zk4KcgnAiqAKEHOKSbtctMfNOGzk9Y1+ +GvD7CKg+O2ltMHELSFAP+BS3kxu3+k7QXn9oeeW8ImVvvNE+OooCiipSC0fTGJr0eIAu/S4nCycc +2m932DHQKlAUHp/GyjWQKMlkTw1XxsAfBbUgGcfYTCgxTQoFlIorWnVz4+ZTVx4OkmEENyWtboan +IuGpRGJOMnrD4wRNRKf7h0SptH8/wAgJmYyhiZDeHcyeK9W3YrHa0RNXaalA8plYdjpdWcvWNgrN +nXz7sBDqYFQsEak//thHB4uHoST9ftHnl/1Bg2aLkdg8L9ZdVjd4DUDDbzXPSaF4JohlCLKghXqa +2XV7hdFRL2KtCLJ2Z/iCBorF4aDprCAWc4UlQciaRkUPdwKIwQkl2ehySi1IJt1+ze1V4WpBNV3f +hKvSbN4I92gyCUJR0/MBRA4GZJIIQ145HWwgaOBEDOQTSkQJJs0IOaBgqGK7nQD1bhvHKDJBMynV +aNWmTiJMetRmdckAkAwiGmgzSD+3VwbGoUBtIlDa6I37PEPDAUgPr0cjiALP10Cf8GKVE8okk0GI +GMVlQdx6rcZTYYbL8UrF7eJ4OnLl8gOilAbQGB0N+nwK0DFFxnHcBK3lcrEsk2KYBEGE4WLi6alU +eVkwW3pyihEKGBEN6Q0UDY+OILZx2u8zMCzFsXWBb3s8xriNxRAzEumC8gEtDeMaGfYPD/nh8nA8 +FzL7yfQ8WAwb2BZrNxkX8IWsTWF2wes3eKkSjg9A04p8UtXidoff7sScLtZqIBO0HrwCbbl8IiMV +MDbpRXU9MSWZvUhiptU71po8HS8ssGwymeybiR5BQiVqQVQB3B6x4XDOWnWdl6w+OcGATlrRi4li +oVBZjSQnstnJk2fvpuUco2SL7c364Ehj6kiusZkqr5NcnmRi/fbyS1/65vGb7/L4BRTReL4giLV4 +ciVbOMBwFUWpWUWKhK2NwGiaFduKORvP7tS6N5nJeR/4TUTR9VoAMR1uwQ4OFI/wUgk0G8lkVbNb +qSxevfWR6aWbXB7wPgUjMa3FZjitq5rTZnQBlInHJ5Ns9noXHdPa4+AJuexW6wCfV07G+6KYh9y2 +2WgSj2hqmeZynFSVQs1SfTNdXAliptsDqIjZbQToOkmtxHILmcYeKVZYuSppHdBvDgduPSs0mvDB +cGw6npiFVBmy2rkH4VsAARwOsCp5lisxXJFirYY2tFDm1RYjVaGQ7deb4aN4AkYkq2XTqE1ObKCo +DPkMYCXwIBVSkGCjY8jwsJfnshybhG+02xCaNBOpbiTVI/msFu7TfIlmciG9RdEpq5OV1TU3EQiG +r3cD0BxWE7m4LJbTqWngBZ9XCgRUJ/D4CEISKQxPkXQGYB8wDWjF4xVvuGFs2Oq0A+IqxXF5US7B +2IFwI+EW+PLhYbvdDkwhwqS4APPRKHglMzZT6RwNRXpmcsCH6pLZliPdSGZWDLVBXQyqK/ff9dTE +4lHQ52BeAmBS/KoglVW9pWgtu5PyOCkMi7rc4tgY4fXxINTDiUGqsJzILxC0qWjZam/TWmws5ay9 +BtF+prjc7OxOzZ3cOXqNEWJ+hNf1htU3VSjDVQUgbfCwEe1Hc3Munzw6hoWjc42J083pk5HsAskW +/FjcEwAsKmQLC6JWJdg0xaVZAeRrTTEbwONqtBHNdOrdlWh2gGFKo7U+tXKx0j/BSA1ObsLhcEv9 +zuat1z6YyQ/G7SToTwQtoWgxkVjOFg7GkguWiuMySqgKMmYchKiTMuJTMwtnT55/pNTcQfDI2trJ +mdkjUOMcn8pWl4vdvVLvyOTSpZXdB/PVw6BCScoUlDxGR0HFAW9iVM5hNb4QHU7a2h4+hvp8QP26 +x2tt4QwSKVZtxcpbenolSKSDmKZoZU4qAo5RbIaXCrLRyJSXtXALNAxgC1gzu532WCscaL9f9vnV +sXHMbgd3rDhsQQ94aiIMLK9HB+HkHMmVCKYgh/rl1pF0ftPhFIaH/UEkRrMljEjzQgmxpHKMpCFV +yoCEJBmz26ynmVbHHh+YuzTD5HWjDQb2hhtGbWPI+GhwbCQAUAbOgmHBiadpJk/gMZcDOFpwWHiO +gMwjmTQnllKFxWR+aWry6O3XPmzG2jSfydW2o2mYuFa7d6Q3OJ6pbDh80tgYSlIJEngTMQW+SNJp +K53GIaUzmcIsRkZhvDyfUc2WER8kistaZEJRSpMTB67e+xGPX4IQJfMrBavwlwqNrXx9K5ycCSCa +JAEltewOsPYkhkchwWKpxcUDt7ZmTvhR0+mgcDLiCWh2FzdmJwBkeKWZKm4vbtwWjvXMaDdVnEMp +c8yOILihR9tzGzdduffJM1ce6c4dZ+VcOlbZOXhJCTdG7RRCxhO52WRhgVPaqfxyf/qAEsq7PWqm +tGNEZwkqJ0oNXq55/AoQbrG8VGttwlWBAQeJLmk1OVRnpYLDI3r9Sm/mULYy70UlI9rszh6ZXDvd +nNoptbejmTlWLjBM9OOfeun85XsRQgNxaETni50TueZhSe3Z7CzMUbe1urVz5cZ9YFpDgtZN1Q80 +Fs62Fy+E86seNBLSy09/4osHds+P20hwtXpkUOke2znxYGvitNU4btglsFGKSoyMoeN2CjKW5qqc +1AJ3BjbB46IIXCepmC+gQRUXWnv1qZMLu3etHL6/PXWKYfP79we6vT3d7DqsVqsofAVEAGiiPX02 +nl70WN0/BNCrHAveRwFnAXrM4TFA0AZQqws3qPch0D+jKBY0An6VwOMgs4OBCHCl3w== + + + B3peB/DEcRWm0gnJ6ZNQ0gSPE0lOFRurKBVmxUKxtZepHoikl5q9o2Z8xmqHa6cwRBGljD8IkZdc +VgNP0WbjvN6wCpZTKABgCmzGCFcDqOQLiteXgaXz1fX+wk2D1Qssk+h2N0uN1SBpgPqKZmb1+CQt +VPKVjXrvsBmfAJXCcoVkZj4cm4jEB3q8z0g1PxJlWajc+NCIf/9IwOfXUpn5RHY5nl8zEzM4GQOw +ypYXBK3kC2qCXAECqjZXDp+87czFBxY2bqKEVKuxcNu1x5JZq7N3rrx1+PT773jos1Nbd4nmFELG +YGpoMp3JLdmtPm9Y0OoTaLg8EorHNLNv9QewOnKzwWDY7RH8iImQSUlvmvHpdHlFNeuN9uLhE1dV +vY5TkSAm42wa47KsnM9Xlw6duS+Vn7RujyB6vX8SaFTWWw6X5HBxgYCSSU50ujtAiwgSpvg8LeQo +vqiYk0p0Ilma788fv3Dtg93Zo8OjRBCLhiIDSWsTdBo81MgIBZAiiwVByNy4z+lw85I+iCTXZX2g +6BMgh8Brk5QFlUFU3zx85dwdj64fuXWwdN5IzALUj4yB96Gv3PnRbHERpGYwGNWMbiAYo+h8KrcI +3hbqyOflcrmByKfANt4IHnCMJPlaOLsRy20ksmsYmvb7dEVpBP3G8H7X6Ah2vQkqAV4SRJHLZe0A +6g42Qc3CtVmDRUOQG2p0RjSshcGQWqJRx60lamlB7bIy4FgZR8MsFSEJE1IIAwhFUiRRgiOIZIJo +CmDW6WQrxaVUfmB11RtHwAtzYrXYOFAfHM3WFg0td+H8A/MrJ72IHM/OLmxenV65XG4dHsydnVg8 +JxmtMRuhhppgdYNAuEEJQopTRVHuQj5wcnEYQNh69004ZDRJNoNSSYoroGSal63dkRSfpfmcEenR +bFLgE/XOemvqcGPqUL6+uLB6ZnL+uBKqGZF2rbNb7x5oT+1o8QkPErPaPruFiNHO5hZHx4mRUYzl +S4oxIWsd0EucUANA9rhFgoj5rRaUGM0VIsnZ7tyZSudIPDOrKPndvTPv/+AngTchhghqiGq31Ng9 +eOLec7c/1Z47Banr8nLRVCcU63sD2vWXDeHjDjaIhMGYBIKmx8OzfDZg9SXG3V6NFRvx7OLOiTvu +euTTZ+98OlZctblEhs9BKLyBEMwUsBiGpgShxvE1MDhDwz6AJj06S1qd4SUwQTB3QNYyiHY8DAgw +Mb3bHWwlMpNmYpYWWwRXovgyUEln5gJCpOwOQQtPilrN6q5gZz1ezepvP4wEglq+uBTwS/tvHN13 +w5gbImBtgp5ipXoAjQyN0C6vAa5qbNS6A+Z0CC6X7HLL4KEQJGK10cYi6fIyhYUz6QkMN20OEoYQ +y61rsQVJ78eL61BHwLaidZ+qgdNZGB1ofoBKl5NzOXmvWwLbAmH3uATQpZDq19sScrredFntqnww +ETYnC1dC83nRemVGJRKt11sbIb3OsqnJ+ZPTq2ervW01UqPYKEqG/Yjh86mKUsFR3e1iQBlK6mQ6 +f7DSPDm5cDloNX+maSoRMlsgjZxuFuy5HyyD2tWMPqhfVsi1e5uN5hpJ6FhQyhVmlrZvOXT2gaNn +77t630er3T1BKF88de3eBz7Iy9kAqgfwOA2WIbPSnjg5u3gRQdP7hvzDgCF4UgtPKFDISBSq2z5O +gdgGL+ax3nkkyqGWarRlUHdUEsNjAp/NFecG62dJvuDxqMXSZqN1Ip1dnFk4Obd2lhELLjcf0gp3 +P/yMGumNjJBen8EKoMn7JFN0exWQ+kAfRqQLDs7hojm+EE3OJnIL3enDJ26+b2XnEiNXdL116vQd +4Ps8PkXV2/HUbDq7lMyssHzTeh+Wg6TICAgt4LXhEdDPoVRhpdrfSxaWQKEhqBaLt11u1uFiILWg +CDaO3TdYvVybPEGw+X37g1gwcvymB0k+BYwACe/2hX2BhKROZIs7udLesHWPy+l2EQQZGR4JXH+5 +m+AFt04XtfAMJzbgGx02NBiUwCY77EwAiRA0+Nn63Pq5k1ce9cCImGQgEAoErNVritFSwn09uWik +VzAmg2ORQn6eZsF6yxzgPJcTxBLPA1KlvB4JvP/QkGN42DM05Bmzup0T11uWCV63iqNRDAm5XRTP +52S9HstMxXKzpfaOHpsALxyJ9YxoBadVktFI2uD5NCdkVa0RDk/6QNa6OZowETTkdFEgUFkmTZBW +iz+/32CoLDhr8ERQ7F6fBOAJhDVuY4CaWa6YTM+qeg1FVQJTQ2ZeDedixX5jemdi4USxspzPz69v +nMtXZgg6Go71s5UtXmtFUnPp0qZizPj9iUAgIkkljs+AuHKCN7Qz18VDiCJS4C8oqoAiJqjr4VHX +viG7zyfpRjcSmy9Udhd3bgcNpiqFzQMXjcQA4Mvl5nzXN3dQVCYc6ZUa6yPj1NgowTElQEW7kxka +8cHhdHMsnw+ZXQRS3c9D6ZFk1O3mQch5gorPWgWabXUOzSycAM8liNlGZ5ei016P6LDRtuvNvR12 +kqIiLheF4rrXHyKprB7ui3AxZpsRS6xcbvV3OSHHsPFmZ73W24bfIFTGEwx5A6ooV80YOO51q9EQ +GECtacbmjch8IrcsKk27Q4Xcc9jpdmNpZnrbahM3hnp8KqfUEqW1cvuQHOoMDQeNUDWb7YyN+vbv +cwIagDAIR7uinIdCcNppr1eDg+NzrJinmAT4slRpI5Ffbw7OpIobWqTjQyQtVGm092StFkQjLncI +TKvLelkeabPh4+PY2Dj6z/cy/LMbHo4mEX+YCIajofL8whGciTJCqjl96OiFDxy75fH2wlklOkky +CV3JLM/tLCyclpSKxye4PHzAetpookgobFRRRHG7CVXOyGIGDAuKJfzBpMOpXk9gzGk9syNGRgAb +UUBRcDe8UOe4KvgIP6KyXKLWWZpeOLC8fWb98OWNvUu7x2+fXjqdrm2gVLRcmtneOsfyca+f56W8 +pDQppiopPQRJeL0qcDGYa79XCfgNBIkjgYgXJJZPgiCzdJqXijQblZVsEFUxIoJTKYxKcUpFM2q1 ++vKJ03eJakkQc+AsaDYrqeVobFpV2xSdBTEcCdfLxQWH1Qfba3dwPr8hiFWWL7JcHsfCul4B1IV/ +BR0FljyRWWoNjnVnj2/u3QH/D7Xfbq+ubZ3/Z3O5YEBFraU4VMAnMkwMQ9RiZZYXMwBikHhQboJa +ixWWG3Nn13bujMX766vHvvqtH4ejfZtdopgaeIp8ee38lcfO3PKEGOrtH0Kgani+AN8CZTVq9Rik +HQ5NVnohcyArlYBfBuHkdrFuN+dwsXY3N2rnx6wXeSia3uKlrNNNgYl2OAibDbVZa89YxFrOAbwf +w6ksr4AzqoDhypaXItnJWG4u3zxgpucFow0KudXe2Thwp2o07FYLbqv5CUNlUDTq86pAiMCSVmdy +6+VolDV2j+Zzy1hACxvFdn9Fj9SrjaWFA+eztflsbSmaX2SUFkomzVB5a+3M8uoV5PpLNNweliAS +HF+mmLQoFgkyLgqZXG4Sx3Xw2j5AD7rCsDWSzjmuN3+2ZsFOQo0DrVx/Gi74/DrFJnglD/Nbqy99 +5KPPP/fK96YWj8JvADaj6Zn24HC5vj7R3V2YO6xpWU0tKGpFkiuK1sKJnMMuDQ9Zr1gaHQlAarmc +7Lj1DMs3POQeH0Ps4xiGGKFQs9vbXVg5ZXfRoGoC1ov5DEGrpPIrmeK6EmpguNHtbpQqi16rSz+H +YaBIrUdgYMyz6X4xPzU67B8bQTA0Av4uGNDGx0mXC2pKYZiUbjYgMazbg0RSlIvR1EAxGpxQYPky +QHe3sz6Y3LXbGbgMiowCk3pcXNAvkbgZDMjRWJMBjzziRQKgeUxOLMhGUwMAkYoYqmZTtbNnbwd4 +ZLharrCXL+3qeieZHETjPZzKgAiXuGwhOwVlNTTsuf7OgiQvTCws3zW/foeoNEZHcbAMwOxeN3Pj +Pvs+6yUanNOl43gWDBdKRQKY5vHy+/c7/wluNJeJ5xfA9IHXjuVWwskFis0nM9NGvOkjZCVSL3UO +tCePbR26dubS4xfv+Mju8fsYPs1yKZAZgQC4ztC4DR8e9o6NBjxuQFSapJIuq08OA1TidXMEqqKY +ImipZnf1+Nlrg6VDPvgRyDG3XGocBtRVtKoZaQtKzeWVCCaJkRF/QAVIp5gCL1Qr9Z1GB6x622bn +UGAWGlC9TJA5jzdkcyo2l3L9BX8ihoehVN1uBurF6+PMaGNp/fT6zoVSY2lp7fju8VvUcInh4ma8 +p4WbyxtnOoNDKB4JBEVVTa2unshkevApcNBeb8i6lxiI0VQq4FP9XmlsNDhuNcqzmj3CGMfHgiAJ +ItF+IjUdTw4EMbW5dbHZOYBQYS5ULXWPNqfOJPLLmt5cWD5dqS0DTEFAYompWGxK4AtAjg4nNTrq +v/EGu9vBIAELk4eGHaOjiN+nBgIq6CWH9cSEJ7CY0/Kqfn8Q+DQFOiFfWgmFrKdXcD0kHlXlgtXD +bdgHcOp18xii46j1jNs2HnQ5MBIznE4AdnR0HAM5IXIJgQ2LQoJhEpFY55bbHts5dNXrUzEswfNl +4PR0fhkULI6IDKVf7/yM4XjMuh3KFDmmYJigwxMOGyHy0bBeAoVzw412r9+iOVA+Y9absFCbnXB7 +BeCd0RGf3Y6BUAGUA0fj9SmU5bbiGBmj+QKUXq6yqhn53aOX5tduqtTWuoO9ufWb+gsn47l5hkv/ +/yS993dl13kl+A+MyAoIL6ebc873vpxzxMNDzhkFFFCoKqByjiwWWQwiixRFUaJEUVSgkiVbwUGW +rFa0pGlZtnu67XHbnjU9PWvN6p41v825pbWwsApAvffuPWd/+9v7nnO+L5sbyFrx2c4cGYzAyRPu +jiMMdiuDqSqwLblaYzOGmCMjsUiYI+lUpjy/fe7huZtvdsZ3b99+/e7j98xkHyWSOJnFiDQn1qzE +TLVz1Ju/baSmGDbVaG7l62ua3RHVBhDSXp9b31hR+sB9HDsRPHY8eHIEw5kaI4+hZOFZmT6BprKZ +wgJB2UBPpjJj+wc33/7Ml85efpiuLmiJAcOX1rbvLG3dEPUShCm61esNTperi4bRyGZ7gpAA0wGc +L0GmgZ7x+d0eo273nLDqVm9AgDFUThx3WSvop0ShqGo9ki6jWNqyqsurZ5PpNsFYVro/tXZ1/cyD +7uxRuXdW0LvBkJhPTVy49gpC6qNeJORuTgY23y2g5xulobAqsbmZyZ31zWvHjwePH/OC9wdJULMH +YEBQLAG4q1KeXd24CrxwDNIJCoRznCTjKKRqGmD1OKBxhjB5IRvwk36/u3PGM4KCT4mEhVhEHB4K +QDGOYeLADQGkFUoTC+vnZ5YO47n5WmsLMBXDZuZXr5BkJhAQ3Pr/XtrvZaMxk5MaJJUCMTUyHAVM +CHAbDQs4amIw0D8o+NCRoRiQwQwdP/a859jzI88/N3LiuA+gGuRoicvSuFGrziaAcQ== + + + 8GGymA1HJZrL8VrTiAOlvdQaHNY7WwuDtT//q1/unL0NPKOo1FKFGTs1CW5cNSdxJhOOCgzpLC9d +ghBz6KR/dCQQ8CN+HwGYEKhKoGZ5IcUJGQS1Ga6oxbv17mpv8lS5Mn3/3ku3Hr5uJJoEm09mVxKp +xVprb2n70dTC1fHp85rZTTrd0/s3BS0ZgoG1tGJwGuQpWe3xUicc1X0BDpgy4FBG/eKo2wgMBRYJ ++Cw7MWc4U8Cs7e3eGBvfENWikRjLVtbrvbPTSzd3z758+eH7tf5Oo7187tIDMzWlWy1ZrVN0Bvhi +oIoBH8pSOxwVvT434qIxQxS6qjoODD4EWT6vW5OZoXIeDyCZKBCZsVjSrZ8ZVdzlIS6vWU1aSJNM +HIxVFHZEtTm/fHkweRpgo1KbxGmTE5KGXgu6kyiFQlrAL4YDKoE49fJir7t14tlDJBiWgB6AsTgl +VCihDEKvP749ObXL8TmWBYmyoupVQSxQVFzW3MpIOGZXChNgHn0+1OtBAKIwGASCEQkJ3hEMcJpl +lFNJ9zwOS1q9iY3d83d2jx4bqTmcLsXgxMrKhT/74U8KmT4QkD4vSZEpgasJQpsTGqGwCGSGLBXG +pg4su+n3YQBO3mE06COhiIBEJVXMEIQOiJ2hsqMjbpXdEyeAm2DgqBry8VBEA6k/7nQfPv5UIEhh +hEXxWUFvmpmpdHkpW5xanD319rtf6Q02QaJvdE6BtOikpwG0KB4kLyAhGFstv/b6VwWj+vzzQydP +eIZOhkbBHflokFlYyhmrTx1eui8blShQBUKBkXJmop0qDFoT66X2AsEmnMx4sbEpyA3D6hvOgObz +ilbnhYpljlUbS6KWSuQagtoIhlWQFGDM8AVF4HxJMieITeBwETw16uePn4wB0RWBLVnvUmyeY7Ob +61d6/XVZr9jpyUpntzdztLR56+zFxxPLh052YmZu70vf+gvF7gJ1BKiMEytWoq8aE4I4Jik9GDUk +uVRvbfFiyX1KE5D/WBEUfOF4lmbKI+5yNj40HAUYC4UlcBmsWE9kF5pjZyQNzEt6ML5dLC9STKbb +3xifOsUBlxSVUNwBDkjgCz4vC9QgeNtwWI+EtIifA1ke0MXwEKaqNUnO+0AW81Ci1unOXsw3NlWr +G0PtKKQ3WitWvI5gFkakLGc8U5g37YHAg/xoAkQF/BRJmMEAFXAX2sxoRPa62yEk8tnJNZArRSEP +3txKdmdWr6zu3t3Yvbdz5uHOwf1Bf57CgS3VSCLh7u0Muz2bMCzl7tbAHNNoF4oLpl4NeHE4ImGQ +EfSSaEzBIDUcID0jMEnkLGs6AlIeqbkNpI7HQn7e7wP6JA2EK8+XHLuBoCpB2iiuc0IunpucWDi/ +fXBn++DhxNoVhHQpd2LuiFNrGIgUKoviKZLOMUwa6PPB5AZwjseeHw14iGhIDfrBbdKhIBOLMJV8 +Y/vMFUpKhmHNyc0pVhu8c2NqL9PaoqWyIGQuHN5d374ClBUMA94o2PGpqZnzi0uX4skpXqo0K+Of +/dxHrfHTzz/n83ixEGASyLad8UZrVzXHI1F5c/ummegcH4qMeokIyDKoW7NOUGrx9KBcnl5bOzuz +dC6KKrwKhrSj23VBK1SaS/uHL1y48ylKAEl/Pl9fx5lCDDYRPBGOmaGou66dyc9ni/ORmHByKEaS +KdNwPSMci4dC+tAwNTxCRKLiyZFQIEQiqKHbg3hhudDYLja3gWvOpfpP3/ro3JUnwZCgmnUnOzBS +A9XqAd6OQWokIkhipdM7QzOlkRHCfV7tPhtkTpyIInBC07oT45v3Hj6l2SJQkrLe4tVWFE0DnZkt +r6/svqA7rdm507fvv9Ue2w6GZHd7ZNRyC+8jNo67633RMEtiBhDSgaBbIntoGPcFxAhka9ZUubaZ +SHYGE1urp2+fufbqmWuvbJ+/r8d7oZjCcJlyfaU9OA0AIKsl4HYxPImgLlH7PEzAxwW8FKCpYmZa +lavHnvMMD0XDITbkrhczoRBQhiJN5zZ2bgZD0ic+4R8exoFOFuWObg3AfB07FgmG2BgsQ6hM0I5o +VMrdrZnNm+3pi5ze57Sqk50qtTdRPG4YvURm3snMJnNLstWBCXPU5xZEDfq5SJD3eQjAiidOhgES +IFiNIXowKvnDrKSXZaeKsVaiMDG5cqXYXC/WV5pjO9UWMFMFoJ8h9wBLgQXuG4/jRJxmU7yY7bQX +rl5/0bBbJ44HMMxS9SYvlmOw9axqXxwlnFR2guLTgEC8PiAgQWKyBLkM0AtEYCnf2dw805tYhRA5 +X12e37y7c+6Vrb0Hkwtn+zP7drqfdFrvf/SdR2992W0uhtj1zu7C6r1SZb9U2dPMfjgqj3rgZKLJ +CzkwR8dPuEWeRz1iMGyhRD6Znrx+58m9x28D0+oNsMGYAuEJXqnV2+vNzn6lcw5l8gB16fIc4GqE +cHAyg+LJKAS4V+8Mzolaw+OnYdQCfvyZilMBhgEBAsmK43q2MA5kVTAo8kq12Fhvjx+snbo5s3QB +aE5JTN299fg7P/hRu7fo9XE0XQIsyrJVGHHAtAaCPMfmcNweBS47zHHPxooRKqXWzvLuC/nS/Pry +/hc//PrS2uHC1rW1cy92Fq62Zy8u7jzcOH1re+9mqbFSqc798K9//fpbX0QRTRFLktQADEYTSVNv +qWItGtaOH4eBYwVCaOik65ePPec9eTziGkkoKWk9Qa7nC3OSUqb5gqi3ObUpGj3VmQyGBV7OpwuT +7f62pFcKjdWx+aO5rZtz23cn1m7lWjuy3U/GBxcOX9o5c5/i8zRXLtQ3MuU1QZth+fFIxPJ4CGCj +/H4QL9TIs21sETBruAMcX6ownSxOVJqzm2dubx3cObz+0uLWlWJrg5ZqCB4HQoXlChCkBINUJKqx +XLXZ3etPHiWzcxQHJDoXA3knJgNjBYIRB2wptDRzPplZFpQqmFl/kMFJOxBk/AGSYhKy3kjnp0q1 +OfBdNeoUZZXqS63+TrO3kchMZ8uLucqCotcSTuPM2euLGwcwqsVTk/naQjw7rpgdRqgFQhIIDSQm +nj24VSrNgPzl9fKRSDwWS8egdDhqZnOTN2+/MpjcGh1FSTpjpKaTpZXe9NG1e59+8c2P57ceokS2 +XZ87d3iHE1IAY7niytj09eml+5XWBd3uRyEZislXLj2q1tfcPcweErhpCIkDh54sLFZ7+8CqdFpL +k1PbgM9xIsmIZU6u5YtzkwsXat3dRKoPaDOfH8hqZcTt3ot4PBRO5SW1qxv9cFjx+ShRqZRbW5xY +AmqcZFK0kIUQVVXLpcqsKOfGZ88eXH293t/NlGZ5uQiukCLjptU8e/HFtz77jYWVi8BYqVqfpgvh +kBgJUd4ReGTILWg/PEQZ1jiYiOeeGx06GfOMEgEvsAwGyZTB9cdiuqbUQDpGiUR1bHfz8MnZm++M +L14F1qPaWl/fuXv1ztvTs2eu33tzdv1Cqjo9vnQEFFO8vGYlQYq5eeXG06nFI0GtG85EqbmeKy/L +1hSMpf/YbWHoZBRDLRTVQ+5OWgrFbUYocFLJyU4mcoOd/VtX778RL/QLzfnONIjuU5nKWr17bjB7 +I19Zj6EajKq8XCW5vGJ0NGdS1Ce0+BwrtTEsHXHX3WicTOBMPgRZMJ5zS9FSmYDb2iCu6TXYfbJK +PDt4Pt6ZOD+5eKnQ2KS4kiDmehPbmeIAp6xEfnZ2/frRjafb519KluZVu45RKsvaC0uHsp5DCJWV +SyRXdGmTSZGYXSpM2HYT6MaQWxXfbc4CCDMSNeLJQbm6wLDuqQQMA4q9LqoVSS2Vm4tz65czlSUY +s7aXz7z+xmctq4TjVnvsXKt/vlTdMJ1pv/t8BgMW7+a1l9qdtWG3yaxbQ1XWe+nCSqN/ttzeoan4 +vTsvX7l+z+vDQKzlKuvTq7eu3H/v3K1344XVSMzAUPVLH31je/uiPyT+scOIakw6qWWKLg0Pw7Go +2O1tFutrox4iElEg2N1vwEkVOzltxAc8n7l17/XHr33OcboxSBOkqpWYKFSW105dv/7w0/3pI5qr +kmRWlJpBt3l0+PnnPeA2vR4asCtOFIJB/fixYCwiZFITwE6ODgP7wMQgB6TFQFChySzQdWD0ZKNZ +aW02evskV5WVYrt/ujt1AFLG+cO7L7/5fmuwYab7h9c+effJR5tnX11YvfPq02/Or99W9HYpN7t7 +5gU73fUF2VBEBWqNY+KxKBdwuxHJSaveH9viuHQoxEKIxsvlXH2t0t+dXbs6sXykOfXlzaOxuYNc +cy3bWDfSM7zWoMSiYDZztRUjPYjiBsamIXB3Rj9V3YbZaiBiIWSOVRtOdhZnsqxaYdQmzlRYoUoy +RZJ27W0oLIDQIygbo3QA+MXtB4s7D/pzl2q93WxlGUx9PNHaOLhj5waJ/NT8qfu51inZGZP0GnCs +K6uHCCYHgnSmsKSaYwyT0/QmBJnBIEeStmE2GbZ47Fh4yF2bE1k+XayuqUY7EtECPsa2WggCXouG +w1SttXT74Vt3Hjxd3LiczU1pejUSYVBY4rkscFsjbi9gmqQS5dpSuTyfTPb9fvLEiRBwPRDk1jDB +CZPlMjhpkbhWLQ90IzsyEgHafnb9ytbho4nF88n8HE4Vo1GDZeKffOvTc/N7/pA06qHcwjJuewj3 +CQyQcxiqV2tzqlZ5/jk/8KEEnpaUhqi2Ra3rrqpb9ZeevHn/haccB7JnanL2emv8fK68CMjQio/D +cNzrHgFg250dAneGhxEUdli2RlNZArOhmHH8eCToJ8a7yx98+KeeEeQkQJ2XBopCVjtOfCbh9FhS +n5haF6UsyFkkU+e0Po6JlcZia3y3O7nbHNtI5Sc1o1Zvrqzu3VreudCd3MgUZ+MZwCRt4Hkts9Ef +nJLVqruVhc0xdJoiTAAttzJAVAD/Zpmk348H/ARQhqbTnV25ev7mp9b37vdn9pbmt3/y1z+79+Kb +arxjpqfKnb1UcaXY2F7aunvx1lvzG9davc1Hr7+vOP0QZNrZ2XL3dL1/4dThW6cuvjG1dqPT2fz2 +n/3s/a/8IIravqD8rEeeDBNpyRxPZhfrjaXbd17c2L/RmT2YWLnQnT2Trs6Nzx/MLl84f+Xl2y9/ +Oluer7fXbj5898U3vrh38fHY7JGTmWKEEsNVBLkTjABupECYRyHgj9K8UNOMFs3mGbEWihgcX4Zg +yR9EYFfUNSW9LYhVFI2D9CQrhcnZM4pRSWWajeZ0rjSn2VMUVyPJAkmkgfP6YxdpAIlYTEGxeDAo +DA8DK80QeBKGDJDuSTJOUnGKTohKSdGaQJWNerFwhMOAfYOAeRclJWvH2/2p/bmVK6pex0kzhrhn +Op7tuMMi7sYqk6YzmtWFYCMU5AI+FjBtwM/5fVQU+D5Iq7TX51Yvdif37NQ0RmX8AVaVio7dQVEL +wAxFE8DuaWqDIpNhgE8i/sdTWtGQfPJ47MSx0InjQfAjCqs44q6gEYRz/Hl/0E97PQ== + + + uNsecSj6bAmGDvgIjkvhhA4iJZmbSRWWeNbIFSbKjcX2YKfU2jbjfVHMA+eYLU9xksXwimLkBbmQ +Lizla5vA6wXdDa66LNVEqfTsjC3mngEM8zjmhAIsuNmR4Sgwwjhu4oQlKMV4brrW2pieP7u6unf9 +9gvzK/ut/tbu0csrOy+cu/LG9v69anNRtyqW3axVZ48uPTASwC9MTyxcXNm+OTZ7WKgv2umebJXz +2d79h29cu/8qhFlmfEo2+ons4qnzr2+df7VYXZwZX//e9//q9uPXzWS3UFvsTO9MLO7ffPGtL37r +L775F7/47Mffu3j5xY+/+t1PfvqjeH42npvVE9P56ubs8q2jG59Z2XlC8xWByw6m9kEQhSJKKCxi +pAPMoxaf6c9cddJTQNSNjS+JYkHV21Z6XLaaQEwKSqPd3z9z8TVOShtWwXQarFxrj58dn7tupZZh +JI8Rec0eSHoHeDdFzgA8gNwaDmn+gOSuKXgZis6Wa2ucUIjEFKAHppeutyZOK3ZHBCZRKUIITzAm +jMnRGENSOiukOLHAywXFqLJCLhRmOCm7eupquTYHtB8vVaGYCtJHNKIKQi0Wlb1eHJAAgFYEkiku +rTqDYn1XUNo0k+WZBM+61lJRq8GAMDpCUFRCMxosXwb8BmRkBFiMEzG/jwU6BwaIDUkIrPu8JNDV +7s7AAE/iDvjR6yFA7Ix4qGAEqBqb4rIEkzScZqmxBKNO2imls11OTNmJtuGMq0bfsMYy2ZlUbpLl +TUmyVLNAUJZmdozktGR0QBqi6bxjDZLJcZ+XCAdZBFKiUaBJ2OGhyLOaQhE4pgPfhyA6y2cYId/q +bp7au7N/eK/aXeKkpJ2ozy4fpvP9Yrmfzo0xfAaAUFFqqlq37DYI4VxputpaltQixRcQ3MIoW9Hy +llnOFyecVNstAlkFeJsAUTA1d64ztp6OlwetwePHT2aWt3SjODWze+Xeq3dfefvFp597+MZn7r72 +9ODqvfnl7YePXjq6+nh69uylm29OrdycWb2zun13ZvEImFaCiifsxstvfji7djQ0gnq8BM1mRK2V +qe60Jw4ZPi3yyU+++Z5hVIFAiqKWDYxza3vt9KPTF59Ord3mhfTR+Ztvvv1BZ7CN0RlBa+NcheSb +Y5MXzlx+uzE4QDDj9u2XW701X4BzW6IHJAhJEHSx3QM65IKq1ScG2wtrVzvj+9XuOq9VYCzOiiXZ +bFS6G4xUDEdZcF80l+CELEGbwIAQdEqzWxOLFx88/Vp/5owslw1nLOYeEqHcJd2g+7wLWIZ6a53j +86KYTmXGRK1dHzunxacIGlgnQL9VQayDdBYKKQSRtOKdZHbAS2UEc9w2eaOAkaJgolHMARzrHiAa +cTezjbjbCN0Od0DMnzgRg2HL7T81hIQhQ7W7VnpKT/RVsy1prWBI1aQUSVv+IIkSGitkk9nZbHk9 +XQIGsCpK6VS6qVrVSJQ37W61s1dsnKp1Tj8rSunW3/N5UFMp2WDAg9TwcHh4KAxIDHhhEgcJOs2Q +mWZ7DadtQcyYAMntVTXe5ZSCZrWqQLKyTijkbgSiuUomv5IpbahmH0EsGFJ0q0Xz+REvGY0ZNJ0G +0eSk+qJcRlArGGK9XowiLaAKAkF3JwmBqSpvZe1iPtMWhISupJuNqbHJpebYVLbQU62Knmqly1O1 +ztz0yl6xvjg5uXn1wdOZjStgJFW1SJMWAotIlMo6lVM7V0uNeaCfDb2XSkxb9pikNGEMZHxMEZTd +3bMYbtFszUrOVVs7q6cfbJ97OL953UlPSFz8pUev/Ow3f7d9cIvkS5nqRrF7dnLz8e2Xv7RzcK/W +mrOs3Duf+cLu2TuhiATMnWJNZmunupMXDq+/my3OpZzWK6985uaL73oDPLAn4ZjGCdWVrbuX7793 +8dH7Tm6+2Vh4872v11or4bAYiYmiWq139rfOvXTr8Rcm568CY3Xt5ieL5fkTbneemNfLwHACoCJf +mJ9bvizyuZvXH378J3/BC3mSq2vxWfDpRnJh5/CNo7ufq7b34Zhx/+Hb9176VCLdG/USw6Mo+B4O +SyiSYLnmkNtrlTg4ffXWjceAQI4d8x573vvcJ3zHjsXCEcew52FIn13Y741vAFsqaYD3CggWh9CU +PwzmLgNMFo5phlGCIDEG/k0lVLuXKS13B7vLp26Y6XEUVfL5aTs5cHueRmSgGz1e2t0eSVqykIIi +dMgPM6QUCiCBAIEQCZTKADuDExmUSIUinKqWgIRrTu5vnX+0uHOnO38lUVjzB2k4xqtqJQa5j/6e +OX02EpJYJpctzlNsHkREMjEGLikSE8Boe/wccItu+T5Il/lCwN1PwmcLs0DuykKBJhLRsITDKiCf +dLpLMUYgAJOkCQhHMcv9mdMbp2/MrRyadiuVatuJLoabHBuX5SxDORgsM7hGEeAl9MgoCrwVTWZA +yGOoAkNqKMiLbIohLBIzgCUHAc4yWSCYMdygGIem45KcTzn1bmu+3lwAGQFc/PjM+Vp3M5npSEpG +FOO6GrfUuCym3bV7D8nSaRFcMJ1AUS0W5WNhBqSneHKMV9uBoJzIzKaLi7rZmZg5s7B5udJZw3Gj +nG2e3ruSL0ziaDyVmUpkJnS7JSp5VS8CVw6crCAWMNwZedacAmhF05qIJ+dkpcHQcVWwa5V+f7Dm +nlIsryaKq/XBYb1/kCnOOJlJik4SMLe2erB+6oog5oEU1PQ2TgD1FZeEot9L+D2YKRdffvyp1954 +F3gZt7+qh/NHbJwtZ0pr6fyCoWQ/+OhrT15/x+8lTxyP+H0cx9dy1d3+6u1gkA/5SY4G89jAUA2Q +BkhJYPCB9usOtoEQIsHosc7i/OlqbTYckWJRDYhYismAwYGidNAH+0YjUBgRGSEWiUIRlGETpfaO +5kxK2hjFFRnKmB5f29m9nsiOS1rFSQOzvIDguXCYpzBV5BLhIBUJMhhiEqjDUhnT7AJfBsFxEksq +fEHmsu3a3NzCYQTWQFpBUCMSlgKA9v0ETxn5/LjfR48OI24L5lEChjQwJgyTpBkHAMOJNwUpDaOC +FW+WG2uJzJxmjrV7e/HkBAyrndZStTobDrmVSWIQsOrxQNCG4YLA18ElBf2QLiUMreIDvikk/nEF +MBLR3ZP4Uc3vZ1XdjVCCzBhWzzKbJGGHQjyQwRQVR2A1GCAo3N2RiKMqAC0CK+GIPOohQEQQqOz3 +QO7pbD8VDlAMbtBkkuVLKJ4MhehsYZDM92MxYFENScmzXFIWs5aWEzknHCAENp7JtKAYCCscQ2UA +b1kGF5wFt+P3U8EAi+NONKIgsIYiBhglOMJLrMmSJjAUsahU7W5IapUkEySVRGAD6CWOSalylkCU +oB8bGYqA2MRR/eSJ8PDJaMCLUCjDU3LSrJTz0yBOT56MjgzjsVgCp4sYkURRkyQlGpiWate2SidP +xtxzYfZEd+LczNrNicULwGJgAE6YjsA8BvNudoAlcF+8mLGdhuU0AfIVIa7JSYrQwERQOPCkKRTT +MFT1e1EMEpAIjcVIiRUJBONokSJVJ91kpByMGhAk6WJya2Xv8Oi2qgGRlkimp5vtg3hqAcNMOMpE +AnjQh0FhHoUVKMrDUYHADJJMCWKDpbJIVDbEzLntCw+ffBpC1XCUQxA1BogrphII+JIDfsw3ioSB +sPQDNyRGY+qzIg9cJCKydNKyGyRl4phcLE/ny3OJzJSVGOjmGAsoEVIto2ZZDfCfwSzEE+PpzCqG +N2AoHwqK3pFoOADLvClwznG3jEwYABjDMiRRRNBEJKJBkBFP9hk2C4QKBNsgj7u/RGwgjAExugVA +hqLRIAUD7zwKu1URRjAEBRSXxhEdQ0TvaNSQi5nEGAKpcESEoyqBASWgRiNModh3EjW/H6UInecT +NGWxlE2gEhTGIwGEIdRsuhz2h6BQDEdArrFI0gEf5/eRw0NR7ygKpO+J4wHPCAxH5ZCfjoH5gmUk +DNgDwEzojW8qUjYaoinSQREbQw0QEWAePcOR0aFgwIMQsDLqVqiAgD3EIN02iqYGojuDxvTjx4Mg +FZ444WrpZ8dgMb8PEziDZ3UMFbweCLhFhsnKSs00G/FUV1Yqfh8eDoF8GjtxfDQaRFAETBDH0nq1 +PJ7JdDStiCJyJIz7fNFQgCKwLIYYGCJlk5362OawB3BFxDMS8o6ECJjmCNHUUm4lIifHSYmQS/VO +pzZVACqIcxCISycahl4EmQhG9dFRLByko2FOAuZFKqCIBAInFMCjIRKKCoDTfB4SiaqWmq+Xx8vl +PkVIhpamSBNoVPBCJCZAYeH48TCgrFjYvbWhk35fgI/GbIYtK0rbMHuaXoVjLCCfmdldUQFmJA5U +nChV4/GxUmnOtNwnh8EARVEmw1gA6u66mNuAEoOB94f4cAj3joaD3igOcXAEXCrj9wMZY8lyledc +oohEhGcmqwk4h2bqtrPoHnKBtaC70AZ4FR8dDkZCNLA5FJVUlRzLxJ+VVggEPND81Ob+/k0C0/1e +JOwnoCArMnFwU3CUDwWI0aEwCgsMBdhGCAVINMaSMEtjPIEKcAwOev1YFAY/gkjk2AxDp9x1ah8e +CTFgjo4/7/GPoH4PMgpgcMw/cjzkG8WgiMjgpsyngG7JJgoH+1eAyATJLuxnAKtEQ3wsxFGIDuDn +HYFso+lYY3BExkGOCHGeYfjYcz7vKJgXCXziiWMeElM4Jh70k0EfGCIU2DfPcBSLijyZwCEtGmQY +whH52tBw+Phx77Fjo+CWcVRWZSC/ZVuxz569YFpFn58IhzgE1UgqRbNFnEj6vZAuWIenr7775e+H +YuJznxg6ecIfC1EiY6tywrYyEqudP7i4tn0+CnGjI9Fni/LuujyBqyyjSryWsIDCnOLZPElYQOPF +Igz4PQYRLMErfBKOMVAEg0I4iUqOVaUpPRYBIxAQacq2ACaZYAQPhWGQESQuKwvtSEgBmWh4JHri +uAeKiRyXpGkbck2rCkE6BisynyBRORYhFSWbLc9DCPhEPhJy92c++2tKV/M+Pzo0FAJuOhIUKMyB +IoLfh8AQk4pn0qYjkELID/l9MAyLpt0oVOYBokJBBlxRvbkUT/TcrtDDUQAnKMphbgaMS3wJRywA +pLTTyCWbsTAGKJ2nFAIWCESkED4aQkL+CHj/84eHOMKOngx5h6Mnj/mGjwdDPtIt80gZzxaCBSii +x4JYNBD1jvhHh/yRQNSW5ErKruUSuqSWq11BcjyjwEMFR9wphpCIGAmwwyeCx58fPf7caNBL8UyO +o1OxIMPialzPJs28KucCXhQKc2gM5BreC4jlmGfouN87HAn7MI6MozHBPxoFCPd5APJpHLZQyAn5 +uaETwaHjPolLAUAOnwwCHIK0S+GGIeUoWAt5mdGTcDQAIosYORn2jiLRICBPNuCFWJLhSFzm8HLS +6HYbNMtBwCDpyXKxEXfSNCPGojEsFrOBaSy1E6naiROBkaFwNEhrfNyR4yJJGTzdzA== + + + JZaW5uLpXDCMen1INAJyqMJzSsI2cmk7nzLX5/uPHtxtt6dHR8OjI8GRYT+D8xKQR4qkcjwSiVkS +n4sbIgMQ5YkF/RweyzhCNWecPzVzcGZ5Zq1froM3E1QFiA0RCJhnphgFV6LwiqlJqiyYms0QhiLk +KdwCssc/EmVxvpgt15pjipLIZZo0raMwi0FcJEgMnwwfO+Zzn2VhbrkYMHQhHwzUb7PSm5meUQUJ +DmN+L4zCMlAFtlVgOYcgjXJ5XNNyipLjuETAj8fCNMAMifESo7CkjsQ4kLJZOsNSlkSLMknkHdVW +NInlDVHkMIQDICOhfjO5ONfhGcCKBBxhoSCFRQUcUkAiA/AAHEIChRlhooEAFPTHAgGd49sZc67q +7EwWru11Lu+Ov/HK1d3N6ZSukbgIRVmQ+xhEBwB7/hPDJ48HgsBlB5ngaAwPExxKOaJsCpLGiSgI +3iAkMRxHkSTgR5JhMF6kbEPOR8P08En/8eeHTxzzAniA5DgMXOcwcfxY9Nix0MkTEf8oDsAf9kFQ +CE7HczhE41FS5x04BDQ/QaEOT8cDPvjkCa/fAxNAw4TQmN/PYSFHghoZZrplLU6XGjW7kJV6VfNo +tX73wvz2WrtdNlpFO2k5qmShCHfy2IhvJICEIJ1mHRZXsEBWhlZ6iUbFNDRaVznT0EWWSplcvSAt +dfVXb2+8+sLuw6tzL9xcrpZSoyOB0eEwEgWC1VFZ3uQIm4UdDhqU1JV+Yrws5nSoXxBOTaZevbP6 +6t21737u6Lc/fusXv/rwi1+8vbGQT9uUxDMkGYchB46aAqnnHb1T1idbiUE9FZeYnG0KNB8ORGLB +sMnzrXK236+uLc+9+sYb9XYPgpFgAAYXMHQC8BUtK22SzLiP5o6doGE4YxiNfK6YttBYGAlDsRAk +MGK7lLt8eDDW65qGubY2m82mEJiIRHBBcBjGAcqNArwUA0RAg6+c6VTSeZAICyZXVJGdufz5rcFU +I9lOi9uD1IvXlz/5YOsLb557+sLO3csb84NqxjLwCAQF0YgfJ2Fd5LIMJjAwplBoNc6Ml5R+SZ1r +G+fmrAc7+U/fmfny0+2vvnHq73/5td/+/CvvvLB9Zn3QqxU0VsCiOBwmIiGKJm2OMPEwBEx1URVa +CbVsMFMVfXksNdvObM+171xav3ww/fDa0tsv7n/y4eXLe6d75UrWsVSeQsJhoL4iAco7ggA4eUcw +wKgnj3k9w8GYH4b8YZXE84bUq2TiEqfTeD0Tr2bTKc1J62k8Rp847gUBG/GjQGwpaNjCfU0zemZC +efGgdmuv9vCo++FbB998/8oXXl/94FHv99+/9U+/ee8vv/HgvdcOdhZ7eccB9iHoDUa8o0zEl+Ni +k0l4Kh1cKscuzKlXT+UPN7JH69kbe42H55tv3Bq8da//xcdTf/dXr/6n33z2O58/c3cnVdSRsM/v +90ZpXGJwgYjCEhzqGbH9DnU0yT05k/nw5fnP3O+/c6f1xSeTv/juzX/67Wd/8e3Lv/qTo//ys1f+ +x3//+V998+7b9+YvbdcKCRuPgWhlbEHLm2IrzS41lf0JfSYHz5WxXhpf6pir/fh63766XXn/yeYf +fvcnv/r1Nz764P6Tu+t7G+MKjwe8vkgAhWLC8HDwxLGhmNcTZ6MZPlaQoTjji7OBfk6YaxiLXX1v +Un/n0cY7T/Zfvbv51Xcv/OSH7735ytVGyZyb6s/O7Sxv3VW0Ehr0mxSU5OCOiZ4Zlx+fqz/YKx6M +869eqPzi+49//sNXP//C/JceDX73o5f/7T995b/+4Qs/+fLBv/zq5b/55sVzC7ZFReCAW5OQhAQi +hvJQIMkE5/LYvc3E9z6///MfPPqTz5//7IPuNz459aMvH/zhb578zcdHP/5w519+88o//OjqFx6U +H+zndmeyeVspxEGuTBpKRiSZFB/rOdBKib65En/7xsQr50pPzuf+9IPzv/nx0//6n7/z+1+896vv +3f5v//DO//f//t3f//qDJ4fVb7+z9csfvvDe442sIQU9EEiywMayhIyEQjhI+RGvhgcMbHQ2T1xe +TF5azu5NaEfz5ssXO3/21Xsfvr7z4dNLb790NWc7UJQBDCyheFmhplLodp24syh/cLv1vXf3v/vu +3k+/dvM//+Tp//j3v/r9zz/94y8f/N2f3/uvv/vcNz5zdGoqmwUOkhJsNS7guEFCLR1dzEPn+8TN +Ofn1vcR33lz66Tdu/uALZ7/59tpff+ngP//1S//tP77/r7995zc/uPm771/+zZ9ee+PadNV2kyAQ +ISF/FA0jcUGtqNJCinx1S3n3YuLz1/PffXPmt98693/+4a1//Pkrf/mlvd985+iffvbwH390+8cf +bP70w/VffWv/zz+/dX0r28w60QAMh0kqiq2Mlda7zkpdvL6kfeVx/8dfOv3tN2e/+XTh9z959Vff +v/9nn9v94WfW//s/fvA///uP/ulvn/7+e9f+j79/+/sfHmyPAyz4R4dHwgEIcLtJM9M5rmeEu6rv +8jj5aMu8v2W+dqHw4ZPpH3x+61tvL/z0m1f+/T995Xd/+fIffvzKv/3Dl/7mW7cOFsszg36+0EVg +OWs6NUvsJ4jtCnppnPzi3eYvv3742+9c+d5769/59NpPv375X3/37i+/c+37763/h4/P/e+/fuM3 +37jwrUflL97MHIxxgFVEkvUOB08+P4J4fUk6OJWInOsy15eMJ+eL7z+Y+tmf3P7nv33zf/vp47// +0aO///GLP//48Ocf7f7lp6c+dz1/aVoaS+ApEXXLiTIajetxvdCvNVd6qaksNZeGLw7Iz99r/dl7 +Wz/66OAvv7Tzi+9e/MNPX/yHnz355Z9c/uVHm//ww0v/8qsXfv/DK9/+ZO8zF+MvH5QaKRUK0zyb +Yyhb5eRWVm/Y+FgcPTuQ763JL+/on7qYBaPxH//i9q++e/Hn3zj8v/75a//3v/7pdz61/t3Pnnty +a41FKTTKJAQxxeFZLtqzkaUCdjQuvnqm9K03Vn/w2f2ffPHcv//mM//zv/3kH3/8+McfnP7g0eKp +2XxKoVgUx2Fek9KGlLbFuMPSBRGaz3OHU+m7W/mXTid++OnV//V79/7w43e//MryR4963//Uwk+/ +cu4bb288PFs5M1ds5Us6iCk+Q6A68GIMruSMdNWy8wI27uBnxs1zk+bVefOz1+o/+sLer7977wef +P/udT21+6cXlpxc6b+xX7qyl1rpyM8MZAhUNUwKdt7WaSPAlUykoZFnG5ov8w1PFb74+/9cfnPrb +717+7Q/u/uGvXvrnX73zs69f/PmXd//lZy/+2y9f/fVXNr/zJP/yfmquxNNQKByATaWUi3c11jQp +rKnjHSU2bwdvTLOfPMy+fbn8tSfz//77d//ld2///kf3/8uvXvu3v//8T791/RtPV95/cXZpLGHK +GkOa4HZquZbOsimBWG/ZgwQ8l4zst8gH68mnl7ovn23c28h+4Vbv19++9tOPr3/7jdUvvzDxqUu9 +i9OJ+SLIqbCAcySiACUzejJCQ5QAheJEcMzCNlrm/mRudyx1ZTH/0pnK21fG3rkx8/aNmbM97VxX +OegZ8yUrwQkywfA4CzS/yCZ4OqkKWY13qslU2ZBKCrNStc9NZA7HzbcvNb71xuzffuvMP//i5b/5 +8uHXHk9+7WH39W3z0YLyZDO7VhZMLETHEIlPG3qXwGxgA/EowUbDDhFpqOhamT3bJV9Y11/fT330 +sPeHv37h//n3j//p16/99vsPP379zMX58kTBUTglGlOQGIOGwpS7rwvLK0zDpCfS/EpNPZxNX17K +vrBb/urLy19/6/Q7d6dub1emKhpHQZGA3+8JR8JcKt6tV5eTdlemNRUnWnH97EL/6u7MII0dTSiv +nGt95c1Lt0+PXVku3Nos7Qzsfk5JqwwwODRuuuUKYyZOpICRBw46Ha87siXCiEkSRU0qGXzNYpcb +1uFM4dpq89JSeW8yO11MTGUSYBrTCsfiKBTFQyEqEGApPEXActQfgfxBOhI1SWo8m97oFQ6nnTur +zocvDH7wuVMfvzL/ow8v/OgLh997a+27ry1+/MLM+1cbl2e1OBcFpl2gFbf0MeYQqBkChihCVqxE +N2ln6FDfip3uSBcm9RsL5nefrv3rf3z/n3/3mf/wzevfe+/cG9emrm6WFjs28MaymDbNNknYFGkg +MVaitU62mhXpkko0LLYkkXWNm8yag6Qym6IvTCfvbo+dn8r3TLqqCGleVAmWhOign/GMkEMngAJE +FS7BwTgTiYgQnFGUctyuxeMN28xLdIYjCxJbM3mHjAEtmGSFZr4j0DZwJQhQ8pCQzXRxVA8HgNjG +kTAhk1LZKSyOr8y3Bk1DXCooN5YKW1Xh0mzuzCC9XpI2yvJCTpnL6jWFjQBZMBKBIjJDFeEYsIFh +4DS9QwEs6A5sTuSaplAUoMkUvVLkLk+bn7o2/plbs4/3u2f65TRN8xBpyLl4ZqY1OKKJuCIkGVyi +UTAgisYrMi3ovNzM5ysJvWjxRYuLS5Qhspoo05SAYAKw6qOjcCwmC2KGpG1fgIxGBJ6ydMHMOrli +qkxGIgmWasTNShJwmiERnEiwwFDEQiRwUpEQ7fPiHg8OI4lkZiGdX3C3kElZhtQomNWFOB4DaZrU +GGO8NjPdme9VBgnFUihO4xzTtTD4ySGvP0DGkATF1AShqkoVGtdGh3zeYT/w9RpvW1Lcloy8oTYz ++kIrfriQ3+6Z52ayRwvN1UZ6IqP2U2bVNKBg7ORJTyjonm0f9SAnTgaB3yTIXCY9Wy0uFFMdiaRs +Dq0ZdFFECwJ0qpN+9cr2a7fPXFibXqyV05Ig4BgO4zRjw7AJwYY/yKtmr949qDX2c4kJidIXJxau +HN2kYA7MF4tKjpQuOOVqupY1shIhQz4CDkleYEtPRAGoIlErGNSCARmGLIFNRX0QFgK5HvOOwu7j +ryAZDXNITKEwi8ZtHOJC3jASIqMBJhpiWXfFSqfwhOQeZhkLhURge4N+Coc0GjMMtSKLDRA4ZIyR +SbGdqyD+cFxwMmbZ5Ew6SlGQSCKy3600HoIhk8RTPg/53P8ycuy5EeA3cUgyRcuWEyREEVFMIXiH +l92zuGjMIBGDomxWs9hUcBT1uQVhOsXmrh0f142xTv+UlagiKE+QlqrV86WVVH6OpAwMFVTBGevO +eAPw0HDY62dYsaHZE6oxzrqVtdICl+0PTol6zRuSEdw9lIHiyXBERSGdQtWgDxk6GQj6GBxxeK5C +kjlAUzHIiERUns0AWeLzc76A2+oIxeKqVjWthqoUE/EG5275cBfaEMQEf2L5siBWJKWiW23NrAt8 +QpQKMJYIx7QYpEeiOoLFEcQOhQQEVijKlOWcIKRkuZxIjNlOU1eLFMLxlKCBieVTHk84FEBhSJOk +jplaQciMz08ODUVPnAwDYCBYTlI77oFEH+H1Eihq07iDRSksgqmMWswCXtIgWEIxiw== + + + eVYrD4LdgufgtaMgUmBNFEu54grDV0JhMxyWYpBqO/14csI7SoYCYHhtQSzIWjMGO8GQEo3qPFfl +uHLAz3tGaYIoFMobmtkX5RaMJUc9ADmMRMdlPgE8Gs2VrPRMsrRYdjvSTj7rNi6ShNXqbLFu9XLN +MPuJ1Hwmv+pkljwB5cQwfnIYDYc1n4d6/rnRkWFYlNvJ0kamtKaZA4Dek8cjkaDg93LPPx8aHkYw +Iq3o4/HUqmYMQhHDF5CHR9xlKYa0AZiH3KdknuGTkaCPxBBdFUsSm/CORIJeCI8JOCxjYLpDgntk +KSRFESccs57/hMdIzuJsluWT66tHnYlthEpQQgGj0rxclNSqYXY6E3shWAzHRIrN6IkOSmeiSDyG +JgW122jvHV5/q9BYHvKQwSjgiVk7s8mrA5zKR2NqIMSimMkJZYA3CLFhLC0oY5o9BRhRkms8nw+G +lUjMiCEGyRQVs+ekJ0S1juIJy+4Vysu8UFDUGsUVeK2TqZ1KlNbtzJxm9zgh35u6wEv1KKSIaoHi +8orVY6QaQuUxOq/b/XZ/f3nrBkomRrxEMCxRbNHd4EemCdY9wmNq1W5vW9Zbkt6gpSZClnC6zkuD +YBjQjhOOunsC/UEyFhNFsSjIfYIshQJcOMhJYoV9dqJBUJrp0nKmvE5yDZKrx9BEBDJorkBQmVhM +5dhcOKoFAjJKJCm+hFJFT1AdGiYJMh6OsB6PW0gWQhyWr1FMkWFLKJ4m6QLLV1Sj5/ML0ZgNoRmM +LEJoimRKKJEeHsFGhjFFabJ8IRBiQhGR4Io4V8aZkmx0ecndlgmjFkJkvUElEDUgImdlVyRrykwv +GomFk0OEx8PQTIEXi5GYDsEg9hPhSByQM4qlIhF9dJTEqaxpD0xrPAZZbu/RkErxdU7qamoNiooA +lseOhTwjWNBHhUMCjMRD7vlfPRIBiDJ9IyigNQIzdWtMtSckc1wwxjGqcPIESostWqgmUoODc49q +3ZUIqiFUEibiZmLcTE65FcO0FuNutpmwU2MhWPKE2EBEp7h6rXu+NriUb+4SfD4Kq6xYU6wpxZ7B +mCpEZMH461Y/kZlV7TFAL6GIKqrdeHbbSCyzUgcjMxASBxfAyy0INSJRmRUrABWZ0mqxtpUrr8XT +s6n09MbuHU6tkWIl396bWLk1v31veu1WobVTHzsry41Mcmxp+1oY0REyAaClOLPp8la9f1jtnU+X +VxEizggFUW0yfA2n8wCfnN7llcbk5MHG3iNBqQ15sBBkOJnFYvNspnRAsu0oko7ADoQnnu2FE6Mx +cdTtwiy7tX9RBydzUThu2AM7NY1SFoRbYBJpqSuabodlPTEFMBYOK2P9Xd3sgvv1+BlAiQRbIbmm +oA1ooQzBajTCa2pV0duAiqMxQIC2pI056cVkbjmVXfT5RUFqiUqfEzvgs8Kw4wvrQx42Ajl2co6g +8259e8yhhYqg93itTwu1YEQBwFascRhkDbcSWh2lC3pilpXbij1Jy50w5IjaWDyz4A0AWMoAWjhR +4sWOZo2DO4pBTgyyFWMMJGKAwFEPFYkqotJM5pYoruHWbPGQ4KqCYQMw24lj3mPH/MeH8BCUFJWu +Zg0Yvur3MsEAz/MlBoQwbIMvt3gmmpDVLit2ipWtQnVVs7sYnWDEkpEcwFScFYu80gIg5JVmIjNV +624pVisQlXitgZJZGEsRbD6EpmNEDcKLf9zDH4rpMTQuGmN6YqbeP1o89aQ7ey2Gp2DYysX7i4uH +YdT2R61QNI4SZdmYzNR2Ms1d0Wi6jdVyU7RUEfUmJ9c4uS7onUR+0clMkXzWSHRPHb28fOZOfbCb +rqwrzgzAJLiRVnNtefsGGDFerhQbO+XOYXPqUqm7J1rjEJm3U5OzqzcLtfVgSEukZhc3bk4sXOxO +XVjbe6TGpwCJAfxwUpXmcxBmYFRmeunO5ML9+uBGorSNYhkEd0S1yOuNIQ/jD4iAuxRtRrPnncxK +prQC46qoVeP5FSO5CPihPn44vnAtU17T7EkgtCS9E0VMXi4LWldzBiAvCPpkIOoedjOt3vTcEUml +gmEwy5ZmjmVrYAQmOX0CZ2qBkFYqrznxgScgxtBMOOogeE6PLzr5TUGfCkPJdGZy/+y9sFvZjxrx +8oC4WEChlc3lM6+zfP3ipcdf/voPi5XFYQ/nD+u81qvNXJzYvN+cvqLFp4MRLVNcAKHh9YlDwzhM +pKMo4NVGvnraSi75fXIkrPBCCcSUx4sC7hrycN6QwgAIJZbyzYPnj0dHRmAI1sIxMxyxACYhJBkM +WxE4qTkzycIqSNC+AB929UkSJbLx3BqCpTHgsJgCIBPJGNQ65ydWb9NS3k6OZavL5eZ6rbuZKswq +ZhMMpqDVav09MGtu21yxZibmS82zpfZZIz4DbtMflWEyDmgKZFiSK3MqiKwpgm2q1mRn4nxz/BTs +7j0eqHZf1Hu00JCsCT01Len1uYVzm/v3NKeLuFXls0AJN8YPBut39fS8Fe/MzOy89e5XG4P1MGZR +YqvQ2GtNXO7PXS0211DC9vhpgsnidBYiLJzPhTGHU1v9uWsLm48qnX1ObYPU2Rg7y0h1hMqKxkSl +d9bKLIpaH/CVnZ4c9kDBKOFkOslCX4/3olgGpaqyNkjlF9dP3do8fWfYQ/qDAss1uv0rsxsvmtlT +JN+kmfzDl75Yqq6EowZgxZmV6w9f++DhGx8u7j2UnUmgFlSt/fanPjacsREvF0MyijWXqZ7pztxY +3Xm52jmgmEx/cjdfmvEEqDBsUmInXtidW3/cm74wPnMkuIXyCvnqujuJUUPUurI9yaljJNcq1k5P +zF2AkASQyoCiRb0v6G13UytZBJptbfva1Qdvs1IZwdN2ct5OAQM8oIQGQZeAGmH4en3swEkvDI2w +gaCmOeNObi5TWSt3dgAv+T3ApU+NzxwCATw0QoBcr8VXBL0vmQOcraFkZXiUTSV616+/quu15z4x +OjqCokTKTCx1pq/tXnyz1NgKBOUrN57aifFQVAsBdS/2YkA4wQlwL1ZqpTF2dffwndW9x6pWO719 +pd1fB4pLNZp2crLa3mj2T7cmzqSqS7xULFUXK91djMqySoXT6hhTAYmVU7t6YrrQ2Ca5PFBrnNzK +Vfdr49fac9eK/QNWqcbt7vrO/URhEsBAj09mKhtzqzfOX3zl/I23+7NHTmJ8rL/dHd9RjXamtNya +PJ+pbJWbW/Or13eOHqfLg05vY2b+quZMUHwF54solQRKjOabRmKelRqKVu3P7gl6PYo6ujMJkoJo +TnB6vz11aXbzAcCkEZ+KF1fnNq8vn3mx0DsHfFIQsiOQqVqtYns9CDGyVSWFGiv3spWNVGlVMnvg +LkY8BE6mJa0laGVWb3P6jJpYsDNLiewcjLndrArlecWss2LGzgwa02fT1aVMeSlf3ciVlmHMBvRo +p+ftNJjlvpWdBUJaiS9q9nSxccpIDIIRsdbe6Ewdqs6kEZ/k1YZktEm2lEzPAFQzfIGks3PLF669 +8N72hScTq9ervbOG02eY1OnTN+8++kIwasB4wklNdqaO2lNHzcmzjclDINKuXnt1bu4sglgknapP +nJ1avTtYuNkYv9Sbu8uInVGvQDGFKGRYqWkrM6+nZlitBcRPuryeLm4PDTMxKJ7MLVJsdXgUHvFg +QyMkBKfBOAMjoKndYFA4fiIE5Csr1EgXdUWCLgfCOqCyzd0XU5lpoFdhLA6QAJIjTuZBmgaKy0rN +5mvrIJY5LrswvZMrTyCYoaj1IqDczburOw8a/X0z1RfkwthguzN9PgBEHWHJVjtfPdUeXC209nL1 +7WRxUVLqhcqiarb1+CBT207WNiRnnBIqhdL6zNo9MzOBkE6tezpXXhmf3j9z+GBu47qdnpDlyuz0 +mcHMPicWc8W5sxef7B29tnTqwezm3UrvtKpnj87fOTj/AoQBEgb0VZWMLsBAurytxudJtprNTl29 +/zSeG8B4PFNc0ZPzZna1On7+9OU35zbuxBMzO/sPJ1cuM2rFKS7J8QVa6evJpXR5tzZ2yKttUcpd +vfVJwAlh2ILxFM5WCb7OyA2KLRTL6/XW9vrm4eTCOYJrsHIHEHIYiUNEQnN6E0tXXdqknHRhJt9c +T5UWK52deH4JwnIIkcnVN5LFpShis3IlVVkrtM4U2ufaUzeLrTOqNeCE0sVrT/YOX+CVGhBXBF0E +BqHaOZ3ML5nxMaBgaTYzu3hhfuVCMjvQ4l2Adic5UazO7519YXXjOvALitYezB7Obd2xC0ucMfb/ +s/deTZIl2ZnYO4nuqszQV2utVdzQWmZkRGpdlZWlRVd1V7XuGfTMYDALgMAulgAXKw3cNSPX1kgj +X/jAB/4DvvAnkZ9nc5dLPvGBZkxbS+/orIzIiBvX3c/5hMcNP35+Avn6/Y9/NZ9fiEIUJcudwy/m +m9fdwQXSzU1PaKFdqUVRvJLV5vHjH7749T+7+vBXo/2vJnvvR7tfeMl5pZZAx55dfOP5C0mCeW/w +QtOA5klPXH8tiu1iURPEehBuAErFssNyTS849MKjRud5e/gcvoxiAySUovXhGmxnQjaQ5yOMgO5M +ksZxd/SEZEdMlGcQjMN4tzO8RDJG2Qby2A93BrOXcfu0CPLVGgit9fE36+Mf4taJ7o5pIfHc8cHR +V0m2cr0hgO7y1e8x/s+++MunX/z1/uNfB409xWgfXX5rOpA0bZLyyTqp74+n15PFMz9ZGmar3d70 +Buv56qo/e5T3zl3IsGQ8nl42OgcgEddf3NataEpmI2kft4ZPuwRGrjvjE1mrp9nip9/+83c//G1r +8qw7eUq+NN3ci+PF06ffP3nxayAtdP7i4Kf+4v308CdgiAktykXD3vHX3//FfP10u6Ro1gTwMt58 +2R4/RWr3Bxf7mxf/5u//+7/5u3/LSm1B7VneptF/fvHyz9//8b8+fv7nfrT++PF3/81/9z8v1y/g +0Zzk3I4hoS8253/87Ju/w6xJSqMFW9Q7M13E21Czx7o19sP14Bad3n71u8Hk8tHjb5vtUy/ehdcQ +1R4tZBz8ZrTe2XyV5vtp4yDrnNrh4vjsm6unP/fGzwybFE6aLZ72BmcWZq37ZAjtun7fnb0Ks0NM +MWzCYHqjm6Nb0xcCDKPm4/7yY2/+1vLmutnbHL9+8u7XQX1VwhP4xPJ3Jrtf4iW9wVWWbcj+YEY2 +GF2p2qBWC4tlF5xI0ZmqDcfTdzvr74NoM1vcTGYvZKnJsTGkfoWKEGlhctQZvlC1UZQfBNku8g4p +YHlTSHQ32oT5iWJNBbWjWd0wWXBi4seL4fJ5d3zT6l2vDn7YOfnJTtecnHYmj+r9c1bKdHsCm+bC +za3eZvkJnuaGS0XNV/vvVscf+vObtH3qZruK09fcSX/6dLzzGuAAhx6m6yjZDMdX0+WT1uCM5iPH +7bX7R5pd9/1uUl/XW6ezNazlIzgj05sJUjPKjv10jxX9MJv05tfrk68un//++PpnRg== + + + CAVyKf786PKj4U9hncjG4P7u6vCLzem79fF715s6zjTO4L865ZqJLOiOHr949w+gMZrdC5lsTmhW +KBs+2nT6NdoEbuSdw9n8crO5ef/hN6PJmSC3s+ajvH2TNc+DbB+WAfjW7FycP/ru5uUfy3pHVPut +0ZvZ0a+78y+y9lm9e2V4ZMP/569+u9x9CrMsKF3Dmc93Pzx9+1+cXH2/2gN1Pt5dP/37v/8fTs+/ +EfVJZ/ZqvPfVaP3F/PArDLiq967O3v9P/8v/+oe//jcQq/CeYf2sO3493/s0XLzM2ydZffPFuz/5 ++se/tfw5gFR1Zm60V29d+MmRbu8o2rDXOz57/Mn0JrIxlfQJwzdoJvGC2Xz3+dXzn1Sj5bqTKN5t +dS/Or391+fg705lRTFypOmmyfnz9K9uZFgpGpeJ5wWbv5Ifx/K0fH8rqpN06/hf/6t99/c0ftrdF ++AJWGurWqj94Nhw+rdePXLuP7lv+RNZaspKnjT3LnbvJoeosIbMH07fd4cvO6AnGHMqz2T8LyIb8 +u5o9Ua2JHe4Ops/Pn/0u65xUKAvn48VrK5gPFk/RC7CtanTJVm87r7x4AZhqdC96i5eLw2+On/z+ +3Xd/sz77WjF7XjQl4cSGktSEs7DcpWpOITsRorLRaLV34bMYIYUKxYCwYh1vUe88CvMz0587/uj1 +F7+Jsh3LHSFPYQoQ4Y47ns6fP3n3B5GU2BtEydpxZxBv/elVa3guKo3bjZ1XstZkWN8NZ+3uwf7h +i0Z7v1xxihWX5jLVGuetU11v2FY9zXfGO9cXT747vflxsLgW5AwqJakf3e4OYSMvIJVPH/365t0/ +ilrXrNCtVINO56Q9uOCVOkIUXp7hct1aZu3H+eAGWSPJ9cOzj5CIMlkN7klKGwg8nb9c7X2aLD7w +UldU+p3xc4iu21WFuijXBZ7sAvf+018cnH9pWO00P5jtvt2cfGqPriW9D60IPXZw+H42v5GUPKqv +8/41MvHs5reDxVtW7FBU2GoeHJ590K2+ac2C9CBpXtj+ptN/tDn61B1cqWrz5vqb48OXttUWxFgx +OvXO6enNry6f/04zxoLYYLnU0Aa62qfpSBDqNIvnkIpXWb476B+YRrdW8+P68WD2nhdyuuZUy7rI +Ra7Ztv2V5e2o5gQQ3R6cJfXD8fILnxSyOVmf/Ag7lrbOWCERhMRxR5iRrHXsJftxfr4DzXD5q73z +7/xsU6lZrj9Xzb5s9r18T7WHPHjWnfbHjye7byxvFKXL1eGXrdHjvH/RGJ73Fo9AZAgtP1nBxTBc +4ngrWNSIfFNjLetDCB5E+2r9AuZU1LuGtxDkHgRhlMKoHqJrpjfHGR4//omXG6433hx9mK7eQWak ++XFveD1ZvYJD98NZFO8A2GWlE6T7URNIOJa0pma1NLPVbO43Wns0a1KMUaXtUtkSlQE8V2NwbdlD +18gvj19ePvooqnWknhUudW/uRaso2Xf9JcMGUTztjc7qrb127yhuHIrahGLgytvz5eu8e0Kxjqyk +qtpl2MyyFxgulRReDB1n+PbD7xWtXSjILBtLaiepH5xe/Xx89du48Xi75NSYGNNRo73bLWgiRW25 +zjhN9rqD66h+EITT/ujUctqKniFNVHMcpQft3mXWPIWdFKV0PH00Xb3CbAb1Izver7F1WekHwQZP +k+Wm7042Jx9WJx9VYwwtpBkj2DqejZ49+ebo4JnrtMN43B0cz3afHj36BgqNYpJiyaxRoW1MXGuy +vaVVq77tL4Glq8OvssaRIGSViqOo3d7oSdY43toWS0WyQyBOOE03WfNiuvtNY/A27z+1/ZGspo7f +t90hUtJN1qYH9JhyygD9xZDyfNAbPepPXnYHLyBvwICi3mOlFhyrbrQlpQ52Wx582j35LmtdBvF+ +3jlzo4UXjnd2X6yPvpSNlqQ3JaMFt/jm019+8/M/PXn6G7h1XkxhQoFpkt6jmIiXesCuRvvi7Yd/ +cHT+vtE9Pr76xrCnrFBHwECHOMFu1sJpf7l39VvNHLtOb7nzuNneN2yIN0R1w/Z3kuw0y49Ne1iq +GCbIOtwN4fLyQ7A8xUey2prNn4NKikW+WGRrtA0DLqoD2ZqIeh/TamjNbuswThZV2vWTg7hxAbPQ +Gt5IWoeiQ4TW7u5Nf3wsSAFIkxFy1Zi2ehB1V5jWKu1XanajuW/Zo1LZptlU1qdueDSavt1ZfxzN +XoA+NK2zWr/MW/tkJ3AuYvlMd+Zhdmp4O7ozZRjn+OiL+eJGkOowXKLcRgxUa57rzVrt4xrZgFFW +yV5AIx1dNvu83KoypNBPt3/R7V/yQnZ0+d27H/+rwc4rDJRpzxCllYphaPVGY4WY57hENydeuN/u +X3vBnHwnjvMcp3vx6Mvh8MC2ci+a8HLH9nfb/ceev6trwzLZP8Qeji53Ni+BxjQdVCp2oaArcq/Z +ucpbF6KYM7SLXLadsSI1qZqH1A7THZsokxZo3bDGUP6i1JSkVohMz4+jnChSw9vToL6kDBCkaB3I +Nl0f2O5O0oSBfRs3TnkloVhT0eFZFn4wJpXjog0cYrP/GGZwc/aDHa5pLnT9MaBsvn795NXPz979 +tje7NoP5zuG745sf8+GjMu2Y1rQ7eBnEe2njNMjWYbpstY8Ozr4R5SZFe/X22XDn42zzVZgdW/6u +rI9EpWmSOk0jWY5UpRHEB+3+zfHlT+vDT7AGSO1KzbGcBcyX5c1WR19uzn8NeoqyQ4CbpPRoJhLl +nJdSlosanaud42+Xxx93T3/oLd5LxhTWBly5d/wp75wDIrz00A7WUXZyW9MEid8YDo6+/fEv8XuF +DjVrZrpL+KBW76YzfBMkh5AritpP0mPH23X83bRxgSeUa/b2NinatVi9tP2xiGQRG7Lc9oOlbo04 +BAkdiGJ8fvVhNLvgxDiu74+Wb1v9x3F6YtqrSs3f3pZKZc33JsWibJjd7ujR5vS7H/7s3129/gf1 +9glwQ+a93c3LRhtiHvxFNhtB73ghdaBk1E6lapINech+41ml6m8X1Crl4a+G0Qn8nqmHQdDxghGI +j2bInt4PH3IPHtC1qmNopB4WyzkUbWhGh2ZSjm3CjAQRnGOnXDJNvWkajVpVKReUSskybXAo+b6q +orSD6DBvXdvBHi+3OSG3vaVmjQSlDcjyo/3u4Fl/9iZuHdN8UijqgpArGvzyQHfITj6twZWf7OpW +m2M1nlFVNQ6iGXzlgnxG8/v9q59EfQTe1PQ4jQdpCiSHNpvDdG+Ov/nix3+yuvzGSjcQD1Gy8sOx +JKdOsNrZ//j1j//yq+//1ebsd2SjMD7KG/thdqCZQ8SeFx044dFk+WWzcy2rHZ5zkwRgtecGU9wk +tVeu+jSXuMneYu9jo3vlBNPF5mVrcCEoLSCbrA3i+ulo+aEzfoGBiuPxzes/2bv4TrGHZrjy8lMz +3Ljx+uD869nOC8PqNZt7i/13fnKY5Fd+emr5yyjdnc5vDk++NMk3+4a90c1g+qwzvMJoKMYISrhc +sQx9GIc7DGPBr0lARW2Yty8texnFB66/otms3b0MwhVF+aLU0u150rrqTl+Nl+8MewgsxYltjr/0 +oDzJzofzGpOjRxyfqGrbtrrlkhz44073IMmW7d4FzC8pSFEzIn+UJSuISZ7PAN1esGvZU0mGBWiA +98tlPU52bWdRLjtILsgPwyZ1x2S1S1FmtSLk+bLbP6fZ5I/IXn8mwwDxHJ6rs4i0mlsqK+PpxcnF +J9D9wy0FT4DW0rWRpnRZ2sfBt7Y4hg44NlONXrEo3X5sGoF8NWtpuCtIdN1dBdkpfF+N9R1/2Wyf +r/c+7Z39nPavaLFeZRLNmLI82dxVN9vzndcvvvrH67OfvWRTo1Rd9gw9NS3EZD+qb+q9y7AJZjyw +vZlp5YYeampg2u0g2QmSVW/0GIYx6V34rdMwP07yPd0EZqYwy93x5c2L3zx59Yes94zjG4besZ2h +KGfQwM3Oo6R+FmXn7dFLPz7mBPjfIIlIPa9qTRHEyPF2eL6pG6N696LeJns+O25/tnNt2H14YWSN +H+3NNx9Hu18F9RPMexiOJsunUX2XEeKgfrw5//7Rqz8AvnYOP7nBAh5nMYOHvWb4uuPvT1df3bz6 +k7cf//L82W864yeikHRam5vnv5rMrjkhImXpmFBWe3G651gTQ21RNa3RWK8PPjjBjm4BLjBudcvZ +UfUpeoE5hWiZz18uN++D9BD+TjVGNVKBwrXt8XL3paJjJKeINz87UUwC1BD5ZLf8smabLdduWVZz +OH4U54eK3gMG2g4YMC4UVZbLBDGvAjyVtu+vDGuu3O5GGMcrSe5Wa4hnHCpDFLFCA2+qWwPL6bW7 +Z63OJYb0swdsjYow8qWyU61FrNjkJLiGKYxSPT8Aq3JMIstdnsvxs0rKeZiEBaRmnO4LQqPKpQ+2 +xUpFR5BYzggwPpi8fPXhH7/66p+dPPnzrH1FMYFhD0JIpmDuxgdOehLULwbzj+vj35B6Q2KYZLO4 +vtPsX+nBfplvl6pRnhyulm+6g0tRjnWzYTjjMD08AMuMnzC8U6UV8GaYQZCTEkUIad8fz9cvd8+/ +9fIjxRrzUgvdhF6S1CzPd/L2Ud5/gjEHJ9IMZs01LQI4ujXl+NiwRs3es9bgtRue6Ga/UlW2C4wg +Ja6/rlFkt1vTGmOKSb2SfJNlK1XvCGKGIMfsGM7Ujfbbwxfj5Qc/OSdQw7pA+5tnv0GY2cFYNvqs +1OXlrmFPeiPI+x6c74js4Pdx9+DlfPXcS3ZZuQktUa/vj0dXcbKsVA1INSg3WR0ZzgwCabuglcpG +lq4WO095ISJ7GvCJG6wOz74/vvgZgqdSdQ2j9/z1bwCAgFPNnJj2st66yDsXEVmhalarVprvdUeX +otbcLhs0V5f1CRSg6+1qSm5peRKOzx99ShqHNJ9vl2zFGHNSV1AGje41EUUlJYuXk/Gz2+1xvK0t +qVBQBKmtGUNBapRKBjIrb58M569Gi3eWO1O1AYINFA+YNawdik4tc5K0H3XmL8P6IbmOiEtqVReB +5BjTfve0UlHIx9YPJU0ZalqPh+kTEygxEAdDLm6pA/NtdzCYXO/svd45eLN79L45OAf7a/rA/+Wb ++O5wsnxzev2nm9NfTdYfoVigE8iGHl5X0vIgOah3IOwfJY2X8+XXu5tP9eYJw3t4ghfBPLYVYs1G +ktqK0vWjp3/66qt/Ak6pklqNnuP1NXjVYCduXyrWbDh/vzz4znR3YNVXq+t295CTcga2l6vDm5vm +fLb8MFl90q05lAAvhI67AHARj8YlvJhD9HaH1yfXvxGkriK3HXcGqa9ZE3go6AfDmjgu2QCwShlI +LtiN3YP312/+oDs7xYpdpRzD6tTzfcTA7fUYGwTt9eu/unz2pxaprWNASU7m15P5Y0jfZucyblw1 +h6+hNjVzhoQtllRSPyVaVSpmqaTzYlPSRlH9sjt6/8uFRtWqzvO+5w2gWEQpkpQGBA== + + + vGMvHWeFFCBXqoi5AzssNSS5ifxChNSYzDDare6BG4whrlx71Olc9sfPQfGi1Bb4SJWSwB+EYU+W +A9fpI8J7g4v++KkbbmR9vF0walVdkxNdbQBARClXtX4U78XZkSS3wY8PHwqOPZjOHhlGs1jSwHE1 +pm6GR63Z17ODj0m2Zmmz29zd2byCW/zsc75Ytit0IhsLL73Km9cMBe3Hh8H09PTb7S3p8wdMqWRr +5jxrXwhiHVksqw3d7IXJMkkXcKBe0FVIaYxQlvM8P+oOH4fprm52wmSn0T003QH6jpGUFZLObrSj +Wl0vXKWNMz858dNzqE0oB8QDsixI9/LOY0AQ1HLeOXUDUqy2Pbhw4nWFjSuUp2rdvHXkh8t252q6 +/mQG4OKFoPVqLBA415yJYg4rFEh57ccnUAWKOsTgwHZBSiG2EbFQF7WayYkJJ9Sj+Nj1971woxgT +io51YyDI7QodKeYMRB9mZ3BwiDFSZaYiI4Qsuw/gVY2u4a2tYOOnx43BdZXxt0kNRA+mRlTg9Htu +uEaou/58vnrdHT7x45Wq5LBjEPDwZRSblaouy6WAxyA+gd8vldRa1ajRLsvXTWcVZReVWsRwiSg3 +VLKe0KdqOsc6sEVQiY6/A0MEcQtIEeUOHAfsA3Spoo/D5Hi8+ArjD+1xW8bLOTt6P+wfS2LE0D7g +UZYy5fZWq0iG7B6sLv/FP/9vA79fo7waFdBc7gQIoa4okG0oaFpP62vXHVOUh7OtViHMfIgowyBF +samaAYun6RPL27X8jaROy2WD7J9WMzyna9mDB1tipeqljfOwcdYe3gTpaakSfv5AhGazLbJCQlFu +o3kYZ6dAXYYltgvZZJht15s0WscmLK0G6kx+2TlBketBuEzrh83OKdDGC6ZeNBSVpEbK59mGMSLl +Y4K5YXeguBxSonfhp4eS3CP78PirrHV+cPWrkye/z3vXmHrbG2ESBYScnHNii1cGprOTNU6bvbMw +XtXzwyg7YsS6Yo4FQLG7qnefhY1LcBaUiWFNLZdc1EeugaRjWBte6ITk0q9hYZuvlhXHhXIODXMh +ysNKDWeYymofAclJPbzECQ8Md20H+xSfPSyqWyWlRjuWNZTERJUT5KafHsWNMzvaF/VBlfEYPpYh +lZ0J+AsBnNRP28OXre712dXP7d4V9J5v95CGgD5SZRXkYs4b7Uf7xz940QnLNcplk2VDmgnKt5cl +W+5Ktxdx/Syu469RsajStKdoLVlrV2mfl1uwujCYQXyUt65gRQtlsoe8rPQ0ox8mMMtnFVLS1Hf0 +Qb9zYuoNTDdds8nuzZRTKRuVss0xXhoMR93D5fy8ViUbYZH6GmoXlhnDVSoBnWieD5vdK8xmqahq +ahfIAAOr6X2Oq29vi1sPaV3NLXvOcFmtFtCQE3RIwzySmm4ZQrFYNC1zNF8+BxDRjI+7haIjiB3d +mGIuikWr1z34s3/4r9vto4cPpa0tR9EHgpgyrEN2oVHItyFUpYmopmh4xlzTWqrWtN1+GM9df6ob +3ZQUrLyAJCNLLmQHj7qk5JwQsJwvy5mqk2sJOCFTtVaUbLrjm9HiWXfyyI0WqoHx79BsUKNc2GFd +HyraxHAgpzcID0XvkJplHFlFHC2+zHuv651XcePGcPDCriw3NKMLEscvzfbTJL/2ggPc4OVpLiwW +ZIENAw/yOAzCgyS9Mqxd4FuSn8XZBSs0HbuHnBKkliD3dAfBNlKMWZafZ/UzFtGoZKenby13BPlh +uBvNIZXrk3zj+FNehMvTPX+eN89EUv0cwdCnGPggFbymqBlFW6qWg+wUDd0ZIoaLZbdSDRV1lGan +yDuoLIoKJLmDYVH0kaSA4NxSxVWNaXf0otm91PT2l9/8xaNnf6yaM0kZqNaUEZtlinhbRetRBPd8 +ZJxhr6AERC6plM2HW8L2tmZbE2ARQohcoq6Ns/gwjfd0fVAmO/WpNVJxzy0W+XJRAaqIKk5vBGyx +nDnNpNvbys7Oc+Qp6BIWr1iyGSrQlUYSzXCEzx/wDx6KPF8HKpZLTmFbK+MJTN22FmGwA9YuFOVK +xYCagiqD1hXFFk0nHBd323vr9QtRbJZKvunsE6MnNGgu46QWJWTbFaOI0aB925rlrRMvJOYIkoki +tWBMTauDvLqj13n7qWZODXOs6v0q5W8VpEJJZ9hUUjqwyRgNUY7IzkJaW7enqgF7OzadMcXHODiM +jyw1BQFJbclK3SQVsef15jEpT2P0car19kVUP4JAIvufB4skP2h2rlRrVCZFuDyYJrJLktxAKmkq +jM+kRT5H20OQV6s2OqjDJckgyrZhDk1zDE7Msj3DHJB6ZEzaHb9JGo+98CCtH6v6CPTkWb1O55Bi +PFFp1VtXSeMS74VeMHxSqKgQoqo+VpQucAbigaJzimkgVSvVoFjSacZttvc1s7ddVKq1wAkO4hzi +4TxtXMCOlW+3Z+TFBt66VLMgiR1vnXYuZmuyGAIdi3Sup/Nf/fHfnl99Cd8nAbucpWrNRLXrQ2DU +D1k20fVmo3NcrjjlioXcgRCStGmQXmWtm2JRc/Te/u5bUUgRSDUGAiOusXmj/3Rz/G0QLQvbnCpm +kpAhnTHs0N4QV1sFkxN6Uf0CMFgsGjzXQO8wqhgKTW2Qa0qFPGue9cYvKhWHqoW4iTzGeQ/BzLEp +5Fal5sLTQUc9eMBVKq4gNl13AXYzzRFL4hY60zOtOSfCwe0qxhw32ZjWuLRGB2Q52hxDF4lKx7QW +UQKDPIS/kJUG/KkfrAfjV/XWI17qM1ybYlq80CtXgxodQ04IkBN633Zn5IJtvYPjQ12TC1DVdqP7 +yPZXELcc3qWGAFZlOSS0q9Qtfxzl++PFq/bgqUI+XMuBkJbZ6Q9O5zsvmoMnkj7A436w0LU21BFE +qWv1dK1umRkpGSOnEKXkwyatLQhxtWKC2dNk7TpjTWtbzkTSBrzcAwvLeg8nyXChafVxnlG2D7lo +2jMEgGmPwmTNy7AMGTRwa/AsbV8gWjRzeVsCEjDSgcJEBgESbW8fR5O0jhfvVpnw888pAGBWPzHt +CQxguQo00AE7y82Hnb2vELScEDfb5zhDIKFqdCo1B6Ki0T7ZPfxw+vS3MMvo3XDyGiqRFeoUGyNO +AG7FkqXr3Shd1m595W32TQG/vAh155RKmoDIVzulogx1R/N1UYXkWMb5iXpbUxu2woLj5lIgjO1A +La8VZQLBgAg3TbLoVC7pLJ1sbQs0UtKZNftP8t7Nzbt/+N3v/m138PzhQwVohluxoEOYAd+qVYix +0WD0bDR/aZELqp315n0Qrlm2Xq6FZabOK50k3794/MNf/M3/SHY4FNucALE6zRqPLWeFIESyIJAk +pY1eWBbk6wFygeEw+BPLneiknMoUdq9Kp4o+d4NTLzipUgm56IKJOSGBLvKCDTAHWGE4E07MWYEs +oLUHj+wAx8cEgUwzVUW+4JdQkmLLG4b1zfr42zgHQE1Nd6ooDUPNHKtpWiAy8tlNu/+o3jjlhTrH +hY49sswuw1qlEg11yrA+JmW8eAMooNkQ6WaQL+N0GdqGGlGUlheu8+6TuHkOcKhSLiYaocUKkWYN +RLVHdE4GwDkM0z08gVx9ESxag+usdQHmQtJBStnuBt6NZUE0puvtdAYvdXuiGD0r2ClR4YMtnmMC +xxlRlFWtqJWygve1nVlv9CxrnNyWY866w1PHg1JNDeCSMgTXQzAcP/7x6uWfNHuIuunB0UfkDoLc +T/Z1e450VpQB7DzDevDCtjP2/CVUHOIEKo4Xcknpy2oPKujhQ6ZYVEAcpYpTqXmcmJH04TMYgbx9 +JcttyPUwPFK1qUgmN67V7O0tenubY6hQFnuAX1nvt0fPz1/8+fL4+/HqHbRltRo9eABaJF8NgPVj +mciyx0l2NBy/hMEE+8NxQJUdnX6bZofVWsgILad+tTr9/uvf/NPf/Nk/++LL31NcLIgNyDn4GstZ +AGQQVLfVRVeWt1AM8F1YqgYVUjyuDTuM5MI5w76JahvIKdyu29OECtuISU0fQBqxQiJKTXBWSkps +PNfMEcUmqt6rMR7FgigHqjbXjAVyX1KHvIAAaxvkE+06kE3WJ4PZ68HiFTL9tl8xVBzLh8AZTkgZ +DgA1crw9x10BPeDjymVZU5sSqXiLkRwZ8AXNR93RF6raq4LcC5JMeLMhSIlidFR7ZHg7TrBnOguG +D6s1ndSNSvcnq3f95RvNngtKlyx08JGiN2WNXNUGOwkfMVx8NVp8JcitQlGqVCxJbglSStEOlAMv +dU0PAdlTNcxyvLXFVcoqQ76woJMvshmAkRFeaLojP5oJcmq5g3b/RZI/ivNjN5zCAYlaC1Dp+bNm +54RmfY5Po+zEjVYAPY6tV8pOsaRQlK2pLbjCrQc0SN9xZ6Y1o7lmsQLlZhNFx0CWyFvbEoSuorY1 +HbJqRzdnstK+rcoK2PELBblWdRgmrlFkk0OYI1UZ+f4hZsf2l1601kzQULxV1LeLniCNLGecZuDl +nXIZw1i37ZEoN0GphbIj613Ln9veKk6PgD+AL2i5ODuP032yL72S16oWI7Rldaxq4woJIQc3iolc +bwG/A2x0M7JeVKWgkexiGXIr0a0dOzwyvbVuLzERDMSe0EBAsnxWpQLcwHeaQfb4FcSEYV1e9Pnb +JCLfF9O6CEX4cVg5KNvx9O3ly380O/4B8hUCGJEjyXhtRzFalj/rzd+l3Rs7Wkt6HzBbg8yoeRgQ +EB/EsCQNbffYC6/i+pWoEPAvlERN7/UGz5udG9vfY/imoPThghv1A9seQOPBlvZHTzrjV4IypNiM +l1qQ2a3uozDegfDDX11/uX/87eXNb01/TgsxxQe2D1u6A25C7xRtkDav8+4LNzxCthaKYrVmQH0B +ZJAjeDuMpOGsZX0KsefaQ+CMLDfT+mZ18Lo7faZau5zQLVdd2DrTGtwWznZZzvWD1Xj5xXT3w3T1 +npc7CINazQXqIpwARJWyS9OZ488EKauC4Aoy2fJRbopkmz6+WNTLFd92lr3pM4pPCyWtVNEB2hwP +r2Tj+WTZakthbxMfyQ56Zcj6ecewxrd+JK3UQpptiMoga16gp9sFDbax1bludp/5pOxFBH1bLCsV +UqejTVedhw95iopa3YuLZ9/3ZpeiPmaFFsOlLJeH8T6p6is27GDTm7xerr/nRJiXkaRORaVP+L1q +lyoYk1avd73a/3bv/Le92YcKFRVKFjkxNmMBa3JL1Ia2fxTVz+P81HTmwEYiDMp2jYZn7Hr+MaTa +7e76RD2Wq9ZtSZ0QiAdnLWlDSUWOd8JwlTdJsXtQbRAdt7pP/GAXhpQTfNPuJ81DxZmqziztPNq/ ++n3ee0Y+lSvrpLg2F7j2PEnPYCUsf237G8tZev6OKJA9xqs1p1J1gcD11pkX7d5+4D4Q5b7rrWAT +aD5nxY5p74wWHwaztwhCAA7ZcFiHVBtn+W5/+sSOdrvTF4uDj4uDb013jaTG1DSa5w== + + + vfFLxVhy4kA3J7qJXrQ4kZT14QXM/u5o+f7s2Z979VOKIXJClKAHJobdM5x22tpzoiNZJQsjSCsk +V6kMH0fWB8gW6NHMj9deuA8JZJgzQ59UKl6hqFKUz3M5+SmkSEyAv+0tdWNG0THQ6eEDytJ7CiHE +DAkOpdEePB5NXwDQapTGck49363nRw8e8gB/QWpU2YSXYFH7ZGm3eLsHpj52/f0gOsT76iZYoFWt +xo6zgcuuwZpti3gmxooVe6C/GpWWSvb2tiSysWm0yYcaSsfw9yabbw8vf24BBMDgchPyfr55l+SH +IP0yoIBvmc6eFx8BfKq0j0iQpGazedjrnfWGTzC2pUpUpVJgF7ClUNZqbCCovSA9b/SfBPmRas9k +9Jdr3Mr49NZitBQNgLwSlQnLt4oVUucIoKRbw6R5Gjcv09aVaU9lpQWdwAlkFiwXwngXcAQQtuyh +ZrRpPgDkIh/3zr+7fPtXbnKI6C0UtSpZwevpepsh6xgOuCZMTwHFnr8ulWC0VVhyhg1ltW7YA1ZI +gWk+WUeFSZzRTAzY1KyFbs39aCMoPbgty9u3vR24Bt2E4O8ljcPe7Obsyc8nT/447z/hpAHF1qFd +PW/ndiVqYvsHjfZVkB6Ieh+et0ywKw2jnRRSLTsQjQmv9DVzFiV4011ehkvqT3efme6SopMalVTp +RDXmMKcEqLmkVJIEMcqb+2n9yI9BLj2KhqFLeL4RhJsw3KsRQ90I4wMn2MjGiGWbhaJTKJocG9v6 +kKEDUu4Hnq511hs9ibMjiOca44bRajh6EviLzz6rQogGyTrrPPbiC92a0nS0tSVVa16SHlv2jGUj +hkmhJG1ALvjR23fcXcBdpWwJQg7VUQJiUBGvID0HPJdJXCrCO2g9J1g3+jf9+esk29P1kUKopF5v +7C13n7NMAESFGWHFlmLNaly9VPUoLqO5uq4NBDEW5RhMrRsrWdnhuF6NrlfpqFjRRbUj3V6tx0iZ +bI4b/ee7539ozd5B6iCuQD3Iyjg5GU4+uPH57ecvOdAMiQNUvy0xPzO9DaYbWo4gs9KuUV6V8hCW +ij7I2+TL1zSbILsnixfDxZUTDWSjC9CO649ARpKc6XqrRjtVynKcAV4Loq+QheWQrGYLeaNxLBtN +2+3sHr8P6jBcDUntk2+aV9waHbrhjm5DpaQMn0LA2+Emqp8R6cUhL0L02vFGQTxwvJ6otkD6O/s/ +ps0nmPTbUkeu5c1lvcMICStmcfPw+Or7zcnXSbZrGi2oEddbDuavZIMkFMXksDmWtztavM6awAGX +gsDmcgSn4a4Va15jMeBQSrqmd+JkBfujW0ugou0drPZ/COMjCGBJapcrUFl905yJEux2k+NbqrZU +9ZXjbmg6frjFV6qWbowqNR82SlAGnenTfPS6M3qrm/OtbWVrS8bIw3ypxpAWmjgC0iqIT1wQhNqH +KdguKoLUAauq2pBmUic8skKATAc0yjEJMLNacW7V+KBcdktFq0ZBz5DP/SEkZLXJsNF2QYZ/NIyZ +7czJxx8ikDZsNk4EyDzarQlplU0ZoYksVrRFnJwxbKxqXQORoA8qtXi76FaroNRWEB/EzVNJ73Jy +nXx9wF4MJq835z9lvWvoDXIdC5+RWRPrImSV0DGcI9s/N92NakBgJLdrsL0kO98/AyZcQ1RDhpUh +8FjocFhyxFgAJV9vPe+PPwTZHkcuA7M5PpLUrmIOGSEtV3WaS7zowHQXstp6uC2SK46qpIYaGB/U +wKBrQo4ED7Jj2Rpvl0xeaCHvqrVYlNowgCA4WR9nrWtY9ULFAgiHyUFcv4TeCOKV6494MfKcQZZt +yLqEOy9T0XbJKdcCQI1mDinOK1N2XN/sHr49e/LD7fXbTqkCIRp67qLZPufFHI4mig+z/CJtXHjR +HuLnwYMqRbmaAQOb0EJuBcf1zpvB/GvLW5HPrZhwuyDRjI8pU4gKCgrQ0gUFMOt4K9ud02wEhG91 +LuDvtgpGqRpRXHOrZGNqoGyDcM8nV6ecwSAzQkbxnWItLVRiSZl3R68a7RP4C46LwFP7p99dv/qL +Vu8xvNh20dguWhzfALoSs1bxdGv26ut/uTj+SbUXhZJTLJiGOW13nkDl/tF/Xv78AS9Kvc3jP9+7 ++JUf7uI8wTgYB93qI7ArtQhSQdLWzf4X7777+zh7ZLjLGo+TyYEtjAirAt01V4wdZEcY75pOl2JM +zHilGvNs17H3Jot3RrCoMF6arY8vf+TkjqT1RaNbhYYRepBtyFPV6JOq0EIGTdsbfRwvvk8al5C7 +kEACnzrwsMnai3CQbLsChdzzvPNm663jHxdLEJ8+OtgavEyaTwStV2aC8u01IWS0S3KhqPB8FmeX +efcZzrxKe9tFlRhtNoEEhS7VnGXee3pw8aez/e+d+KiKtyiYitwrl73tbfLpCYaUE9tBcnr9+q8n +q48UXJI1bHSv6q0njr+BPSzVnFLN041xSAoxx7APZDVMHdSbl/UWZqRP1mEEggOK3hWUBiviblOQ ++6LcVdQOsUIVm+Hgp6YQ+TQb426lavN8ahgj25mQC4+tkRcfNwcvs9YVWLJAlsSh3n0of4YhWyFB +rhcLKi/kngervob7K1Ugn8Ik3UCcFwq6Ya5Wp78K83PTWqvqBGMS+dNB/4DnnYdbrKhOTfckbb0c +z7+1vHW5Zm9tiWmye379g2bBStifb4nFiuf4+1DLwAqYdMiqiHyv6tANdkpVC/nIigNVn49nH/ZP +f+aE5oPPyeoovIxijSFLHj6UYQEQNqqJ0TuDQatC3g+eYVRn66/D+kWxkvzv/4m0J/9/n8D/V+2+ +I3et3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty +19p9R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et +3XfkrrX7jty1dt+Ru9buO3LX2n1H7lq778hda/cduWvtviN3rd135K61+47ctXbfkbvW7jty19p9 +R+5au+/IXWv3Hblr7b4jd63dd+SutfuO3LV235G71u47ctfafUfuWrvvyF1r9x25a+2+I3et3Xfk +rrX7jty19uR/+0+krYX/RNofqerkw/PxzTc3n53NP1MHi/Qa9w9uvv7mxafP1p+p1/7g0zfjN8++ +efPlh5tPPwpNPBR4USL4By9uvhCMX54p4EnC5tObV28+4MHDZzdfvDAFB09t4f/Pjslxc3Lc4adv +v369d/MNXvLhlweHL/Ca/9vDxvGHDzfvXzwXbh8V8LAQRan5WSAM8P/Z9+SXF599i39CIbj97+xH +3Fnil7d46HshDIRd4fJRIDwnzz/4zM2DPBFuf7wnd+LUq2e/3F/9x/d/+Xf1H57//7x/+/wP/9fb +45+P/+EsQnIWt8M3ffPFi+Yvv9527v8cS8MkZzr7zB+/+O7NsxcHs6Fwtv7sUnBvR/O2I+SX/+h8 +6pEX1+thJjwSoiBEtzJyhNf/b19D/vzvX/fv/82FGGca1m9POhFuj/GZqt6eJ4mBppDFjSj87Gzx +nwkSKVrC8pGsthSto5CqLC2Ga4vKWDWnotzjebI3vyg3HXehm2PV6LNCVmNDvIoTM15qkCrKXKhp +TdMeBvHSDkiFLgWv1Ua6vaLYqFxRymWJpixSWsoe2cGu6a81eymZQ1aqV2nPD6eWO+CE3LSXnr8X +paeyMeH4tmLOBbnLsGmN8nmpLWlDRR/6yR6ntAtlk2ITTmrQbFCtuRyXWfY0To9Nf6mYA4oNOanO +SbFiNKqsI+nNIDuMGo/qvZd2dIiXU3xSY6MwPsj7T6LmeVg/SVvXprcW9X6NC2WtJyoYhKRSc8oV +g+U8XowUtSFrrXLVwHvxQqtKRzUmprhUICXdhqLSVvW+KLc5sVOvX4XxCSf1qkxUqjrlmkuzoeMt +THtSo90a5Wj60DCnpIweRYoaMWxk6ING44zhE44UleqXK/Z2QcFfaTqmGdxSWR3L+kSQh4LcL5Jy +QD4eZLmc43JFHUhyl2YSQWzX6IjsSM2lDJtRdEQxoa6PLHNKSu4wWanqbRUU3Iolo1xGRyJJrMsI +AMqvVi2ODYpFeWubL1X0KuVRTFSjYl7o8HwTR6tUcea+pHZpNi6W5FrNw0kWizrDpKLU54WeLI80 +Y2qYo/H4cdrYpWiT5XPdnHnx2nAmVcqtVkyGTnBASRtzUqdCRZWqpyhd31+5zoxjkyDYUfQezccI +CZbPVGOqmTNZzj13UKkauCE4HW9Ps1aiiuiaIThJQW8pr9VsXsycYJW2L92YlN8UtCElpLzYuHr0 +c3f0iBNTlk8tZ52334TZY1EZ0VxGkULlAcX4pCI97aO/pPavOqS5nObq5apTLJk4bTyB1CbSOoxQ +5+W25a6y5pP+6MXm5CteTWjeN5xZkJ+3xm+i5iPJnEv6GDNyevLTYvOBkfMK5Vnepjf+UO88l/SZ +qE8ZPq9RHoaR5VJShrFqbxfVKhWQEtyUXyhidjSaTQQEvNoVMOBCg+GbNNdkxQ6vtEgZT6mHMUQE +4ml4YY0OEKilskYqrJL6mWGNcisVm6r6NBUgwBBIHFtvZqdZelQoKIVtuVw2C0V1a1vEJKKznNiT +1RknDBiuq2s7hrEsVxxSFoPLRKmDKQMgMBzwYeL6G1ZIHxaEB1ssghOYYlkL05gjWcjRynatRnY0 +f7jFFgsix0SS1JeVgcDXtwsyToNlk1JZr1RNxFKNSgolr1qLKJqUmZLNBQGWqoleFDEIRZVlsyA8 +ieLzMDxVtVE9O/ru+787OH//+YOK6SxJlcX+tWKOyVbiSCKG1M0o12yyN3YNw5va/txyJiIiXGwc +Hn5ygnmF9goVXRRbWeM6ql+JUkMQo0rFuK2PNAfCMEKT4puiOna8TVI/NawJy/iOM663z5x4KRlt +SR9g5DVr5kd7O7tf+NGKE1KEpRceuvGxpE9oJuelDsOTeLvdX1wpo0eMjwTkReROS5SGQDZR7HNC +VqVsUvNEayLmWanhR0fj5XfzvW8Hyxeskkha0w7mVrg0wh3RmATpeX/8Nm9dTmcv6+0TIDDHpY6/ +CuvHhrvDyQNBRRf6HN8AvJAaqmUDUFAqO5zQvq3u62CCSmWT48lm+WXKK9EhhWnlB7w4dsJTXm2X +qjrG2XTXlVpQLFsPtzXgDMMmFA0ECwBTNEN+UjW/XDKKBbVUxFS6VC2wrYmmDRBRhYJaLGi/FEIv +FOUq5XNi27B2FW1H0RaOc2hZ6xqFqOjQpJBRzrCYgiEnDkx7nWRXgtJ+WOCLJYXlSEEwUWpzXB1Q +gNO+rRMbPXzIIbQqFZ1lQkHoszwgNKWoRJJGhj6S5YautZAI2yW7WA6B0hypQN5kxBED0OYTHHa7 +IBKs4+qqOsATBBGU1/f8TW/00k12Pn9Q1Z1hlJEiAzQpo9QBGrB8o3xLBEgrjIAg4Q== + + + gHWaTHHdMcer3TeK3qkxAS/mCqlbMmdFjKQNABGE3LanbrBkuFQ1+4LaEdU+h7xW+reVb504XvfG +N168E6Y7drSQ9L7uzKxghZ+i0uXFVp6f2MGsWNVLVYtlc91YCGIXEwoMITUTaMAX0t8pV70qlcnK +BEOt6qTGEcZWlFqS0tKMvm6PFYNsou9nZ3a0xyvtMD0Kko3mjJ1gpjiDrP14d//H3uQNxh85AjBx +rDEQdbuoIIQse9Vov8DsWM5KN0aC2ATskK33KQ/YVSybiAGGyUBAvACYSsF6FGZW6HHCSFZ3guQJ +Uobmkig6NNzdUtUtlKxCyQZb4SAAPYaLwGKC1EG+16oe0KlacXAjMVZUGfCa0LytFGQUS3al4iIS +HmzxtxXMEkUbVaiwXMGZ+JUqIDRTtCFGG4RIioABGOmAFVqSOsM8AtNkuc2wDvAHgV2jAUcxEJIH +jbLp1pZcLtmlkv7woUBRdVWb8sBboVurJbLUjcId35tuF2WcfKlCuK9aQ2x3VXPPj48dbwfgtrUt +lUoasGtrm9veFkUhbzfPDXvBSt1yzUNG0KxxW1y9jzkynDUrdhmeVJmGGNC0Nk2bHBcKckcx5o63 +74eYyi7HxyDH/vg1w9Ux12ANUhBDI0XScBwkl+3sJI0jqJ3tsg7QA9hq+gSx7fhLy5vX08M//OZf +nj39kZVTRoxlA5JsJ4iPs/yi2XmkGAPSCxyZjjm+q+oryzux3GPD3sPTOL6uKS3bW1boBGRdpRKM +pGnvGPZKtZZJcnRy+v1g/KTKkCrlXnTY6D5t9l80+s+dcBWF65+++ZugtSrWbJqUZethrCAPTHMG +eXOrUhyQi3RbgQ1Hxq1GiAD6p8kKja0CWybVw2KapG27WHartZRmGpY1N6zBVhHYYlWphmrsWe6h +5e4p+uy2qAsEG6bGKpdVUvqppFZqtgBmkXuYQZbJqtWgWgW5qOWyDgIiAqZkbhf0UtkFTiK0wCCA +rCIApCg9eEhBg5VKVqXiU1QEoMAUIGZAi9slpVg1aS5G0BrWSlaRFB0MOzJaEBA5AxwcOAPKKxT0 +QsGoVkOOaVTQi7LDMnGhIALEHm5JoC08n2GiLYKWGgOxR4OPHF7EsDQ4saUaMwyaJA+gwVgG2CXg +hRSFV2XFir5V0reKBno3GrwsVRToUmgGUghFyFmho1vrNL9O649dd6araaO+TvIjSesjwCCbRbXp +ONNGftboXlep0DT7mtGDXCSqQxnL2sy09xqd53EOHVuHLHGDHVHpSASUOm6wSZtn49mLT9/+l8vD +N5ycqdbI8FaGu4Jl+KVYmagOEeQAOuSFqo9sb9dy14o2NawluNJ2d3cWX8x2v6zQaZVOBamnG2PT +muG1ujWP48Ne95HtzRmBFEyWlB50YJie5Z0b09sJk/0PX/1VvXeCgK8xEbBOs+ZQ7EBU6GEgAMWk ++B2UwTIRqWBsToFLhEqEjiD1K1WnQqZbw61cBp4DK4aAzXpOCg4XShrihGFzim2Q6iV8S5SHsjLk ++Q5FZfjrVkEolRVoUYrygEuGPlaVviL3dG1C0Skwigar0lGhaJYrpHReuWwhxkolEzPLC41KzQW7 +bW/zFBUWi9bWFhhTpxmQEXIWItkHcXCgLb6JSBPFDvFfQhthRqZGaMpyF5oZx4R+wzFx/ggtiK4S +9DxwqWQQ9V7StrdVhBOh46L2C1IhfkSxDXqy3RWkGuQ9YgyHxYRyfFYpW9BsOCApl82G2xgEoSHI +bUVDHMalskqKxwIkhQaZC2Mnb73ojN453lpRWqbWXM6fDSZPeCmXtb6i9013Esa7rc6F5c+LZduy +x4Y1gsaLk2M/PPWDc+SsEx6LKuItUOV2q3depV2ocVHqtjrPR/N3s82H6d4XejhVzcFw+irIjqts +/bYiSi9IjpPG47R5rVtLnJJhjUlxUTqmWIBJJ4gPk/rlaPZF1DivMi0OWktsiqQjgNyh7a0sZ0kc +Jd/AwGrGELKfExthcjxZfvDTIyfaNHrnrFgvkRxsQsXBiYB5wSOQ9IoywhuBOApFXZFaUbyB+UVI +YEYg7SxnT1HHVAXZfYs8FRczzpLqRn1ZW+AnhLHANTEOWwW1UDJAWzg33K3VoM0axRIpJVQoYcpk +ivbhwTHXUKqmPs2SU02bVmrw0e6tI2sjPCplmKmgUrXxkmoNZg0eOa7WiNonBYHLkMReFZxYcaH8 +uVu1AHiU1SEmHX4BkWBac/yEQMJdvJFlL0AfIHEwYKVs03RSLJrb2xJwjIi6ogEkpClSWIagYhl2 +DFxsFRFgZRNvxDJ1xBJEHc9mujosVhBRIqJxe0uqkdLxXYhS0G6hrGPQGC4oFNjPP69AwYqQ3FQo +y8DPEUl/e8rLzRoh5dTSB73+Yy/exWEtZwfam1fqst5wvJ6qg7NCslaQHEPx1vNLzVzAGtNco1SL +Ga4JHRsEG9OdlilLkBGZXcuda9ZIc6ac2mPlVpAeTVdfBdkhDXDQx4KKuN1xoyPL39ftXdhtPL8G +ccJniASKjXRr4QQnmr3Hq1MBXkkeQMkAbG+LtTYpJkbyVmoQMy3HPSR1CCkbeAKyRn+huDhSJ7Yj +Kj3XW6f18xob1Rgfsp8mFX0hsMEpJqQFZlBTB2G4SyMNt0Vobxz/1nRHFYifEiY9hLMDgOCnIPYM +60DTd2G9Ba5dIllMCroil7e2YdC4SjVk6DYUMpl0itRjh59FuAKREBi3Yz7g+Fa5GkI7IUgUZQhl +LnCJoXQYxn+4RSMaEVcMk9M0eCoHQTN0asBc1+wHD2tFUk0XiBfwJKGgSxFmtmkuTGuJ2QGHQjMT +nX9b2BCPFAoyThtvQbpAuIzHDQBI1RKazhBvODEIbFA/oc6STmqKlm3INmQEaLedH50ffbNVlD9/ +QONQPJvbUMtOl+VccjIlcLq7XWAffF4sbrOANQoJUjYhI6EwMR2VmgGnD1FtGlPbmpv2BNMK+2zY +c0Frl2saJ4ayUjfMLvAqzE4sb1llfM2e00K9SKo81RFgYXwcpUeaOSpTDuwSK2bgxxobsFIdDk6z +lnnnpZ+c6c6CEbMg3keYYa5JpWh9mjRu2uN3ZrjPq6SELOKKlfIK4+FVTnRhBRcGIkfp1VjEUhAn +R160ge8gPq5qIzHBSjh53MVMIVtBjnCXmjGO8gs7PBBJlXVSgw7OzrSnhrdTYcKtkopHFLWP7MNY +SaT2MqlgL3A53mKLTAGFSYQioilf4FLkI2YcqQ1krlIOhhTRgnlnWaRkhpjZ2paJ8AZq0T4Ydpvo +FgP8QlRTyQSygVXBgLyQ14hnjAnzkkKyiDdYUQgtDXFVo+xSUdZVmKPRLVOjj/bWtlat+JhTuLOH +DyscG0pio0aqhPkFECgBGVuRh7a7B0wmLFwxfqm+S+qCMjG8LWAKofLgYXW7wCHwYHh5DtRmII9g +SAFfBG2k3IVZFlq3qx/CA1JhW0NfeLEOo0SqI7KhqjYqVXW7QG9v1wrbdK3qqErPsacc59FVzXP6 +UJiA3FrNJXpPyssIA86TlRyTBX4ngwNzXTHJ4ps5kfRejbIsdygoOR4hCzUQqBSBjqx5YzhLqIIw +29RYFwNeua0iW4VqFbMw2fPCteWMk9aRZPQFpasYE3jSKiJByPPWk0bvKSuCkTt59yaon6v2Arar +Supz9qL0LG6dA/Sg03R/UWECUvmzTKqugQ3D6ABIiy6Y9ghhAK1C1G/Vp+k48Pfr+YWs92jKbXZO +zWhcqqnFqlVC1xjClcPxq+Hyo2RNWT4Nkw0ngXegRjQoXkwlaCuNjgxjXChJ1arG8/F2gUemY7oR +AKSuKZ9SLChVYrgQLrJGRZDWYKti0S4UMV9tGLRqzaqQG1kWqxD1QuJwa1vBk1V1CpEAx0FzYZV2 +MIkPHxLBU6mAnlRBSGpVSxKSNFlQLIAOriG8hbUeVYuqFSCnVSgIkpiztA/gAmdRVEyTMrYZqVFJ +VnQxPhnevVhWSxWdlF4v4cR0MBTkU7GEXqg0491KLPHhQxY4DIy69QiO68y//PS3ZHFsiymVZMg8 +PIi4BRWWcHAq7HROu70DBFW1zMuCJwsx7OdttPhAKoHPuv1LeDG4UcTtLeIFJVIE2HPs0e3SilYu +uTQVMaSocqqoXbL0JDXG86eK2Xm4LRXhPYkkDmRt0Ow8UY2xY8/Ob35drCpkjYuFj66LYkPTewgt +y5l2mkcn1z/q3qR4GxiAaFHs+sHRYv1ja/iSk9qq1vezA0pIqkwI5pIh4/1No/ssbJyl0e6LV7+L +musH29wtPpPa4EhG09oVlSHsfHdwA/1cKJjQDLiLv9rOEjaZlHPnG/PVG9mqP9yqAitIAXmprujd +2erdbO+j5sxca7y797rCWA+3altbrCDmpNim3PW9XRAW0kSQUpYLb+lJrBBIIb4Y0c6LCc3YXgTc +Dn5Z6N7ahteDw23r0GA8hFBsO2NJaT14yD58yMCng0duSaeu6UuR6IeY4oJiWb7FEw2YA7cFhESm +Q2659jDOlsWqfrssBqMBgRcRkipatYojCblrTxmEkJCqag+2DkBKalaDyEDcbNztXohyDuxCRiAU +WaZRvU06iHNElCzGlokYQ2hJAORSEaKLvBC0Dke5f/yxTBmlgigwIQwIsGtri5x8uQJyydP6oRfM +igVWYG1Z9BkKzgI+xRKlpmlNAHeKPoJMKoFMy2ahAP9iM5gIKdeNHiAdFFwpeywiRExIYpJozKNg +rz+5kbU2QJ4lq39I8PBWMGc0WS+dnF7/VGFsUazr+kCSWsAxQWpyQsYJcbd1ePPmT914p0zkaIrc +MfSp66/rnUvFHFVu2VyxB0XKktRmlh9yUouBERYasj6cTW9+94f/erJ8gveVxTYPTKM8hKgkz23v +2HTWUeMRIw9gxywDCg1IC35P8L7QsZoy8MLdKuNghHUinNoU49KcB+zllQYv1f8Pkt7DS5LizBf9 +Bx7MtClflZXe+8zKqizvva/uau/99HhvYJjBDt4LFoQTkkAeOYSQQGZlkbcgIYFAaLUrIbfS7n17 +3z33vC9b5+TpM6YrMyK+7/uZiMioQnLqppvfGwjLIyPBMKLqZhOQFmI0Oga1I4BUU7QaWB7AnBCi +BoNSCDGAFODO0HFNru8cvyOAglsn9takNPgZCllAfwA1utFYWrm2WF0HThkZCbhcGGQCkMvoOA3Y +CzEiqDSAA+g64FNAG9DG42PY6CgKio5nSopcI5nkmIcFxgSc3D+KAYMAKdNEgiaSPJtXlBoajhha +3ecXAXb27w94oeOOTragTk2rR9L2P2HQ7ab27CHt+ESg75Am8ElRyO59FzdIRCdzIMFAEMIFAYIB +HBkNgaMRuQrA49VXuUZH4OZgBjMAtuAawEKOjWFeR0pR8Gj4czBgAnbtLSJwQQS0rrh/FAWMAmYM +hy0EnHgoAm5ldMxJ4HEHuGgkrCOIwdDZqDVk5TqIfOc7NoOq31kRE0KoCUlF0hlOLA== + + + g4Wk2FwIjSpaS4sNMBLMe4Kk0yhhE1RC1WoEkx7zAp2JjuT2is6XDANDeVngYopOwzjD/YNYDCOT +AIbjHrh5TFJaieySlV0RjD5Cpjx+GYDXMeNedtzLYWQK3CiKZ0m2EUQzijpUtD6IK4+fh3hBC2Hc +3B5wW4YjlX2K2wcJg4yMBuBnGNqpDyL2MBJt2okOiBxQOCyE0hUaHQvCX2EoeL5B0mWcAr+pg1QO +hlS3l3aqCfwvk4ZENYwpO7c87iw5MVBQY2MwyFDd6Pg45vVyNJcT1DrJ5J3Zp4DocZMuFw6BgOgH +nRkz2+MzQOTjeFFWZxEs4VhCLyguCAcHwt7jdebucKpkRBfATThMvfcN86MAEeNU0Cf4PEI4ZJp6 +C5LB61UBk0NB4EfO55XBj3j9zroYwxTgd/aDzB4l4Ll+v/PdyKOOdCQctws46aza4IA8LJ1xPIhz +EXB5fRKKpSFJALJCQXCjIpQeeOTRMcqxqD6nMQxVBKJ3j7M8ld8/gl51Fegu5+u1HXHiBurHHAh1 +JjRooOMA9BTLAmwCeDqTHuOQWqbzBc5+SCQVqNbhGqFK07kAKBZEZ/ksSkR9QT0QjvlDiRCa082F +eGZbj8+DYcGJBNAowAjkMEA0kKA3YPqDFrA2PDQcirBM1huUKDrBMBmaLevWrKxPIEQcLDxodQwc +NBYNoRavzmn2pmAMQ+AWg5EQmgw78wyWJ8D6QRwSmXhqg5c7oXDKGzCgtMOYDdgC5Q/9CgZBxZVx +55ve425ngohxPLiHA6Ql2BRCRMJkDEHBkdmOrvY7xRhCdAQzfQHITx2cBThWBEsBCzuriuEokDVI +TejRnrXPkEwFCSfRcML5uvuRkNcDw4iPjPiAPb0BDfRkAImhju6SAFIgoEAQ42OEQ0PgE/1wwxSK +Q+7FvIEYiuUoMh8ISk567E2WQoyCYTsMTwfliSYEvukFwTOGhwJqCESji/a6gZLywZAdDEZ8PlCb +kDAgmC3IWwQFAZ+TxKbAlQEifB7Z7XK+MPmqq8ZBRI07mofYPwKF5kyluh3za4Ld8Dleg9k3ggKK +ulyiywXNlnWtAQGCrA4H9KDfWUgFMISOwKeA2tBQOqJMgdkcGQHBRoE1vnpfEADc65WcCTpgWzCP +PsDSOEUVAFKA+l3jPHwQwxIeZyqDcDs4YxB4TpJaMMLQAIpMWtFeCDOciXfEJpmGpM5E4+uc3AYj +BqNhmH1671uLIdwkmeS4Esc3CDILZDHuYiksFY1MeAIA0Qxwsah2M6VdPToL+eP1a4LSI9mqU48+ +WbWWRGMaIdIQrDCWFNW+EpmhGVDCUU4qoniSE+sBxHS+IjgETj9BMYUQAgNFgt4DYePxRTx+y+3T +3V5gNJskQf9kIE+gKBDCImhQVpUA+LuAOj5Oelw84yChOToeBhJkhBLFF7wBwCtnwpAX25LS9znI +KQSc1UCg3QS4+1Ao5nJLoJMRqCAfNzIaBP/lfH069BRYA4bOp4VDQAqW2y3t3xeC8gf5DWpkzJn1 +Ag7SKKauKDOi1Hdmiqh8GIUGoI7L8/KA6qgjqJK8UPf7hFBApHB7bBQZAe82SpFYGT4CjOnUPqhf +nwJiIxA0QDsBN/l9Jook4CcSsKHQrr7aDew2PuasTu7bF7zqKv+Y4zoBOlQAk3HAlqAFfL1vP4Yg +iWAQRi8eCiVVtUXToGktiasEA/o/paN7nIGsCwUi4FnCoejICOZ2nCYO8OVxC5I8gFHam75goZAh +zVzOQgPwsuh2wmQGAqBUI6PQyDEamAii7HY7ixEgxjyg96iSoLSdzSdeHiPSGJEJhCNgSUbGccBD +qB3N7AHNeZ2NJWYgBBwKyQm8wKNojCJzHFthBVD1WBCRIMokl8EYZ6mIBgEv1hmxEXAmi0DbAIAI +cNtxNw2ECIIWZ8phqugP2O3CVmdw0A3E5xEgk4HCOGcvEPCpNu70iLejfbezkKcgaI5mK6izkJrG +8Lw/ZMH4L8xfmF08Bx4NZNXoODhxCQtHCCweUVpo2Ag4Rj4OfL1/HBl1UTiZlZSOHpnhxRaoLJKy +SToxOo7vdyjAdHAjZDlXQHO24gR1goD/pZxVfr8MHh8kH0UUkFDS49GgZkMB3e0iwZqBKYNW7e0K +cGa3Rl3gB007Ms0yMbcb8FNxe6Fh9LgLqBZ+mUGCKoNHBSYD9OQGwQ+eCFLUBVQLmgdzNDACA1gE +YAHLGfBpOJIiAFrJAoakvR5h3z7fPiexScgE+INrjANTACLKD3YexjBgUnQVaMXtkeGnB2DQJY2M +g80U9xYgMpLYAtoCvwk9gsvZhwNgtR9xWgISDvrutAeSX4fSG3MIV0Sdr3YHKuFhNMA/4gRIDmfO +H7AFbgtmGfrudWIERIyNg8L3iHtTFlBu0tgYBWTnd75SHjIWcaadIQd88CkFwC0EDhRLEnQBdM74 +OBoKQQOAxCNBeNzeQjxoTsPoUXxm/zgGLMBwRYbNQ554fBqUs9en+xygJpCgROARaLDbpwDCUEyV +F5uJzLpiT4LogvxhuDIoB2ceBsp5DIMGIOEoiiXdHiWExIOh6BgkPETHzfn9OoJGNbNfbmxlS0vg +CJCQM+0DpA8ZFQoaIF/xsEWiMZbJwIAA7DhTsiDVPE5ic3yR5/IUk4Ec3pPB7N70vgmZD6QAUgqG +CBIGkAo0oSSWwU/BYPqhO85EujrqfJs6xEXx+eQ9smBhnPddHdh3tX98jPT7dCAOEug+oPg8PE1B +IHDHAgC9emC4BFDOXjcPYd2jdWZ0NLTvag9kKfyjzyNhoShNZ/ckGU8RCZCOwM7gbcGcwiMgnUZG +cHiEs2rgkCA81z2yD25O4GEdQ4xAIOIL2N4A9LEyMk7tB+72gJePQPKTZFaU6pxY8wedFQ1nknkU +vfpqF1BtwCf5vcLoKKQ3dA0sIYxDaG92NBoKRwIBxYFEPwiDKIbbzv6okOP7IMfA8wacuVzdmQFz +ChDIVxofZ6HSof2QqCEkEkQjLp8IAwj5Bh+BYMGfQVUqajMSm1T0XsCZfpRAtoH99AXYQAj8kQn5 +z4JG1UDwp9x++DhrRYck7UwHOftYAEKdVWAImQqWUBCAtmJ78/MgXUDgZRE07sx/4glnx51XRlAb +kAriC/AISt5JJAc0ZChYii4Cc0EcQe1AQKEQwDxiVFrS24JcR8JpgizCZ0GBjEHyA+DgyUBAh/SA +MQEk8QaiIIkhjsEADJRB02lnFRtJEEQBR5M+ZxUAGk8C3eytNdNgf0C1evwqjKQd6xWrq/sA2Tyg +e6N7e6Uo4KmxcVD+0t7qkgpBGRuF8ifgp7OiN4Lv34+5gMu8MuQJcByAQwC0rocBLQeFDBQG4fM5 +G8AgtYCGQLrgI/t9I/shOQnw8mNOT5WoOYUTxtVXj+272uV1ObkEDQNYAMZ07a0ngnaC/wLTAX+A +m8BTEGfDSYViSiDVAMb3jZLgkR37s+cdgOygtb4A0LodRhKgVQD90JAV8In794EFxh2JCFnk00A4 +kbSzCwWnUiB1QmErjKf3VoqdxTuaz/NqnZWrLseKgmTVHSWJJ+BywuSGvNVC8CnHiCneoOIoecTR +OYyzhTKFhC2KSotiXpSLLF8O4xmCyhLOTFQhjOmqXtOMLhjkcDgKYRr3CuNeHvR5rX6I4dLg0ENh +fczD7Xe6JnlALTgL+nlnJyeZCTvbNrT9Y+zIGBtEHKUE3grQG5g0jKdorhQm7P2jIfDO4y4aMBNo +GsUzoJbDaBaS2eMFB0EBg4fxZK54IF/cZdgmhjtriFA4zhYUj7N0srfVk9nbaxcLhZNglMCwA/RB +ZXkc9FD8gRhNVTgW6CMCiedMO+xttnFmsEfw8TFntyd0TRDLnFyFGO3NZMqOTx8lfGAMfVGvDxyK +s9XE48yCymNj7P79KLDYnh6G1GLdoHwCzhRoGIkwZNrvY1zjAGsG8Ck4OOAaf8DZUIphMfc4fvVV +kEKesVEMEBjyH7QfhuXBfzmGYjRIhJ3tDUBernFmb+ew6nXWwaGPGHR5b3GKAK3id0xoJBCKOp3y +Ods/3M48P3XVVd59V/mdVjkUFkHCcdTZvWbDHwhIibAOaTnqlI/wz9QKBG1WqOnRCVlvS1pNi3YJ +Blx8kRZqrFhTIwPDnrVSSyE8G3Q2loABBCOcg+A6a68IVH0SQQHNZAeOsCjkJyuAT89CrCG+rACE +VaOYlCiVZLVFMiWKKeLOonmGF6rl8k46syxIFTDyzuxTEBxZHLQQiGRwQySVAdvuCYLwYKH2IXNC +aJzmy6zUYMQ6mDVQ43trvuLeTtccSqS8oJDRhKT1rcQ8xjiz3ECdnj3cG3VxYCdZscUIXWDYEWfS +EpBN46QKK5ahteNuMGJmEHH2rzJ8CVgV3CUgOWQXgHDA2d4DBqQJfQ+iNiQbqB2WzRBkLoymIWnB +5fkRSBJwARG3M1ntYIJDiEDcSAQjUiFosN/0hQyP39nAADozCE7ZB6Vqu31GmMhwQg1Uq8erOXOM +XmFv7wEJqglkLRhPBIkReIrEk5BX0B6vs4bu8I6ztBSG+MbBibsc2wucCzACcoX0esGdaYCKGArw +Avwek8SC20MB8FJ0UjO7UAiAn5CWBJ0Duet3zFGU5zPO3mavBIGGCGJkIUxk/c4G2siog3iQPM6y +IxCKAyMhA4BC1vu62TciPQg3OGi/z0lXZyk2YEIcKQ5GuJoqzmt2D9yQGunSYpWAlFDr0eRsprpj +JudpvuIs8iKaEe1RXAnwAXdmBpIQHUGpUnxONpoEleKlim4PGNHZnscIVS06kcguxlJTstnFmQJQ +mKJ2NJBVTJ6kC3u/U+Llciq/yIjFAGpBR0iuzkpdXu3RYjMMsSNTnFgx4xMARHp02ogvklwlhCdI +tkxAotI5AIS9dcloIGyipA0XJ5UkraVZQ8UY0FyFJPMYngHq9DlTFinE2bgog64OgLbEILLAy6Au +TGcZBUvADeEiGfiIszfeHwKcESk6BQkcQqMUWwIfStI5zejIYMb5IkFlSDYfxGwX8BpkIJaQ9K6g +NsNEwomRX3XWQPE4BrdlgAIastEh2DxOZ6CdGBUDFYHgMU4qi2oTSg+agZIpeBDQKySw3y+HgkoY +ARulUmSGonIUDBoBww4gnIIeQbp6QZH6VfgI/BX+V5GbQBYA9W6f6myw8enA4OBWGCan6nUr2dei +TcWslNrraqTv7P8JRgm6SDJVjMwxXM7Uq6bRxKiUPxyByPqcbWA83B+645AaAnqJCwRFWSsiqE7R +MZbPgYQGHweGXRD7zsY5HkYvDpoEuC8UjhFOgGpmcoJVaorVN+OTvFoVVMCutGRU0uXFdHVV1BuQ +A7JarHcP8EoNBX0olKHk1UhPMlqsXOYUx+ulMrOl5gbF5YIAQXxFjw4gr6KpKSs1RwkNimsC1eJk +BCUgyhbgg251Vasj6k3IFh8S4ZQGxedJLseIVV7tqrFZ3Z6NJOZlcyBK5XrniG5Pew== + + + QybBFIzYrGHDvw9lo08wmTARg1TBnb3xOrAtzSQTmdlsedVOzyQyc7LWAVTxBgxGqJBMLuDsYDT2 +tkYoYN9AbO8t/grOyx1olCBTDFsyIkNeqdNCnpdLmtWhhWwIMxmxBF2GS9Q7MFDxzIKVmFJjXZzL +joJ5RyyazXNSTdS78NPpoFjWrX61fcDOz3N6M5KctlKzEWcLdzuen48kepBdDJ9M5iZzlaVIYrC3 +sv/PzfYpgs1IcgXFgQ15IL69NwJygtICNnEIxeo7WUpnMBrwHAYTPpiStXaxupmvbVJ8GaAGozLg +0J0l+5CC4TFZr6cqS9n6emPy8Pz2pXR1k+RLtAhaKO/yghDK01xZ0zulymYyvwwdZMWKb29CIBw2 +SSYN6oh0dvAWrPhEIjcXSUwoWtl5YQeDTKgTVD7kbFHLKmbXiA84Bfil5rySQyYJJi3odV5rS0bP +sCfT5ZVCc102y5JRjCR7RqKvJ/pWZkqONKPpoWi2WKXCSEVAEorLMGJeUGvwqWRmaWLm7MT86URu +VrW6jFyDWKhmU7PaifxyJL2Wrx+DMcEIcB+AHhGCTipGA+hYj0/TUoMSa8nihmp2JK3KSpDYRS02 +LZkTgtbjlU48MTmYPa1YPXdAhcBFE/N6bJpXWrzShCSHX6b4gmx0Q5jhCwqQvapZ1WONWNrpi5Wa +AcWIMxlRa/gRI+xArkPZgACQY4BaNFfwO2/ExDEiEQrDvxix5HymvJ4sLSfyC3DBcEE3oYIwOk2J +BclsS2YnXVyNZxcgWJLR8AZkFLNoGsDEZviqZk5Ahcaz86Xm7tzGjdn6BgxvND2nx4YQ+sb08cbM +8XR1WbXa0Xi7N32gP3e00t2EVAEkFLQmq1ThEVqkxYmFbHYGIBRSS1QbcHGSQyXV7sF8fdO0B5Xm +SjTVC4QNlEwoRjuRnU9X1zOQXWI5iMaMaAejbbeXImjbtAGy2unSSnfu7NzOjcnyWqY4v7J9rWb2 +/MGkZEwpkaEamUxllxsTpyLJBcjVcTeDIAaBRyW1bGdnjMRULLPQmDyRb+xAHGPJfqO1SvOlYAi0 +GWjsNMs3DXsuWdoutY4pZj9bWIQCAUNHMlndnknkN2rdEyu7dxw98y+Lq+eXt89HUgMl0sxUlzO1 +1UhqMlNZnpg/N79zk5WZJrkMwSYYPm3EugBQpfaBWv9gLD29untzY3iQlAskn9WtZjTZz9TWzMxy +rLguxyflaC9TXUNJ0xfkGD5jp2dL3WOlwYlC72ihe9TOLPZnjidyA9WqJIqLRnwakMpMzGTLK43h +EfigpEGudvxhDaPjDERZa2iRbiQxlavtlNtHaCHHilnNrKKkzghxWa8k8ouF1nahud3oHZ6YOQMS +TtSagtoCvIXuW4mZRHah1Nitdo8l8xuAtMCVYTwmyNVocjpZWjLik4rV1exBPDcnmk1CKAhGW4p0 +NHsyVVyFEW5MHhPVGoabFGWjCBgBlaSLkeh0Z+ZEbWK33NltTp/OVVc3Dl4HIwPsKaj1Ymd7ZvPi +yuEb1o/cOLt0yoq3VaOWLS/TfJGVqpRQUaxBb/ZCfXCk0NicnD8HhR8MG6xcABQ1E1PFxnZv7lRn +7mRjsHvw9G3d6UNatIXTCc55q2XGzi9VJ49ma1vxzHxj4hhKJ1BMicVbgpTz+hhOzBYbm3MHbprb +vrx76rYH3vc5IzpQzenB0g2ZyjbJVmi+rliTjNgIO9uWdECqIKICFUaTHTs7lSoBPmxHkjM4ky1W +lp795Ndi2Vm3j49EO4Pp0xEb4gXAeCSWXQHg3TpwAynkvQFFAmWVmi23Dlc7xzszZ6u93SMnbjt1 +/b+IRjOVWxwuXZjbuDi7fqEzc2xm6/LS4VunZs88/OTzxTbAbyaRHpRaB+qDY63h8Ymlc7PbN7SG +B5fWTm2fvhWItT9zcPHA5UL7kJ6c6c6dWT5yV2V4zrRbqVJfiVZw2ha0lpGYjpdW48Wlcne3Ojhk +pfutqY1sc0WLdsz4gFWKkUQ/lh7GUsPJhcu56jbJJwS9mMhNCxooq5qDw/YwkphJFtZq3WP1wdFo +shVLdhSzYaWG2epqurRcbm22Jw7snrhlaesioKWoVvKNjfbkkeHS2dbEkUr7YLa2oxi96enTs6vX +oITFihlIiVr/aKm1k6muT69cXFy//vKVx7pTR8NUCnLeSi1A2sezS0ZiOZbdbU5ekJU6jts0l2fF +fKY0ZyYHqdKClZpM5GaqnR3F7ACLWclpWa+mC7PVzla2vKRHaiyfBjbsTJ3So/10cQFaK2r1TGmx +1N6083OUWDeTk43Bdr62KGnFQnMtEu9kSzPdmaOFxrqdGdZ6m3c88EG4lazXhotnFnZu7MyfLba3 +U4UFUe2AoK01dg4evydfWcRI1bCqje7G9OqZ2c1zg6UL8zu3aNYgEpvl5arby4A8iGZWJldu7M9f +zFQPZBq7aUdUTFXqS43OCoJpwbAJSluOThgOuc8kc4sOuuqlVm8rXZgDe65Gp+KlDSu7lGtsJPKz +/rDqD0qgvmg2phoNKz6dLq0W2zu1wYly/zj4vqg9TORn7Gyn2FzI1ZaTpXk7M5gZ7jz7iS/VB9so +admpwczyzTPLt0wtX57dvJwoLbba648+/IFHPvIFUCmTi6cXDtwysXxdY+r09PrlmY3rI4npi9fc +856nPmEX+m6/KGkdO71QbO0MV85tHb+9NXVkbv7o+5/9dKW3BTnQ7O+WWpuQcuuHrpy/4bHDF55M +5jamh7uLK2chPRSjbsYhqaazlY3e/Pn14/ceuua97ekzW9sXFleO8WrRSg5imRkt2jNi/UxpYePY +XZun7wdeiCUmIfFYMQd3kPQG2E+UKoTJfCq32p05QbFRTkqbdgdCDNJCt0GC9ruDQ3fd/8zUwnFa +zHdmL9YmThca2zMbl6rDc3pyVY/PsXwhkZynuCxOxRKpiWx5cXH74trhmwZLZwVQL0K51zt0+70f +EtV8Oj/Zmz7emzmrxgbQtkxpJVNeBVGayEzb6ckgqpJMDMAZOpUqri2sX3v+xkcBzLe3LmzvXiNr +pVRusthcK7cPTC2fP3Xdfbc/+H7AkM31k/c+/P6p1TPgiQg2C2YB/HKhdqI1fV17+kI0PrG9ffrc ++ZtS6SYFgbY6amwmkl5KFdYWtu+I51YwMm4lBsCnUAJaBBi/Hcst6dFevrJ0891P7p64PkxEQHRR +bLHUOZJrHjDiUxRbVtTW2bN33vvAM9FYT1SqkFHp+la+eWhq9XpWKoXxCMUkwriJ4bputmIpKLED +EKZy/1S8sEHT2cmJYxG7hhCCqGVyleVGb7c7PNAerE8vHJGMkjfI65FKtblbaR3OV7eAxTS7XWut +nr3mno3jNxJMvNzeLHYOpCqrnblz+c6ulZ6FKJ8/d8cNdzwSSTZdPlE1AZFmzMQAkrY7ewIGbWn5 +5Bde/tbE3DHNqK5uXjx27cPzB6+sHLrlyLn75ravqEbv2rO3X3/TozSfM2MDeGildaBQ26x2DwwW +zzWnjqvRzukzV9a2znJyvtBYK/d247nFZH6p3ju8cezuwfLlWGpufuk8KxfH3DRgvmqCrWszUhO8 +hmxMFKor+cKg2V6huIQGhJ6eBk6UzXYyu9CbPWUm+6yU78yd12JdTgYV0WaUmitkedG4oHYyxa0Q +FgE9mcoMI3anN3N4uHw6VVlhQEwyxVpt45a7njbsWqE2P7t+TXvqRDQ7r5h1NdKghAItlaEX8fQM +TluKWTLtrgVVE5+IJnvF6jIIp8WFo8urp0D5tAYHplfPTS6dm1w8NbV0rDe5Zdudhx966uvf/cnW +kesD4QjFZnmpCmmTqx3O1mDM5xg2c+WW93z0Ey9WqtMg4RoTJ6E0GsOzE8s3Ta9fARHI8qC9zpea +6z7nnWKdkyvlzqFcdX0we+rORz6xcfTGeLpfba0iqMlIZdnqsVIF6Kbc2D547NbNA5cVtdLsrhUa +i4yUI5gcLzWjiZlC/UCxtoWTth1tJ1KTJJuEoYukHHcmmxO8WLbjfYw0/CFWkJPp4tTE7NHNo7cU +O1vgLzx+yRvgSdaiuagZa2WKq/nGbnPq8Nz6xZ3Td8WAsORCtb2mRauKVdk5df/izk2V7m65udno +7wKehEkw9YZuT1B8muaSycI8pEF35tjk0sn+/GE90aLYiJ1qZyvzpe52c+pEZXBEjQ0pNp1K95KZ +SfACqtGMxSckMU8QlmW1W8Mj1cHBaGayPjhUaG7ySj6Vn4ZkEPWqZDQls0nxySBqYHj0zOnbnbd7 +xkmCTEK5OTpHBKVRIpgsxaWTmX69sw4UUGmsrRy8rTN9bSy9PjV3sTF1Qov36u3Ni7c9yWulf77Z +QTIFUe3Gcpv16esT+VVfSGX4VLm+Ch6qUF/vzZ8eLl+3uXv7+vbNldbBbHlN10snTt/andwOohrB +Z0k2w8mAvYtWehEAIZqe4aXU4SPXlctzFPhErZUtLcfSC8Bc0dR8qXUwmZyYXz6bry1D6gLkcmIO +QNIwGvXmaru/wcs5gkpQTBLSO2JPRNPzqjXIVdZSublMdjaVHEhSfmLqaKV3UItPSkZ7b1opjpEZ +WesurF9v2F0EjwI/atF+Z3iyPXW8PTzWmzqhGJ1iae7Cpft5PiHprUL7IBRFc3hy9fidC1sX8yAU +2ezlmx+cXz4SdAxpMppYEpQiydlBTANvpRktSamAIhXUshKdyFY3yt1DULDORk0yLsnFeKLlC7AI +qjrvU6tt1RoyfEuQQdK0fQGBpHTLrtrZbiwzyNZWwRZpsX62tBRLTupGqVlfXN29LlWZF7SKoFYV +sxWJDfXolJ1dyTd3OaUIdFyqrjQGB+uD3frkESHSwtjEXrrOYrSRy/WPnr3v4NkHa4PjmtXFKRiN +OHhz562fkOFykcGAIIg5oOZYZtJMDez8DMEnAVUm589ANHm5mC4stKdOAypW2+tmrM5JyWBY9fqE +YEj1+Eivn4vFB53Jo7Xe0db0NbHiMnhhlDT0SKPS2IkmZimuAqKdUwokl2j1t9rDgwhpQgPs+AzN +pgkqxmt1RmsDBjrzFZGWYXUQzKy2dhc2b8qW1su15f7U4URuAQIXi9RPnbo1nW37ECleWCq2Dvfm +Ls4s3xBNzrNyg+SyulE9c+q2fH6IE3axujK/ek17cDhbWsuWNjmpmk5PDadPkFQikZxc3719Yv5i +MrNoRvqR6ICXa9DTQnVJ1vIQKZZLJbIzsdRUf+r4/MYlUakH/EJEyz3wnqej0XYYi7JiUdEbit5K +5VYGs+cW1i6BYi8WJhc2rxH1WhjXMFyl6BiKRhHEIvAkSThzmytr12QrqyEMPLUeJqIIFg2G47zU +ko2+2yvu24+A1zYiw3EX7uxtC6ugPGWjKchlVSrubF1KVWcRSsdZm2CSkNVGdNKw+iyX8Hpohk5F +4kMlOkjmoXAWCLoAFBxCdJZNymqOF+xsfmgm+mqsZ+cXGxOH7eQgneofOnhpYf00Jw== + + + J2guni3OTs6enF48X3TsxrQS6RBsCsazWF4CQhcV4IuDi5s3T86fPXD0zs3Dt8lGoVaeOHrqlmJj +Eegm5CwdOhNrifRCJg+evRBEIrxQwMhIMMiLcrbaOzC3eXkwewLs1cETD8wsXcxmp7Y2r52YPSXp +VU4uwIDAfVDSNo1JgS8HnQVNiROSulUDRR3JzONciRbLYNihBEStitMxXio0u0fTeQeHRcVREf6A +iBOWqla9bnx8POSgRGJYqm/VOgfSIL/ZNMkkm92DE7NnoBBoPgUyoFDfSReXneNTxHQYhzFPJ3JT +olZmxcKe+K/Y6fl6Z3c4e06Uq2HUoKi4He9BLUO9i0oFtAqY5Uh8RhAqGBpl+YxiNGmhRAsV0x52 +hicW1m+YXb2+3NwBLvD6WSQshcICRpiskLdSU7nyMoyDoVciVt3t4eAfoXwA1WWtxrA5lssLQglD +tOnB+oXr7scoY3Q0EPQzDBk1QSbZfRyP+by8IuVe/tfvLy8d8ngIAtftFNxhOZ5ayZe28+VN57AI +D5NITICOcntoGFgUhBbUnZyTjbIVrW9unS125xBKZqR4NN01k205AhHJQwexsJ5KDq14H7iMZOMw +5ghmkHSc4bKKXhedQUsdPHy50l4xE21OK1FiiuZsPVIqgt2zagShmXqp3l6rNpaMaB2jIp6AAPAL +5i5T2khkZqBSNKtdbB6YXj4LQqXUWDTjDYzWJiaXj567WY0UxtwUK9TlyKQZm9KMBoxPELVAsuYr +m7KZRxBW03P1/vbEwqnl7eumls+1J3djyW4q1T5//uYT5293+3mKzcl6VzX68dSsJFYwzEIhiHSM +ZmyIAuS2HO2JxkCxhoX64Ur7OMXn/CHBtEqp7FBSs9Bf0KWCWBSEosAVsHDEM44GvDhJGLyYNaNd +cGqgLhA0omgNM9pXzUYAkXOV+Wx9LZab5ZQcmCYMj0SsRrO7C/bQ42W8XpYXS1C86dx8rbmTSM3s +vQLD0kyyWFlxeyhBzsaS/Xp/V4n2GLEQCmvBkAw8SDA2SsbMxFR35txw8UJ/+mS+ss4K1RBqw8hA +e0IIj2IKJ2Ti2Zn57Rt6M+fi6QVBKcPNcTrKq3lBzUlqyYz0MrmFXH5ZBQXFJWU55/KQrnEs5Gcw +RGTpeDAgOZsJfbyuls+eujmfbLnHcY5JmvZAkCuSVOW4LEUnvV4BQ61CfpHni4Jc9AfZMAY1G49n +HMvfW9gs9WaL3enOzPLqoZNbp85NbR42MjXByMfTE5FIOx6f4PiML8ihmMyylqbno/GmnW7rsbIR +r+RrE5dufmD54Nl8c8iqKV7PJXKt1tRqvD6FEAr8frk0jCebPj8piIA8oHzUYnWtPnHCyi6QQko1 +0vnG0Mq2rGydNzMoF+G0RDRf7K2sFCcXaC1Bi3FnelzMhFBl3BUMIgIkdqa40Bkelc00wyqSFo+k +6pxiq1bWTFZFMxfPtqYW1hcPHIkWmjhnmXYvmpjae09BHRtDxsfCSEjOF+fTORA5UD4RKORsbS2S +mgGXRIk5jIlTgp0sNBUrEyKlMK0Jer7W22G4vM8nuMbCRFgR2bjApUjSQsJqAFEw0tLMhpWZoaUi +EAfFRA+fvLR++Hws1/SEyACmGPYglpqmucz4OOZy4V4fS5BRik74/M5JCIGgJilAqROp/GIsMaXq +lSOnLm8cPF1sTTNSwhtiQSEYyZYYKSOkysvxYnNZ1Cq8UoaUBo6muXJ34uzM4iXL7vkCDKSWIGWS +uaEaKclGVTXqulkzYrVqb7U6WLMzrUxhMltcKlTWk+lZr5vdd7V3ZATh+Kwd6yJBfnTEPz6GBv2q +ptbrjc1iaY0Xyh4P53aRJBWR9OLIeHjUFR53E7xUz5cPZrJrAlcKBlTTamh6tlLpra0f2j14+prL +V+5/5L2PPfPMx1/49De+860333z7r//5j3f+/U+v/PBnt9/7WG96F9rm2dsDxtLJEmjdUr/dmOlN +rMzMrmwdOHL+2ssPPPLeOx969Mb7Hzhz0y2Xbrvr9ve89+57Hvnii1/+3Je+tH3o5O6h87XWHCgB +iokZ0VrEbgpKKhLJNZqTC0vrWzsHz1xz/ua773jP4+996mMfvfGBhy7edt9dDz/54U9/8uWvf/Vr +3/3Bl7/5nfd/9NMbh85okTxJm0hYYCgjYTcy2bZuxjP56tTsyvqBE4ubh/qzC3NrW0s7Rw+fvubJ +pz/4s1d//pvfvv3SN75x4+33Ts/tZHM9BFGQgIYiJkPFs5lho7HGsnG/n1Pk9OTMVndqrdyay9WG +5c7coVM33HzXe+5/5PHPvfTSfY8+cfuD773r0SetZBOkFMBdKCAqYkFVarrRVrUKw9qJdDNX6tSa +/e7E0tLasdPXXHnsfc88+fTT3/zu9375xptf/ua3Lt9619Lq8UZzQVaLKGaFUR0gSBAzoGbhhsGg +QlGJdHamNdjOliez5f7Z6256/8c//sSHP3Tnex584L1P3XHvQ1fuvv/Bx9/35W9/90PPPXf3fQ+c +uXybpBXDYQUJiTwfN61WMjWta/VsbjIarWYyvW5v5eCxC/OLC2fOX3vtDbfcfPudL3zhi7//45// +/d0///HdP73x1ltPP/uxWm163EW5XBwUXSIxVypt+n2Kz8vgqKIqBY4vYHgMx02OTwhiqlDoHT16 +/vItd569dOWO+x9+4gPPnDxz/dTi6c7kIVUrOXtZr0Jk3p7szO1sHL5w+sKVG294/1PvffmlF3/5 ++q/e/t1vX/vVL954443/+vvff/v7f/vyv37tmY98bPf4tfXeARSP42g0Ca5cz+YShQmwEEfOXbz2 ++puv3PrEE0986atf+8o3v/2pL7z47HMf/9q3vvXqr3/z4stf+e63X/n73//+0tdeef9HPnPmutuy +hWGltjgxs1NpzVl2qVRsrC4vXX/p3MMP3v3hD7//U5/9xDe/+80333nnu6/+7MuvvPK9n/78T3/6 +8//5v//3z/8JLfn9d3/ykwefeHowuxNP9QAwWUZL2fl2Y7C1tQ3X4SNHr9x++wc+9MzzL37mo5/9 +5DOf+uTzL73441d/+qtf//IP//G7//nf//Pmb9959iMfv3zjneXKtCZVBaaYiE+Va5sEaZOYZpt5 +AO6jR47fceddjzz+xCNPf+Dhp55+6avf+NHPX/3Ja6/++W9//st//uPXv/ntb3/3u5e+/PUjx28s +lhdluRa1JiS5Es8M7WSn31taXz948tS5B95z/+NPv+/Dz33qhZdf/vFrv/jlb9589Y03fv32W3/6 +y7v/6//9H6jWH/3sV5/7/NdKtXl/UARODIXkgLND0mS5jBmplUsTuweP3//wQ/c/9vBHP/vcT17/ +xWtv/Prr3//Oy9/46pvvvPXW797++euv/vFPf/z//s///u07b3/qhecv3XBrvtgXBNDbVCDA4Lim +SOlGbX5+dvvUiWvuvufBRx5//Itfeemnv/zFd378g69951u/++Mf/vZf//XWO2+9+dbrf//vv//8 +1798z6OPTUxtVRrrZrQXCjmbnz1uWuISiphM2PVmcwE0yeRw8djp8/f/y8Ofef4zr77+y7d///uv +fvubv3jj1//rf/7nT3/722de/PyjTzx2+5332XZXkhoiE5npzx9YP3jtqbO33XTdfXff9NRj933j +q5//j3//LWT0m2/96he/+OHnv/DxW2+9vLW1Vax04+kBScYxVBfYqMJHbCPWLtePHzpyz133PPTw +ex559OGPf/TZH/34hz/40Q+/9NWXX3nlW3/6y19++svXXnjxc5//4udvuu2eta3TvYl1wyimE61K +bVgsdXK5+vL8xu7WzrHdzXtvufSvX/r817720re/87U33/r1H//6t1d//carv/rlO+/85j//8dd3 +/uOdb3zv6w88eu/a9qFktqMZRVXPGmq8We0sL26cP3fxzOkzp48fu+eOKy+99LnXX//ZG2//5oev +vvqN73z9l2/87N9+/9Zbb7/+27ehWF77wksvXrntrlZviaFthrKjViudnePYtMTbSavQqbaPHNh8 +8l8e/OqXvvjK977z/Bc/99NXf/Lun//0t3/8/fU3f/buH3/32us/feGFjz//wqdOnLtkxRsghwCs +jEg9nuomU62Z6eWl+eUzp06//+nHP/mpj332hU9//ovP//TnP/7P//6vf3v3j6/+6tXvff+rf3r3 +97/9/TsvfeVLTz7xVG+wgRNRMG4BH48EFRyLKHKh1ViqVSaOHT765Pue+MRnP/HpL7zwk9d+9u5f +//Tu3/7649d+8sZbr7/7p//49z/87tVf/Og3v3n1569+/+n3P37LrbflC11FTSFhBlIrYpXtWCWd +aGyuHnjowYe+/JWv/OTVn373B99+59/eevcv7771ztu/+s0bf/3bn+E+P/jhN37801d+/toPn376 +qfOXbt06doNiVF0uOhzSwyGJwuWQn+IofTixeO01F9/z0IOf++LnP/8yRPOzP/7J9/7x3//43R9+ +/xMou5//GAL1qec/duON1x/YPhpP9OqNnZiW6TUm2vVOrVCanRuub64uLkwdOrB41x3nH3nkljtu +P3/DpVP1Wi4aUXlWwHGexJWAjwn46FCAZgk1ZWTqmfpEczA9MThycOfwoa215eE153ceuO+aRx+6 +6dYr1992x20XLl83s7AYT+Q1vRRPgfauoYiIh0WGlDlKBOFy5vjFgwePlbK5fjl/fGfppksnH7z/ +5iefvOvbX//CLwBu3njtrd/+4rnPPHPd9WdnF+didsaKljmwroRGkromx08du+bixSud3myj0V2Y +nNhdmbvu7MHnPvwv33nlS2+8+fo7//bmd773pa+8/Kkvfu5DH/vg/Y8/eOPJwwf7/blYooEgEsPE +UNzw+MDXUH4/Gw5xpmjWMqljm6uP3nnTl1547uWvfO6lF5/52Y//9c9//v1nP/OB2y4fP3VwZbLb +q9VaNC0FAxTPxeAiKRMujjVFVknFst16f2dp7cqFE08/ft8nPvLYv7783Ouv/+jf//D2X/76h9d+ +9tWPPfvwLTef7rSqFCmSRIRlkgE/SBpni7LHRTC4kbIqGauwMD23sbp87typm2647o4rN9x/580v +fubZb3/r5S+88Innn/vAJz/82Bef/+hj99564ejhUr7J8ZEwJmKYQlOWICYLhWHUKjKElLFzR7YP +3XPn3c999EMffOq999x267NPPf7D77/yyrdffu99lz708B3PPnbf9RdPH95en+oNi8WJwdQRO953 +uymvh6PIBBpWQn6aRIVSunZ0a+eeW2/8woufeunlzz37wceefuKB55975off/8EnP/rRe6/csrux +1ay3JN6kSAMJ60E/H/ThWJgjMYGlZMsq5XK9QX9xaXmblzWcAG0phlERQQQC1xgmGgxyoyNev4cg +UZ2hIgSqcKTBO5ci8loqXrKjOQKlcJQgMFrkVUEwZKOI4KbXT4eCAuW8p2D5Q/S4Cw== + + + XC1JEyoeFihc0U0wKXFJMiOqyRGkyvHFVLJWLsxND4+fPL2+tZnJZCCO/gDl9ZNgOkAqh0KKPyAE +gryqZmOxqijGaVqXRStpJcCOJq1oMZPKZ7LVWnNmbikei+cSyWGn0y4VY5JOoSK4ZoqKCkLaTk1w +Ym7/SADUTkSv6VLB1tLdUr2eyeejVtaK7q6tT3XKjUJyut/JpquSaEqizXE5Arf8XsbnIbxu1ONC +3C7snydZCXzWUMqN0kwhWatnyndduencsUOtfHqm3eyUq0sTveVBs5KtEigzNupxjSE+DzU2Ehgb +DXk9FGAXjho8HTe1YgJsVqqYy5RVKUKECU00s3Y1pmcqufp0b36uP2fKSj6ejalJjlSDAX7cw4x7 +2FDY1LSaYVQFIY5jEoFC5SaSiRYUtSoXOt0DK5uXZ+dPG1qKRMJxzSjEs5YSpQkATBqySNVr3cnT +keik18td/f+4QIjSVAIJSRxpSoyRNJOFRC4bTxXTFZDvEsEotBRRcpZetq1a3O6GQlApejzZV43m +/qv9kCouFxrwM3hYYtm0LBdrldmjp29DcD2EgLbMiVJZVqrgKxkmGUYNGAESd+bKRkf9cI27UI+b +IjGdZ1NWpKWqFVnIcnzKOUgqwPoCFEZGMTwBYy5yOYqIerx4COEQVAFhw5A6GhaCQZ7hM4JW0iJV +wyihKIuhLMdoFKlwnKXqBZwywfvTTBpKab/zcl8YtC6GRSgqRjMWx9vBkBAI8Ciq+nxUKMQGgwxD +WeCRNbXM8xlRKpBkJKKnFdUeG/eNjyIYYvBcGmidE8pWfI5hC243DRoYQ2WPG/eMh0NeLOAJBzwI +EeajRkkRYyylslQ0FNLBfXt9/D9fLQ/4FYqMo4jqc1NB500lxRdQESwWCOnAcSxrV8qTRw+fLWSq +fndAoQ2VTSiszUF3AKNGQ24XQRMJtwvfd7XLNY7SZMzvF+CCkg9jJrRHhMxPTBBEBFoVsRqF0rJl +teORKkeYGCJiIX52YkfkbIA7uBXJlhipKSot3WhSTDKE6mGo6L3Db41IPxKfzZZ2irWt3vQ5KzHt +9QLHKdXCJIHp+/d5Pc6JFrpldmdmz3YHJxg2PzoS9oyjlfw0RcZGRsMQzUBAJPGooTfzhaV0ajbo +412jIRoD0lT8Pg5FdAyNklQaXDM8zooNx8bwcRficofcHsTjDmPgW9mM6Excz7JsJpsCLTQnKUVB +LBKETVJJ1tnWHsHJBIJF9u/3jo4G4KE+L8+QcYnPS1IR0q9WXmm0D4yNY+PjCASdE/N6ZEI1OnBb +HDMUId7tLAty3uXC3G7U68UxTM/kV6OpWS3SFoRMNtuMxcthVILP+v0AmFEUTypat1g5QkAg3ASK +gJHuwa38Ac7royDrMCKqaFVVaXidg9FYgDKStAAhCSIKIxYKqQydtqIdVky73Gg4bBpG14y0WS4X +xuMMX/EHdbeHgfQLBNj9zpsLAZ8b87qxgI9iqBiUG4FHACSDQW3f3nEfCGKgaBxBnDMHWDaH4bbf +B1LBQvGoc5Kem3P7ZBgrOzHIFKYIyoKeelwYR9qQgaP7A6POu+o0mHc0HElEZ7Cw7XaTcHm99Ngo +4vVxMMLOBgM6HbVnYslFJGwKQsKy24yQhdwOeLhxZ387TuPRVnVT5JPucZRnE7xUC4WjgZAZdE6L +KpqxaS3SR7EoTcfApDT7x1P5FYrO0Ww+ENRdLtxUi1PDkyQeG9kfpNk0x+UVsWgZNQKPgnof2ecP ++ejl+eMMk3J7OIbN4FSS4QqGOZEvbSlKy+vmfB6WwE0oDdd4GAsrHJuR1Lakdg1rKMk15whK3FC1 +lKClXR7c5xedU0CVuhbtxFPTnckjufI8L2UkrSJIZTPWN2KTrFhB8ERg7/1WKHYkvPeO/yjBUCmK +SuFETFUqeqQ9No47aYBrFJcy7AlGLvsRFf6aTTXWN08rZsMNY4jqJAWpHgNPBKEJhSTgx2OHzy2u +HYHUwgHWmCzPlzmuJCtNVe9DtktCKhato6g0NoZALAjCZPmMrLfjmUXTmqGpdD43G7Xb0BeHghGZ +JGMALLJchUrEMIunYs3aMifkIIJuF+lx82E0HgrbIcSyk1MgukZGQ+BQWKB+PxsKcjimeyDozhGR +UY4rAAiEEGhVhiRSYTQ67sZ9ARGn85HYZL60ICqlQFB1zjdDbQSNgrzn+AxUh8vNSmKVZ3P7r/aO +7gf9YZnmUJabaDjmnL3sYsFNSGIG2oOF9UBQDu5tRAmjEedIExJGJjG/eKrVXyPoGLRc4Esck+WY +HMvkwmELPgWsioXlYBBg09mMjRLpTGFrdefeevdoCLVgECSlQFLOgWk4lnFesLLasWhDV+uqUmfo +ZDDg7EH1OYkdGB9D3ePE2KjDRGFEsawGQcYhVyW56AP5EQCKUZxXz/bDb5IYFsWx6NVXuaABNGHQ +lO32SC6PMu6W9o8SI2MUyMjDu9ctbl8z7mO8QZmTW3p8IVXZLjQPRDOzklqZ7m+dvXwfwSd9iOQL +KWE8RVA5Se5G7GVfyARMwMLmnqEweD4v8HmahgFJEXQakITmLF5JMVKe5DO8WlWtBs1nOLls2FOp +/IaitwC6RTmL086LYAZIHbNKsTGMsoB5GcbBqNGx0OhY2B8QIf0EIa8pFY4DtqWBUwCigccB20No +FKPyrNCS1JaqNTSjBd1MJFpIWPJ6SbgVYAjNZFkub0dbh3avk+TcuAv3eEgCj7NsURCqglijuRwM +Hdje06duzhUmndT1kBiigqaSlTqUYRjRAVQ1s8FwiTEX6nITPj+LoBrNZY1oF6digpRf2rygx9r7 +RkL79gVDQY2kEjSdjlidVHo6FFQ94zhLWryYHRnF9i4cLgxLWlY/mZiQlaKqVRFUd3lof1AMhTWa +ycGja+2DcxuXBBlyTOtP7NTbB3A85vHyLhfj9fBoWOOYGDDm+FiYYVOZ/HIqv0zQGef1q3BEMtvl +ztGJhXOqUQewYvkqjDkvFoJBAQmJfi+396KfBfw+DqrPxzkvmIRUkojhqBkKyB7n3AkhjEXXNy6Z +emnfPp/LRQGKmnqfoQo0lUMQoEssGJDghqMjPr+PBq0CRYGglmS0QaLkcsNIoukGf0RYBJehpWI0 +O8+pVYrPmFbrwM715295hOASJBPXrU48MZdMzGWzS7o9HPOwApuanzqu6fWREYARDjKZprLR2OTM +4nX1zm463T519oqgVzmlmC7NF5pbpfZOtXe4MjihRidoPp1Ndp54/EMzqyegJDFMQzEDI2xBqiXT +y4rWCTqnwVsAGphzeE6eYooEXWS5qhUdWvHJUFh1ucKksyPIeTsDJWyKzsAlCCVVq5Wra6paitvN +WGICJ21ZrRv2pGy2CS4XwqxQOAKtBdW09xJuRJAqdmIocDkQilasgpMGgRscm4C8CvglnLAZNg3y +iWJTrFgQ1TJQMFSxz8eCevd6aJ7LCmI+Yvfbc+dIseDyOqdkAEgSpAXaDNIvFDaAcXhQmySUNrVv +PzI6hkN6hBGLZauK0gZ9omgtWW1wYpFk07xcAnEbdg6eSohyWTGboaCsCMlbbn5Q0wsAGi4XgaIm +0DHPZRgmDlorGJQkMS+KWZZNQGMyhbl8Y12N92O5OVGt0mwqGutSVMI1Tno9AobaNJ2XpY6qDBDE +9nglmownk5OgfEBLQ7/Gx7CxUQyaxzDlaHwqV1gGi+EF2+K8TSbjaNR5KcynhjFb0ZuJzAxoWk3J +RayMz4/5AnQgKDkHyBDOwivQVhDVRL1KS7kwFYtl5/T4MJld6A9P92cvZKorkpTL5abi2SHLQSVa +BGUCbo97Gbhnu7Wt6M45OQQe45zRS2tatdrcTOamS6XZcxfvEYyyaJZqgwOdmZPduZPl7oF8Y5uT +K5yYnhqsv/SFb5y5/m4EUynSUpSqqrUzuY1S9ZAoN02z7RQpmXBeBKYKkjYw44uZ0uH25LXx3DIK +fpM0Y7E2Tsb9IdUHDpRJKnodNBsnliLxyWZz9cqtj86vXRtEwPtU7ey8lV6QrclIfD6eWgFlgqAG +J5X2TtGJO+84INGgzzk6AA0bucyUplUgt71egWOSVqQhyGVZb+nRXr1zoFDbIOh4CAFUpH1eFnSd +HmmmyyvF7lFOa0pGS7cmQL/5/YyzVmj34IOJ9HwmuwipMuoc507AUwAB/H6wKhVJrotyjZecA20E +taFE+qLegkL27R2GTzFZ6JERacTt9uz0DkUZkM8AVqoCUiEPCeZyk2NjYUUuyVIOnujzkgIXz+Yn +k/khp5SsxJSg1AWxHI31eSHvnGTlnJqbxYnE3mkAlt85RC5jaI1Cfh54AQ3rOB4JAI+Pkxybp5k8 +JxQB9gHTgFaQsHb11e4x56QdEFd5Wa5oRh36DoSbTPTBl4+N+Xw+YAoNghIEzKdS4JXi6YXmxKlo +chjPzSjRjh4fGMnJZHFRiw5AXcy0Nh64++np1VOgz8G84GBSsIiqNyKxvmn1fQEeCfA0nQqGNLeb +DaMKCPVEdiZfXc9WVlghblql1vCAs9lYLzvvGqSmirX13sSRuaVzh0/dJappjFRisa5zbqragFbh +kDZMwk5NpcpLQdRwuelEaqk7faE3fy5ZWuGkKkZnEBywqFqqrmhWi5UKvFyQVJCvbTPeBR6PpLqp +4kRnciNVmqFps9vfntu4oTl1VtS7stGDyx/SpyYO3HrX+4qVGY+PA/1JUnWKqmWz66XqsXRuxVFx +ctGMtkDGeECIBng7M7ewcvHcpUfrvcMkk9zaOreweBJqXFbypdZ6bfJofXhydu3GjSMPVVonQIVy +fFw1K7SQAhUHvEnzZb9z8IXmDwjO6+FuCkWB+mNI2HmFk2DzUqSfbuzGChsEWyBoy7Qasl4DHOOl +oqJXDbtbbKxbiT5oGMAWsGY+n4A4OxwEDDNQLOL20D4fuGPT7yUQ8NRsAlg+lppJ5JY4uc6KVSM6 +1eifLFQO+APq2BhGkGlBqtNsQVHrpCOV05wAqdIAJOS4tM/rrGY6J/agYO4KoliJ2QMwsFdf7fK6 +SY+LcI/jAGXgLEQJnHhBECsskw76gaNVv4PnJMg8TizIWj1fXc1V1uZmT91+1wfi6YGgFMvtg6kC +BK4/GJ4czpwpNnf8qO52Uxyf5YA3ybiq1Dih4KSTB1K6WKwu0lwK+qsoxUi8b2dmsrV1KzltmvXZ +6UNX7vsggukwRLnKRtUp/LVqd7fS2U3kFnDS0nWgpL7PD9aeo5kUJFg6v7p66Nb+wlmMigf8PMMl +EdzyBWW3jwWQUcxevnZwdee2RHoYT03ma0sUH3f7SJKxY6nB0s61t9z31DW3PDq5dEYyyoV08/Cx +G81E1+XjSS6TLS/mqiuyOchX1qfmD5nRSgiJFOuH7dQiy5c1vasYbQQzgXBrjbV2/wC0Cgw4SHTd +ahvRjqRX/YgWxszhwvFSczlM6XaqN7l4cnbrQm/ucH1wMFVckoyqKKY+8vGXLt18Hw== + + + yVogDu3Ucm3ibLl3Qo8MvT4JYjTZ39w9fMu+/WBao6o1me8c6q5cHKxeTlQ2ESoZjTWe+ejnDx25 +5PFy4GpjyZnm5OnDZx/qT19wDo4bC6pSiuez427K4+MhYwW5Jet9cGdgE5AgzzIxjk+juAVVXO0f +7cydWzly98aJBwZz50WpMjKCTw6PxuKTfueoVQoeASMANDGYv5gprCLO6R8q6FVZAu9jgrMAPeZH +bBC0OOWcwg3qfRT0j4uiCRvHIiyTAZlN4EngSgwFPR8D8GSYCIQyAMmJ6hQXB4+TzM3VupsUn5C0 +aq1/tNg6lCys9Yan4pkF5zhcH0+TpqYXMQJGXg86B3hqXq8cDiciYDnVKgCmKv3/JL33l1zXde/5 +D4xJdO7KVTfnfG/dUDnn0FXV1TnnRqMbaDSARgaISIIgSJCimEVSokRRlCxawZKt4CBL1lO0pLEs +h3nPHj/bs+bNm7VmvTdrfpt9obV6caEBdte99+z93d/PPefsk7OcOoIrYVR+sgwsW6xv9ZevTG/c +4LlUr7dTaW2gtAXuK55bMJMzrFQr1rabk4d2cgpcCi+U0rklJzEVS06byT6nNCJYnOchc5ODw5GB +YSQcMTK5pVR+LVnctFPzJJ0AscpXlyWjEkYNSa1BAaq31w+Pn738zCvL21cYKTPRWn724dvpvNvZ +u1DdPbz02oNPfzK7+4Jsz2J0AoaGpbO5wqrH7fNGoG6fQMsfVHAyYdh9tz+A25GbR1EnEJQimI3R +acVs28m5bHVdt5utzsrhhXu62SSZGEqoJJ8lhDyvFov11TOXH2eKM+7rEcxs9o+hjKrmhNeveP0C +gmi59FS3dwrKIoY5jFhkpQIjljV7RotPpStL/aXzNx6+11s4GhqhUCIejU0rRodis8BQw8MMSIoq +lyQp9/QJnzcgKuZ0LL2lmtOaOQV2CFibZlypRHFz5/DutQdvbZ29P7163UotgNQPjwL7sHef/zBf +XgGriaJxw+ohaIJhi5nCCrAt5FE4JBQK07KYAWx8GhhwlKbFhpPfThS2U/lNAs9GwqamtdCINTTg +HxkmnjRBpYAlwRT5/e4OoN70DrhZuDb3ZvEoxIYen5ctd2EwhJZsNUl3iVpW0nu8CjpWJXGHZ2I0 +ZUMIESChWIamKvCFYjkUz4DM+nx8rbyaKU67XfXGMGBhQa6XW3vN6aN8Y8UyCjeuv7K0fhzC1GR+ +YXnn3tz6nerE4fTi1amVa4o1MTpO6dE2oC4KBRdV4JGSTFlWexAPgloeAhF2z75xolab5nM4k2aE +Ek5nRdXdHcmIeVYsWLFJlk9LYqrZ3ZqYPWzNnik2V5Y3Ls8sndeiDSvWaXT3m729zuwpIzkVxBJu +2+eAFLM6+cLKyBg1PELwYkWzplSjC35JkBogyMGATFGJiNuCkmCFUiy90Fu8XOueTeYWNK24f3D5 +tfc+hroJzxDDLVnvVVr7py+8dO259zuLFyF0/SEhnulGE/0QYjw5bIgc8/Io5gCYIKgdDIq8mEfc +vsRkIGTwciuZXzl14cELb3zl6vOfT5Q3xv0yJxbgUYSQKIwUVDECz0hSQxAbADiDQ2GQJjO+QLud +4RWAIBg7KNYqmHbSAQWYmtvvTe+mcjN2aoGVJyihwohVKCXd+RsYlfF4JcOZkY2G213BwwdDhtvf +fghDUKNYXkUiysDTIyeeGg3AE3A3Qc/yShPBY4PDrD9kAVWNjrhvwHxeye9X/QEVGArDYm4bbSKW +ra4xhJPLThGkPe6l4RYShS0jsayY/WR5C/IIqq3svqdqkWwe7g48P0il3yf4fWIooAC2wGMP+iXw +pRDqT9oSCqbZ9rvtqsIwEOM+Hq6EFYuye2RGLRZvNie2o2aT5zMzS8dzG1frkyf1WIPh4zjtRDAr +HNY1rUbiZsDPgTNU9Jls8XStfTyzfAd1mz+zLJOK2hNgjXwBHvA8Asig9wyrD+6XlwqdyZ1We5Om +TAJVCqX51ZO3z1x95ejq43uPP6z3DiSp+szFhy+98p6o5hHcRMgkC8iQW+9MHS+sPIPh2RODkSHQ +EDJtOFMaJDIWh+z2jDFgtoHFgu6ZR7IandCtjgrujkkTZEIS84Xy4vTWVVosBYN6ubLTmriQza/M +Lx8vbl7l5JI/IEaN0qPXv6DHJoeH6VDY4iXw5H2aKwdCGlh9KB9WrAcE5/WzgliKpxdSheXe3OGF +m4/XT93i1JppTly89AC4LxjWdLOTzCxk86vp3Dovtt3zsLw0Q8fAaEFdGxoG/xzNlNbr/YN0aRUc +GoYbiWTHH+C9fg5CC5Jg+9zj6Y07jZkLFF88MYASaOz8lVdpMQMVAQI+EHbCSErRp/LlU4XKwZD7 +jssX8FMUHRsaRp4c7iaFgNbZsuHMC3ILPtE7jqOoApjs9XAIFqNY4Nnm4ta147tvBeGOuDSCRBHE +Xb2mWROa0zfTK1Z2neByJBErFZdYHtBbFUDnhYIkV0QRlCoTCirA/oOD3qGh4OBgcNTtdk49aVkm +hQI6iccJLBrwM6JYUM1mIjebKCxUOqfMxBSwcCwxacVrJKvTnEGzlihmBSmvGy3HmQmDrQ0ILGVj +eNTnZ8Cg8lyWot0Wf5GIxTF5IGtgIkj2UFgB8YSCNTbOQWnmhXI6u6CbDRzXKUKP2kXdKSTK/dbc +qanlC+XaWrG4tLV9rVibp9i4k+jna7uiMRHLLGYrO5o1H4mkECSmKBVBzIG58gEbergn5iHKUBng +C4Yp4ZgN7npoxH9i0BMOK6bViyWWSrX9lVPPgQfTtdLO3jNWahrkyx8Qwk82dzBMzolNVlpbw2PM +6AglcBVQRY+PGxwOw5cvIPBiMWr3MAj1iAipR9PxQEAEIxdEtbC7CjQ/0T0zv3wBmEuS863uPsNm +Q0HZO86OP2nu7fXQDBPz+xmcNEORKM3kTacvw8XYHU6u8Gp1or8vSAWOT7a7W43Jk/A3GJMLotEQ +ostq3U4AcW+5jYYAAI22nViyYkupwpqstT1eHWLP62E7rdX5uZNum7hRPBjWBa2RqmxWO2fUaHdw +CLWi9Xy+OzoSHjjhAzUAY+DEe7JahETwedhQyIAvQSzwcpHhUsBlmcp2qrjVnr6cKW8bsW4YU4xo +rdU5UI0Gisf8gShAq989LI8eHyfHxojRMfz35zL8vhseiaexiEOhTjxaXVo+S3JxTsq0584c3Xjz +3O13OstXtfgMzaVMLbe2eGp5+ZKi1YJhyR8UEXe20caxqGPVcUwLBChdzalyDoAFJ1IRNO316U8C +mPC5c3bU8DBoIw4qCnQjSk1BqANHRDCdF1KN7urc8t7ayctbh3e2D27tn39ubvVStrGNM/FqZf7k +7jVeTIYioqgUFa3NcHVFm8SwVCikQy0GuI6ENCRiYVgSQ2IhsFhhBR4yz2ZFpczycVXLo7hOUDGS +yRBMRtBqhtVoNNcuXHpB1iuSXACyYPm8olfjiTld7zBsHsxwzGlWy8tetw92yOMVwhFLkuu8WOaF +Ikk4plkD1YV/BR8FSJ7KrU5Mn+stnN85eAB/htzvdDY2d6//vrkciui4uxSHQcIyxyUITC/XFkQ5 +ByIGgQfpJumNRGmttXh189TziWR/a+Pcn/3wl068P+5RGK4BTFGsbl6/+/bl25+Ro5MDgxhkjSiW +4FMgrUbcHoOs12uo2mTUnla1GhJRwTgF/HwgIHj9vCcgjHjEUfcgD80wJ0Ql7wswANFeLzU+jo+7 +a894zF3OAXU/QTJ5UQMyqgFw5aursfxMorBYbO/Z2SXJ6oBDnuic2t57XrdaHrcFt9v8hGNyOB4P +h3QoiFAl3c7k7uFojHvvQSMcUAnEcKxyp79uxpr11ury3vV8YynfWI0XVzhtAqfTdrS6u3l5beMu +9uQQjUCQp6iUIFYZLivLZYpOylKuUJghSRNYOwzqwdY4vkGzBe+T5s/uKHhoyHEoK09mw6VwxGT4 +lKgVYXwbzdUPPvzmN773k9mVI/gbkM14dr4zfVhtbk319pcXDw0jb+glTa8pak0zJkiq4PUoQ4Pu +EUsjwwiElt/Hj7lzWOGhwcDYKOYZIwjMikbbvcn95fWLHj8LrgZxD+azJKOWKa7nyltatEWQVq+3 +XamthNwu/QJBgCN1p8AAzPPZfrk4OzIUGR3GCDwGfIcixtgY7fdDTmkclzHtFgSG+3qQSstqOZ6Z +1qyWIJV4sQrS3etuTc/sezwcXAZDx6GSBv0CGlFo0kYRNZ5oc8DIwyEMAc9jC3JJtdoGCIhSJnA9 +n2lcvfocyCMnNAqlg2Jl3zS76fR0PDlJMjkw4YqQL+VnIa0Gh4JPzixIi9LU8toLS1sPZK01MkIC +MkBlDwW4p094TriHaAg+v0mSeQAunIkhhBEMiQMDvt+LGyvkksVlgD5g7URh3UkvM3wxnZuzku0w +pWqxZqW715k5t3vm4eVb7zzz4IP98485McsLGbAZCALUGR0bJ4eGQqMjSDAAisrSTNrv9snhoJSE +AgKF6zihSUam3ds4f/Xh9OqZMHwLxbGwVmkdgupqRt2OdSSt4Q8pFJcm6FgE0UHSGa4kSvVa81Sr +C6jeGfcIOFQWFlS9StGFYCg67tPG/dqTA/5kgnQgVQMBDvIlFBbseGt169LWqRuV1urq5vn987d1 +p8IJSTs5aTjtte3L3ekzOBlDUFnXMxsbF3K5SfgpIOhQKOq+S0QSLJNBwnokpIyOoGNuozy32SPc +49goCpYgFu+nMnPJ9LQkZ3Z2n2l39zDGEaL1Su+oPXs5VVwzzPby2qVaYw1kCh5IIjWbSMxKYgmK +o9fHjIxEnn7KE/ByGOJq8uCQd2QEi4R1BNHBL3ndGRORIhI+l1UjERTqaQZ8QrGyHo26s1dwPTQZ +19WS28NtKAxyGgqIBGaSuDvHPT6G+r0ETVg+Hwg7PjJGgJ2QhZTEO7KU4rhULNG9/ezbp87cC4V1 +gkiJYhVqera4Bg6WxGSOMZ90fiZIMuG+DuXKAleybPDhKe84JYtxx6yAw3nqaU8o4pY5cD6j7klY ++LiHCoQkqDsjw2GPhwCjAioHRBMKa4xLW0mCTrBiCVKvUNswrOL+0a2lzSu1xmZv+mBx60p/+ThZ +WOKEbC4/rUVLT1bmaPAEhgbdFUck5nYGMwzAlny9uYvg9ugoEg6JDJfOVpb3zj84f+v1ztTBnTuv +3nv0vp3qE3SKYnIknRGVupNcqHUu9pbvWOk5Xkg3WycLja1orKMYTTDSHq/b31jX+0AfJwYDJwYC +Q6Mkxdd5bZJgik/a9Mkcm8sWV2g2Bn4ynZ08PLr11ntfOnf1Qaa2Ek1O81J5a+/u2slnFLOMkrrp +9HrTpyu1Vctq5nI9WU7CcAD50kwG/IzX554x6p6eEzLc7g04gKE+OOCqVsDHKnLJiPYYrkKQGcep +rW+eS2UmaN5xMv25revbZ5/rLl6s9M7JZjcQVArpmUs3XsYZc8yDB93FyYD5bgM97w== + + + GIeGDFXIL8zub+/eGBgIDJzwwO+HIhiNTcMDIcgkaFe1sri5cx1YGEFNmoV0TjBMgkCNaBRUPQEy +ztO2JOf8Psbnc1fOjI8S8CnhkIyElZFhP4qIPJ8AGoJIK5ZnVrYvLKwdJ/LL9fZJUCpeyC5vXmOY +rN8vu/3/PZzPI0QQW1SbDJuGnBodiYASQtxGQjJF2CQG/oeADx0dRsAG81zixNPjJ54effqp0cEB +L0Q11GhVzHGUVa8tJgEcvKSm5EIRlRPzUrRlJcBpr7WnjxudkyvTW3/2lz/fP3cHmFHR6+niQiw9 +Czdu2LMUnw1FZJ6Jr69dQXF7eMg3Nur3+3CflwYlBFcJblaS06KcxYkYL5aiiW6ju9mbPVWpzj97 +/8XbD161ki1aKKRyG8n0ar19Zm3v4dzK9an5C1G7m4p3Tx/ekqOpIAZo6SBYBuqUZvQktROKmF6/ +CFAGhDLmU8bcg8AIQCTgrFhyyYrPAaydOXhmcmpHMUpWcjJX3W70zs2v3To499LVBx/U+/vNifXz +V56z03Om09aMBstlgYvBFYMeaupEKKJ4vG7GRRBLkbuGMQWAj6KO1+P2ZObZ/Pg4iEwETCaCpNz+ +mRHdnR4SC1GnxckZhk/As4pgccVoLa9fnZ49DbFRrc9SnC3KKcusB9xBVIPBqN+nhPwGjccbldVe +9+Tgk5dIGKaCH8DIBCtXWbkCqdef2pudOxClvCBAoawaZk1Wiiyb0KJuZySKjFWLMzCOXi/hGcch +okgMEsEKB2XPKAma5liVdMrdjyMwTm9m5+DC3YOLj6z0EsWVESy5sXHpT7//o2K2DwbS62FYJi2L +dVmeEOVmMKSAzdDU4uTckRNr+bwkhJNnhAh4GTQs4xHVULI0bYKw82xubNTtsjs4CDTBYxEj6JXQ +cBRKfyLeffDobX+AJWmHlXKy2bKzc5nKWq40t7p46q13v9Kb3oVC3+ycgrIYz8xDaLESFC+wEHzM +qHzq1T+UrdrTTw8PDY4PDwXH4I68HFQWgY1PNuaOrzyrWdUIuAK5yKt5OzmRLk63Z7bLEyu0kIxn +p0rNXVlrWk7fik9zUkGPNiS56tiTteaaEk0n803ZaAZCBhQFjLS8AQXIl2HystICwsWp9JhPGhhC +wHSFMUczu6xQEIXc7va1Xn9bM6uxzGy1c9BbuLi2e/vc5Ucz68fx3MzC0pkvfePP9VgX3BFImahU +nWTfsGZkZVLVexhhqVq50T4pKWX3LY1f+31HUPiiqBzHV0bd6WxqeCQCMRYMqXAZgtJI5lZak2fV +KIxLZnpqr1RZZflst78zNXdKBEqKqAQVBwKSpaLXI4AbhF8bCpnhYDTsE6HKg1yMDJOGUVe1gheq +2DirRDvdxcuF5q7hdBEiFkHNZnvDSTRw0iHptBOfyhaX7di0LEF9tCGi/D6Woe2An/W7E212JKx5 +3OUQKvNk5xrUSkUuwC93Ut2FzWubB/d2Du7vn32wf/TsdH+ZpQBLowyddNd2htwzm0gy7a7WIOO2 +NVEsrdhmze+hsLBKolbAwxCITqJGyM+Mj2IMnXec+TCUPCbqHiA1gAR9ks8L/iQDxlWSyvFYEycM +mokRlCnK+UR+dmblwt7R3b2jBzNb13DGldyZpYuiUSchU9gcQaUZLs/zGfDn07M7QI4nnh7zj9OR +oBHwwW1ywQCPhPlqobl39hqrpkJYNJ5f0p0J+M3NuTPZ9klOrchy9tLxve29a+CsMAx0oxhLzM0t +XFhdu5JIzUlqtVWd+uznPm5PnX76Ke+4hwyCkqCxWHyq2T4w7KlwRNvdu2UnOwPD4TEPHYYqQ7g9 +62S9nshMVyrzW1vnFtbORwhdMuCRdsxYQ44Wq621w+PnL919m5Wh6C8XGtsUX0QwG6eSIcQORtx5 +7WxhOVdaDiPy0DDCMGnbcpkRQxLBoDk8wo6M0uGIMjQa9AcZnLDM2HSiuF5s7pVae0DN+XT/jTc/ +Pn/tcSAoG3Yjnpu20tOG0wPdRlAjHJZVpdrpneX48ugo7b6vdt8N8oODERxLRqPdmand+w/e4IQS +OEnNbEtGO0JkwGfmKtsbB8+b8fbi0uk7z745MbkXCGru8siI4zbex2MU5c73RUICQ1pgpP0Bt0X2 +8Ajl9SthNBZ15ir13WSqMz1zcvP0nbM3Xjl74+W9C8+aiV4Q0XkxW2lsTEyfhgDQjDLQLkmlcMIV +au847/eKfg8LMlXKzhta7cRT4yPDkVBQCLrzxXwwCM5Q4bj8zv6tQFD9gz/wjYxQ4JMVrWM60zBe +J06EA0EBwTSU0GgurljVSvfkwu6tifnLotkXo7V4bq48sUtQCcvqJbPL8exiKr+mOR2Mtse8bkPU +gE8MByTvOA2qODgUgkhAMQPBzUBE9YUE1axo8RopOMnizOzGtVJru9TYaE3u19oAU0Xwz6i7gaUo +AH1TCYpOcEJaUnKdiZXrN1+wYu3BAT9JOobZkpQKgjlPuvYlCDqezs2wUgYExOMFAwmFyZG1CkQv +mMByobO7e7Y3s4niWqG2vrx7b//8yyfPPDe7cq6/cBjL9FPx9gcff+vhm192DxfDY43Owcrm/XL1 +sFw9E7X7oYg2No6lki1JzsMYDQy6TZ7HxpVAyCHoQioze/Pu4/uP3gJo9fiFAKKjVFLS642J7Vbn +sNo5T/AFiLpMZQm0GqfjFJMlqFQEBe01O9PnlWhz3MdhhAM8/sTFGRDDIIBgWSnKzBWnwFYFAoqk +10rN7Ympo61TtxbWLoHnVJX0vduPvvW9H0z0Vj1ekePKoKKCUMPwOAyrPyCJQp6iYmNA2SFRfPKs +eLlabu+vHzxfKC9vrx9+8aM/Wts6Xjl5Y+v8C52V6xOLl1f3H+ycvr135la5uVGtLX3/r3756ptf +JPCorpRVtQkKxtEp22wbSj0Sig4MYECsYISGh1xePvGUZ2gg7IIkmlKjPVlrFIpLql7hpKJiTohG +S7F6Rnw2EJIlrZApzk7091SzWmxuTi5fXDp5a2nv3szW7Xx7X4v1U4npS8cv7p99lpUKnFgpNnay +lS05uiBIU+GwMz5OA0b5fJAv7OiTZWxhGDUqDsSXLs6nSjPV1uLu2Tsnj+4e33xx9eS1UnuHU+s4 +lQCjIohFFNUDATYciQpirdU905+9mMotsSJYdBGBuoNoAFaQjBSopdyO2sup7Lqs12BkfQGeYmL+ +AO/zMyyf1MxmpjBXri/Bfw2rwbJOubHW7u+3ejvJ7HyuspqvruhmPRlvnj13c3XnCCOiifRsob6S +yE3pdoeX6/6gCqmBI8q5o9vl8gLUL49HCocTCJJB0EwoYufys7fuvDw9e3JsjGC4rJWeT5U3evMX +b9z/zAuvf7J88gFB5yYaS+eP74pyGmIsX9qYnL85v/ZstX3JjPUjqIYi2rUrD2uNLXcN8zgDNI3i +CSD0VHG11jsEVOm012bn9kDPKTrFKxVRqxdKS7Mrl+rdg2S6D7JZKExrRnXUPb0XHx9nKbagGl3T +6odCutfLKnq10j4pKmVw4wyf5uQcihuGUSlXFxUtP7V47uj6q43+Qba8KGkluEKWSdhO69zlF978 +7NdWNi4DWBnRPscVQ0ElHGQ9o9josNvQfmSYtZwpGIinnhobHkLGx2i/B5DBYvgKXD+CmFG9DuWY +oJO1yYPd48fnbr0ztXod0KPW3t7ev3f97lvzi2dv3n99cftSujY/tXYRHFOisuWkoMTcuvbMG3Or +F2WjYcVnyq3tfGVdc+YwMvP70xaGhyIk4RCEGXRX0rIEFePloqiW47nZZH56//D29WdfSxT7xdZy +Zx6y+1S2utXonp9efKZQ3UaIKEYYklZjxIJudaLxWcWciSaWBHWCJDNhd96No5gkxReCqINRebcV +LZv1u0cbJKJmHXPfrNJPNp5PdWYuzK5eKTZ3WbEsK/nezF62NE2xTrKwuLh98+Izb+xdeDFVXjZi +DZI1BCG2snasmXmcNgStzIglVzb5NEPGysWZWKwFvjHodsV3D2cBwQxHrERqulJb4QV3VwJJgmNv +KEZVNcqV1urS9tVsdQ0jnb31s6++9lnHKVOUMzF5vt2/UK7t2PF5n/t+hgTEu3XjxYnO1oh7yKzb +Q1Uze5niRrN/rjKxz7GJ+3dfunbzvsdLQq7lq9vzm7evPfv++dvvJoqbYcQiCeNLH39tb++yL6j8 +/oQRw5qNp9dZrjwygiERpdvbLTW2xsbpcFhHMXe9gahWY6l5KzEtSdnb91999KnPxeNdBI3Kas1J +zhSr61unbt588Jn+/EVOrDFMTlFbAffw6NDTT4/DbXrGOVBXii4GAubAiQASlrPpGcDJsRHABx5B +41AW/QGdY3Lg6+DpaVar2t5t9g4ZsabppYn+6e7cEZSMC8f3Xnr9g/b0jp3pH9/49L3HH++ee2Vl +8+4rb3x9efuObk6U84sHZ5+PZbregBAMG+DWRD6BRES/exqRlnIa/cmTopgJBgUUj0paJd/YqvYP +Freuz6xfjMYb67sXJ5eO8q2tXHPbyixI0SarlGS7la9vWJnpCGWRQgaFu7P66doeJtT8YQdn8oLR +jOcWKT4nGFXeaFF8VZBrDF9iOBdvgyEZUo9mYyRrQsCv7j23uv9cf+lKvXeQq67D0CeS7Z2ju7H8 +dLIwt3zq2Xz7lBafVM06EOvG5jFOav4Aly2uGfYkz+ejZgtF7UBAZJiYZbd4oXTiRGjYnZtTBClT +qm0Z1kQ4HPV7+ZjTxnH4WSIUYuvttTsP3rz73BurO1dz+bmoWQuHeQJTJTEHtDXqngXMMWyyUl+r +VJZTqb7PxwwOBoF6UNTtYULRtiBmKcZhqGitMm1audHRMHj7xe1rJ48fzqxeSBWWKLYUiVgCn/j0 +m59ZWj7jC6pj46zbWMY9HsJ9AwN2jiTMWn3JiFaffsoHHEpTGVVvKsaEEu26s+pO48XHrz/7/Bui +CNUzPbt4sz11IV9ZBTF0ElMYlvC4WwCEic4+TcVHRnACiwtCnWNzNBlDEWtgIBzw0VPd9Q8/+pPx +UXwIos7DgaPQjE48sZCM9wTGnJnbVtQc1CyGb4jRPkUq1eZqe+qgO3vQmtxJF2ajVr3R2tg8c3t9 +/1J3didbWkxkQUkmgHkdu9mfPqUZNXcpi5DnuQxL2xBabmeAiAx/FviUz0f5fTQ4QzveXdy4fuHW +29tnnu0vnFlb3vvRX/3k/guvG4mOnZmrdM6kSxul5t7ayXuXb7+5vHOj3dt9+OoHerwfRO1YbrHS +Pd3oXzp1/Oapy6/NbT3T6ex+809/8sFXvhchYt6A9uSMPA2jM6o9lcqtNpprd+6+sHP4TGfxaGbj +UnfxbKa2NLV8tLh+6cK1l+689JlcZbkxsXXrwbsvvPbFM5cfTS5ejGfneLnMi1VZ6wTCoI0spHkE +BT7KSHI9arU5ocAr9WDYEqUKiqm+AI65pq6lmhOyUiOIBJQnTS/OLp7VrWo622q25g== + + + 8+WlaGyOFesMU2ToDJDX70+RhpBAEJ0gE4GAPDICKM3TVApDLSj3DJNg2ATLJRW9rEdb4MrGPGQo +LJKAbyjAu6LquVhioj93uLRxzTAbFGMjuLun48mKOzLsLqyyOS4bdbooZgUDot8rgNL6faLPy0aA ++9BodWJ7afNyd/ZMLD1PslmfXzDUUjzWIQgHwowgkoB7UaPJMqkQxCed+P0urUhQGxpABk8EBwcC +8C2BGRTuzqDRdHzgaV/Ax3nGKfd4xOHIkykYzu+lRTFN0SZkSiq/kC6uSYKVL85UmqsT0/vl9p6d +6CtKAcgxV5kTVYeXdN0qyFoxU1wr1HeB9QLuAldTU+uKWn6yx5Z09wCGJIqMB/0C3OzoSARAmKJs +inZkvZTIz9fbO/PL5zY3z9y88/zyxmG7f/Lg4ksb+8+fv/ba3uH9WmvVdKpOrFWvLV688pyVBF6Y +n1m5vLF3a3LxuNhYjWV6mlMp5HrPPnjtxrOvoKRjJ+Y0q5/MrZ668OrJC6+UaqsLU9vf+e5f3nn0 +qp3qFuurnfn9mdXDWy+8+cVv/PnX//xnn/3kO5evvvDJH37705/5OFFYTOQXzeR8oba7uH774jPv +bew/5qSqLOam5w4hiYJhPRhSSCYO8BhNLPQXrsczc2DqJqfWFKVomBNOZkpzWmAmZb050T88e/lT +opqxnKIdbwpafWLq3NTSTSe9juEFki5EY9Oq2QF207UsxAPU1lAw6vOr7pyCh2e5XKW+JcrFMKKD +H5hfu9meOa3HOgpAol5CcYnmbYzUIgjPsKYgp0WlKGlF3aoJcj4Y4kU1t3nqeqW+BN5PUmsoYkD5 +iIQNWa4jEc3joUAEILTCqMaKGSM+XWocyPoEx+ckPikJLlrqRi3gl8dGaZZNRq2mIFVA38BGhgEx +BhGfVwCfg0HEBlUcM70eBny1uzLQLzFUHL71jNOQO6PjbCAMribGijmaT1nxVrm5hhHxTLycyXVF +JR1LTljxKcPqW85kNreQzs8Kkq2qjmEXadaJ2h0rNa9aHShDHFeIO9Op1JTXQ4cCAo7qkQh4EmFk +OPykp1AYQ0zgPhw3BSnLy4V2d/fUmbuHx/dr3TVRTcWSjcX140yhX6r0M/lJXspCEOp63TAaTmwC +Ujhfnq+111WjxEpFnHJINqZHC45dKZRm4ukJtwlkDeJtBrJgbul8Z3I7k6hMt6cfPXq8sH7StEpz +CwfX7r9y7+W3Xnjjcw9ee+/ep944un5/eX3vwcMXL15/NL947sqt1+c2bi1s3t3cu7ewehGglWYT +yVjzpdc/Wty6ODxKjHtoTsgq0Xa2tj8xc8xLGUVKffr19y2rBgYpQjgxAOf23tbph6cvvzG3dUeS +Mxcv3Hr9rQ8703skl5WjE5RYZaTW5Oyls1ffak4f4aR1585L7d6W1y+6R6L7VRRP0lxpogc+5JIR +bcxM761sXe9MHda621K0ipEJQSlrdrPa3eHVUigiwH1xYlKUczRnA4DQXDoaa8+sXn7uja/2F85q +WsWKTyLuJhHWndINuO+7ABka7W1RKihKJp2dVKITjcnz0cQczQE6gfzWZKUB5SwY1Gk65SQ6qdy0 +pFZwMu4ekzcGihSBgSbIOGisu4Fo1F3MNuouI3RPuAMzPziIYJjjnj81jIdQy4h1ncycmewb9oQa +bQeCRlRNM5zjCzAEHRXkXCq3mKtsZ8oAgDVFzaQzLcOphSOSHevWOmdKzVP1zuknTSnd/nveccLW +yzF44AF2ZCQ0MhwCEQMWZigo0BmeybYmtiguJitZGyJ5YtNIdEW9GHXaNbCsQjwYdBcCcWI1W9jI +lncMu4/jDobqptPmpMKoh4kgFsdlIJvi6b6iVXDCCQQFj4dkGQdcgT/griShScOQnFysVMhOyHLS +1DOt5tzk7Fprci5X7BlO1Uy3M5W5emdpfuNMqbE6O7t7/bk3FnauwZM0jBLHODim4BE2F6+e2r9e +bi6Df7bMXjo578QmVb2FkVDxSV3WDw7OkZTDCXUntVRr72+efm7v/IPl3ZvxzIwqJl58+PJPfvV3 +e0e3Gamcre2Uuudmdx/deelL+0f36+0lx8m/894XDs7dDYZVgDvdmc3VT3VnLx3ffDdXWkrH2y+/ +/N6tF971+CXAkxASFeXaxsl7V599//LDD+L55VZz5fX3/6je3giFlDCiKEat0Tk8ef7F24++MLt8 +HcDqxq1PlyrLg+7pPIjHw2NYEqKiUFxeWr+qSPlbNx988sd/LskFRmxEE4vw6VZqZf/4tYv3Pleb +OMQQ69kHb91/8e1kpjfmoUfGCPhvKKQSeFIQW8PuWav00enrt595BAJy4oTnxNOep/7Ae+IEEgrH +rdgyhpqLK4e9qR3AUjUKulfEyQRKpH0hGLssQBZFRi2rjKIKAn9mk0asly2vd6cP1k89Y2emCEIv +FOZjqWn3zNOwBr5x3MO5yyMZR5PTaJgL+jCeUYN+3O+ncTpJsFnAGYrOEnQ6GBYNowwWrjV7ePLC +w9X9u93la8nili/AYYhkGFUEdV/9PSF9IRxUBT6fKy2zQgEyIpWchEsKIzI87XGfCLTotu9DTU0q ++t31JFKuuAh2V5OLHJ2MhFQKM0B8Mpkuy1t+P8YwNgiOblf6C6d3Tj+ztHFsx9rp9EQs2SUpWxQS +mpbj2TiJaTwVZWn4EW50jAC24pgspDxJ6BhqBAOSIqR52mFIC5AcElzgc2CYScpi+TjHJVStkI43 +uu3lRmsFKgJc/NTChXp3N5XtqHpWURKmkXCMhKZk3Ln7cUbgMgpcMJckiCgSkZAQD+UpkZqUjAl/ +QEtmFzOlVdPuzCycXdm9Wu1sUZRVybVOn7lWKM5SRCKdnUtmZ8xYW9ELhlkCKgeSlZUiScVHnxxO +AV7RdmYSqSVNb/JcwpBj9Wq/P73l7lKsbCZLm43p40b/KFtaiGdnWS5FY+LW5tH2qWuyUgArGDUn +KBrcV0KVSz4P7Rsnba300qO3P/Xau8Ay7vmq46IvHKOESra8lSmsWHruw4+/+vjVd3weZnAg7POK +olTP1w76m3cCASnoY0QOxrFJElEQDShJ8PDB+3Wn98AIMfD0hPjq8ulafTEUVpFIFEwsy2fh4aAR +LuDFvGNhNIQrvIyEI2iY4IVkeWI/Gp9Vo5OsWOJZa35qa//gZjI3pUar8QzA8gpO5UMhiSUNRUyG +Amw4wJO4TRNxgc3adhe4DMUSDJnSpaIm5ibqS0srx2EsCmUFJ6xwSPWD7PtoibUKhSmflxsbwd0j +mMdoDI3CM+H5FMfHITDiiZasZjBCdhKtSnMrmV2K2pMTvTOJ1AyGGZ32Wq22GAq6nUkQFFA94Q/E +MKwoSw24pIAPNdWkFa16gZuCyu9nAMNh092JH4n6fIJhuhlKM1nL6Tl2i6FjwaAENphlEzhmBPw0 +S7krEinCgKDFMT0U1sbGacgImtB846i7O9vHhvwsT1kckxKkMkGlgkEuV5xOFfoIAohqqXpBEFOa +knOieUWMh/y0LCSy2TaKQFpRJKFBeGsaXHAObsfnYwN+gaLikbCOY1ECt+ApYWFJFWyBsQEokIha +6+6oRo1hkgybwjEL/JLIpw0tR+N6wEeODochNynCHBoMjQxF/B6cJXiJ1VJ2tVKYhzwdGoqMjlAI +kqS4EkmnCMJmGJUDaKl1Y055aAhx94XFZroz5xe2bs2sXgLEICGcSBPHJBKT3OqAqXBfkpKNxZtO +vAWRr8uJqJZi6SgMBEsBk6YJMkoShs9DkKiMhzkSYVRBoXFS5BSWMeKZFq/mMcJCUdVUUic3zhxf +vGNEwaQlU5n51sRRIr1CkjYW4cN+KuAl0ZBEYDoakbCITJMWw6RlpSmwOTyiWUr2/N6lB48/gxJG +KCLiuIGAcCEGjcOX5veR3jE8BMbSBzSkRBDjSZMHMRxWBC7lxJoMa1OkVqrMFypLyeyck5w27UkB +JBE1HKvuOE34n2EUEsmpTHaTpJoYWggGFM9oJOTHNMmWxfiA20YmBAFMklmGLuFEMhyOoqiVSPV5 +IQdGBcViUMfdv8RjYIxBGN0GIMORSIDFgJ3HMLcrwiiJEyBxGQo3SVzxjEUsrZRNTuKogYUVLGLQ +JDgBIxLmi6V+PFn3+QiWNiUpybGOwMZoQkVDVNiP87SRy1RCviAaRCgcao3DMHH4OJ+XGRmOeMYI +sL6DA/7xUQyLaEEfh8B4YRoeAvWAMJN7U7u6mosEOZaJE3iMJCzICBjH8ZHw2HDAP47TmD7mdqhA +AQ9J1IxZJTsK2Z0lEHNgIAClcHDQ9dJPtsGSPi8pi5YkmCQhe8ZRoEWez2l63babiXRX06s+LxUK +Qj1FBgfGIgGcwGGARIEza5WpbLYTjZYIXAuHKK83EvSzNJkjcYvE1Vyq05jcHRkHrQiPjwY9o0Ea +40RasaNptxNRPC+qyaAr9fFOfa4ILkiM46iYSTYtswSVCCPMsTEyFOAiIVEFeFGLBK5C4gT9VCTI +oBEZNM07zuARwzEKjcpUpdJnadWKZljGBo8KP4gjMhqSBwZCIFlIyL214SGf1y9FkBgvVHR9wrJ7 +UbOGIQKIz8LigaIDjCTAxSlqLZGYLJeXbMd9cxjwsyxr87wDoe7Oi7kHUJIYsD8qhYKUZywU8EQo +VMTCcKm8zwc2xtG0miS6QhEOy08gqwWaw/GNWHzV3eSCRQPuRBvoKjU2EggHOcAclk0Zel7gE09a +K/j94+jy3O7h4S2aNH0ePOSj0YCg8Am4KSwiBf302HCIwGSeBbWRg36GQAQGEzhSogkZQ7CAx0dG +MPgWMlEUsjyXduepvVQ4yMMYDTw97hslfOP4GITBCd/oQNA7RqJhhadsTUqDb8kli0eH18BkQrEL ++XhQlUhQQoIii5sQfp5RNGa14s4kFtYoqBFBcXwEO/GU1zMG46LCJw6eGGdIXeQTAR8T8MIjIgDf +xkciZESRmCSFRiMBnqfjilQfHgkNDHhOnBiDW6YIzdDAfmsxPXbu3CXbKXl9dCgo4kSUYdOcUKLo +lM+DmrJzfPr6u1/+bhBRnvqD4aFBHxJkFT5maMmYk1WF6IWjy1t7FyKoODYaeTIp787L05Qh8IYq +RZMOOMw5SSgwtAMeDwnz8PckSgu0pEspDOHRMIkGKYZQ406NY00kDE/Ar3BszIGY5ANhKhjCoCKo +Yk6TJ8JBHSrRyGhkcGAcRRRRTHFcDHWh1UBRk8R0TUoyhIaEGV3P5SrLKA6fKIWD7vrMJ/+aNo2C +10cMDweBpsMBmSXjaFj2eXEM5dOJbMaOy4wc9KE+L4Zhih1rFqvLEFHBAA9X1GitJZI991TokQiE +ExoRSbcCJlSpTOEOBFIm3synWkiIBEmXWJ3GZBpXWFyKBPGgLwy//8LxMYULY0NBz0hk6IR3ZCAQ +9DJum0fWejIRLKNhEwmQEX/EM+obG/aF/ZGYqlXTsXo+aapGpdaV1fj4GDBUYNQdYg== + + + FA8rYb8wMhgYeHps4KmxgIeV+LzIpZEAL1BGwsyl7IKh5f0eAg2JBAK1RvKAsJwYHx7weUbCIS8p +MgkCkX1jEYhw7zhEPkdhDoHGgz5xeDAwPOBVxTQE5MhQAOIQyi5LWZaaZ7Fo0MOPDWERP2QWPToU +8ozhkQCIp+D3oALDiwyliVQlZXW7TU4QUQAkM1UpNRPxDMcrSAQhESQG0FieSKbrg4P+0eFQJMBF +pURcSygMa0lcK59cW1tKZPKBEOHx4pEw1FBdEvVkzMpnYoW0vb3cf/jcvYmJ+bGx0NhoYHTEx1OS +CvZIVw1RwsOIo0r5hKXwEFHjSMAnUkg2Ltfy1oVTC0dn1xe2+pUG/DLZ0MFsKGBgnkAxAVeiS7od +VQ1NtqMxnrZ0ucBSDtge32hEoKRSrlJvTep6Mp9tcZxJYAKJiuEAPTIUOnHC677LIt12MfDogl4M +3G+r2luYXzBkFQuRPg9GYBq4gphTFMQ4zViVylQ0mtf1vCgm/T4KCXEQMwwpqbwuMCaOiFCyBS4r +sI7KKRpDF+JGTI+qgmQpikjiIgQZg/ZbqdWljsSDKtJYWEADLBmRKVSHQgbhARrCgMMM8xG/Hw34 +EL/fFKWJrL1Ui+/PFm+c6Vw9mHrt5esHu/NpM8pQChoRoPbxuAkB9vQfjAwN+ANA2QE+MIZQIVok +2Lii2bIaFRUCkjeAqrwosgwD+sjwPCkpbMzSCpEQNzLkG3h6ZPCEB8IDiuMIUOcIPXAicuJEcGgw +7BujIPhDXhQNYplEnkI5KsKYUhwLguenWSIucQm/Fxsa9PjGMRo8TJBAfD6RDMZVtJnl59vO6ny5 +WY8Vc2qvZl/cbNy7tLy3NTFRsdqlWMqJG6pD4OLQiVHvqB8PoiYnxAVKJ/05Dd3oJZtV24pypiHa +lqkIbNoWG0V1rWu+cmfnlecPHlxfev7Weq2cHhv1j42E8AgY1rghSLZIxwQsLqLTZWOjn5yqKHkT +7RflU7PpV+5uvnJv69ufu/jrH775s1989MUv3tlZKWRirCrxDJPA0DgWsWXGLMTNTsWcbSenG+mE +yudjtsxJIX8YCYRsSWpXcv1+bWt96ZXXXmtM9FAMD/gxuIDhQdArTtMnGCbrvpo7MchhWNaymoV8 +KeMQSAgPoUgQlXllopy/enw02evalr21tZjLpXGMDocpWY7zfBycGwu6hIAQcPCVt+PVTAEKYdEW +Swa+v1S4cHJ6rpmayCh70+kXbq5/+rmTX3j9/BvP79+7urM8Xcs6FhVG0QAR9lEMZipijidlHiN1 +lqgl+Kmy3i8bSxPW+SXnuf3CZ+4ufPmNvT987dTf//yrv/7pV955fu/s9nSvXowKMhmhsBAdDrIc +ExNpmwqhANUlQ24njYrFz1XN9cn04kR2b2ni7pXtq0fzD26svfXC4acfXL165nSvUs3FHUNi8VAI +3FfYz3pGcQgnzygJijp0wjM+EkB8GOoLGQxVsNReNZtQRZOjGtlELZdJR+MZM0Mh3OCABxI27CPA +bOlEyKG8LTtydkZ/4ah++0z9wcXuR28eff2Da194dfPDh73ffvf2P//q/b/42nPvf+pof7VXiMcB +HwKeQNgzxoe9eRGZTWFzmcBaBbm0ZFw/VTjeyV3czj1zpvngQuu129Nv3u9/8dHc3/3lK//0q89+ +6/Nn7+2nSyYe8vp8nghHqTwl0xFMxYI9CznssBdnxcdnsx+9tPzes/137ra/+Hj2Z9++9c+//uzP +vnn1F3988b/85OX/8d9/+pdfv/fW/eUre/ViMkYhkK18TI4WbKWdEdZa+uGMuZDHlipkL0OtdezN +fmK7H7u+V/3g8e7vfvPHv/jl1z7+8NnH97bP7EzpEuX3eMN+AkXkkZHA4IlhxDOeECJZCSlqaIL3 +JgR/Py8vNa3Vrnlm1nzn4c47jw9fubf7h+9e+tH333/95evNsr00119c2l8/eU+PlomAz2bRlIh1 +bOLslPbofOO5M6WjKemVS9WffffRT7//yuefX/7Sw+nf/OClf/+nr/zX333hR18++tdfvPTXX798 +fiXmsGHM7/YkZFCZRggJ9af4wFKBvL+b/M7nD3/6vYd//PkLn32u+7VPz/3gy0e/++vHf/3JxR9+ +tP+vv3r5H35w/QvPVZ47zB8s5AoxvZiAWpmy9KzC8GkJ6cXRjTJ3ayPx1jMzL58vP76Q/5MPL/zq +h2/81//8rd/+7P1ffOfOf/uHd/6///fv/v6XHz4+rn3znZM///7z7z/ayVlqYByFIgsYK9AaHgxS +UPLDnijlt8ixxQJ9dTV1ZT13ZiZ6cdl+6XLnT//w/kev7n/0xpW3Xryej8XRCA8KrBJURWfn0sRe +g767qn14p/2ddw+//e6ZH3/11n/+0Rv/4z/+8rc//cwPv3z0d392/7/+5nNfe+/iqblcDgiSlWNG +QqYoi0HbJrFaQC/06VtL2qtnkt96fe3HX7v1vS+c+/pbW3/1paP//Fcv/re//eDffv3Or7536zff +vfqrP7nx2o35WswtgmBCgr4IEcITslE11JU088pJ/d3Lyc/fLHz79YVff+P8//m7N//xpy//xZfO +/OpbF//5Jw/+8Qd3fvjh7o8/2v7FNw7/7PMnb57MtXLxiB/DQgwbITcmy9vd+EZDubkW/cqj/g+/ +dPqbry9+/Y2V3/7olV9899k//dzB99/b/u//+OH//O8/+Oe/eeO337nxf/z9W9/96GhvCmLBNzYy +GvKjoO02x8/nxZ4V6hreq1PMw5P2syftT10qfvR4/nufP/mNt1Z+/PVr//FPX/nNX7z0ux++/O// +8KW//sbto9XKwnS/UOzimJaz43VH6SfpvSpxZYr54r3Wz//o+Nffuvad97e/9ZmtH//R1X/7zbs/ +/9aN776//Z8+Of+///K1X33t0jceVr54K3s0KYKqKIzgGQkMPT2Ke7wpLjCXDJ/v8jfXrMcXSh88 +N/eTP77zL3/z+v/240d//4OHf//DF376yfFPPz74i8/Mfe5m4cq8Opmk0grhthPloxxlJsxiv97a +6KXncuxSBrs8zXz+fvtP3z/5g4+P/uJL+z/79uXf/fiFf/jJ45//8dWff7z7D9+/8q+/eP6337/2 +zU/33ruceOmo3EwbaIiThDzPxgxRa+fMZoyaTBDnprX7W9pL++bbl3PwNP72z+/84tuXf/q14//r +X776f//bn3zr7e1vf/b849tbAsESET4pK2mRyomRXgxfK5IXp5RXzpa/8drm9z57+KMvnv+PX733 +P//bj/7xh49++OHpDx+unlospHVWICgKk6JqxlIzMSURF7iigi4XxOO5zL2ThRdPJ7//mc3/9Tv3 +f/fDd7/88vrHD3vffXvlx185/7W3dh6cq55dKrULZRNySsrShAksxlN63srUnFhBJqfi1Nkp+/ys +fX3Z/uyNxg++cOaX377/vc+f+9bbu196Yf2NS53XDqt3t9JbXa2VFS2ZjYRYmSvEonWFlsq2XtSZ +ikYul6QHp0pff3X5rz489Tffvvrr79373V+++C+/eOcnf3T5p18++NefvPDvP3/ll1/Z/dbjwkuH +6aWyxKHBkB+z9XI+0Y0Kts2SLZPq6MhyLPDMvPDp49xbVytffbz8H799919/89Zvf/Dsf/nFp/79 +7z//42/c/NobGx+8sLg2mbS1KM/YcDv1fNsUhLRMb7dj00lsKRU+bDPPbafeuNJ96Vzz/k7uC7d7 +v/zmjR9/cvObr21++fmZt6/0Ls8nl0tQUzGZEhlcByczNhTmUFZGgwk6MOmQO237cDZ/MJm+tlp4 +8Wz1rWuT7zyz8NYzC+d60fNd/ahnLZedpChrNC9RAnh+RUhKXMqQc1EpXkulK5Za1vmNWuz8TPZ4 +yn7rSvMbry3+zTfO/svPXvrrLx9/9dHsVx90X92zH67oj3dzWxXZJoMcgqtSxjK7NBkDDKQitBAJ +xelw0yC2KsK5LvP8tvnqYfrjB73f/dXz/89/fPLPv/zUr7/74JNXz15erswU47qoRxAdR3giGGLd +dV1kQeebNjeTkTbqxvFi5upa7vmDyh++tP5Hb55+597cnb3qXDUqsmjY7/ONh8IhMZ3oNmrrqVhX +46IGRbcT5rmV/vWDhekMeXFGf/l8+yuvX7lzevLaevH2bnl/OtbP6xmDB8DhKNttV4jYFJ0GkAeC +ziQacc1RMNxm6FJULVtS3RHWm87xQvHGZuvKWuXMbG6+lJzLJmEYM7ooUAQaoYJB1u8XWCpNY1rE +F0Z9AS4csRl2KpfZ6RWP5+N3N+MfPT/9vc+d+uTl5R98dOkHXzj+zptb3/7U6ifPL3xwvXl1MZoQ +IwDtMqe7rY/JOE3YQQCiMFN1kt1ULMsF+w5yuqNemjWfWbG//cbWv/3tB//ym/f+09dvfuf986/d +mLu+W17txICNNSVj2xMMHWMZC0cElYt2crWcwpUNuukIZZVpRMXZnD2d0hfT3KX51L29yQtzhZ7N +1XQ5IykGLTAoF/Dx46PM8CA4QEIXkyJG8eGwgmJZXa8kYvVEohmzCyqXFZmiKtRtKc4g4AVTgtwq +dGQuBlSCg5NH5Vy2SxFmyA9mm8JDtMaolXhxdWpjuT3dspS1ov7MWvFkTb6ymD87ndkuqzsVbSWv +L+XMui6EwRaMhtGwxrMlDAEMDAFpeob9ZMB9sHlFbNlySUZn09xGSbw6b799Y+q924uPDrtn+5UM +x0koY2n5RHahPX2RoxO6nOIplSPggehRSdc42ZS0VqFQTZolRyo5YkJlLUWIKhrHyjgpA6qPjWEI +oslKluFiXj8TCcsS65iynYvnS+kKEw4nBbaZsKsp0DRLpUWFFgAokCADJBUOcl4PNT5OYXgylV3J +FFbcJWRqjmeiLCaYcoJCoEwzUd6aqi/Md5Z71emk7uisGBXjtosw1NCwx+dnEDzJ8nVZrhlqlaOi +Y8Nez4gPuD4qxRw1EVOtgmW0suZKO3G8Utjr2ecXchdXWpvNzEzW6Kftmm2hAWRoaDwYcPe2j43j +g0MB4E2ayWczi7XSSindURk2JhJ1iyspRFFGT3Uyr1zb+9Sds5e25lfrlYwqyxRJYRTHxzDMRjHL +F5AMu9foHtWbh/nkjMqaqzMr1y7eYjERxksg1LiaKcYrtUw9Z+VUWkO9NBZUPYClgxEIqnDECQSi +Ab+GoY4spCNelAxCrSc9Y5j7+ivAREIijugs6XBUjELFoCeEB5mIn48EBcGdsTJZKqm6m1kmg0EF +sDfgYyk0ypGWZVQ1pQmJwyC8xigT+SruCyXkeNau2KLNRVgWVRhc87mdxoMYajNU2jvOPPW/jJ54 +ahR4k0JVW3FiWpJBWTpC6rQUlzR3Ly6BWAxusWxMiDpCOjBGeN2GMJ1S6yCWmDKtyU7/lJOs4YRE +M44RbRTKG+nCEsNaJCEbcnyyu+DxY8MjIY+PF5RmNDZjWFOC21krI4u5/vQpxax7gg== + + + Gk65mzIIKhUKGwRqsoQR8OLDQ/6Al6fwuCRWGSYPMoWgVjhsSEIWbInXJ3r97lFHBJkwojXbaRp6 +KZloiu6SD3eiDcdt+CdBqshKVdWrpjMRtRuylFTUIkYmQ0gUQc1wxMTJBI7HgkEZx3SWtTUtL8tp +Taskk5OxeMs0SiwuSqwchYGV0uPjoaCfwNCoqnbs9AbOZL0+Zng4MjgUgsDAybxqdNwNif8/e+/R +JEmWpIndganKzAjnbpxzzs2cc+7hHh4enGSw5KwyszKrqot2T1fz3ukdTrAjAFYGu4IVCPaAAy44 +44KfBKhFY/Yylz1ABCEj8dorOyPSzN30PdVPv8/8mWpJLBZFjksUocKTMk/wnur124BLPs3YHB+r +N7XyaCYteA7n5iFSGN+yBp3+lWqMMDzCcZuivaSyrtb3i3kJQ2B6E9PqOf6cYioo5pJkYOhjXR8i +ZaOQV0Sx1xs+8aO15WwxfD1fAM9RbaXqGDXQaIo+iJvH9cH5MO1Ie3DTbdySxHhr+UxLq5f7YbSu +Nc5a3etK66KAuBtZYTPL4bhfKsj3Ps3nsozlLOqDJ63BIz/aA+/dfEAQqFku6vfuYdksy4tNN9it +Nq79cA8jwhLiZHPp11KqlIAzZ9K7ZIXsJoGWJJ4NPGtga7VijkCLtECZAuPwsNyYmT6yhNkkW8Gp ++N4nhbB+Imhtzag/vv5iuf+clWuy2ePlpuH0bW8cRsvl/huMsXDKkrVWUFtySotkqxRXN73t2eLN +x+//rje7zBQklAScOElaTw1vT5C7JOUhmMbxkW4Owd9oNmH4punu+MkhIKLtTAyji+IuQYUUG0pq +341Wlea+5U05oRYnq97w0jB7rjeR9Z7hL1uTF7XB46R16icr3eyuDr807ClJu5bXk/WuG69Ue8LK +XV7pBsl6sf7s8tkPnFTLFUUUt2Wtn27wk5qilj7CE/nj7dVzJ9iyg5liz1lpIChTw95DcYCdCk6m +ewLLqERRlmX1TWctSgMM0XFUt62RdvNEg+nOm4PL1vCxpM8kfUpxNYIOFb0nyi2K8nStg5M+gjic +WJeNASf3C6iXyUqiVMUJrVBIC8nSbEUzJrLaV7UBJzQlpacZIy9clcomSSU01+KlPs01JHXAic1s +js9lededa0YPwVSMsES9L+hDQR044bZhp9syGS5mxXYRdREypMVO3L6y48OoeR7WHm5mxEJBVdSe +YfUJKqAZiP0aTlQBnDm+QRBBPi8JcjtK9qJ4l6LjtPco5snGVLe3fW9Ckxa45f37WCHHoyUZx0yG +rWLp878BQYBHRaUcB7Am8lEQ73jJvh3tmuEuL/c2NzjF2lLMca2x9+7z3062rwjOZ+U6I1aj2m5U +P0wrhvlbarrZZj9p7GCMXcA0hAhkfTrZ/jDZ+0l3/ko0uiTjadbEjQ/d5JhXx7TYhvkP4nWtdeIl +OwAvGOFZ3na1/TysXWr2kpdaNFuFCzCcLZoLCdLRrBF4RWtw3Z886wwfVZsnjebRk1c/172JZI26 +izf7Vz87e/6Lo0c/6229nO68d5xZq75z8fw7nA1YqQau5VZOmsNn0/XH8epDc3jNilXV7FneXDUm +gtIF/9SDbcOdHRy8e/Lmt6Y7yRR4jA4rrfP+/H1r8E7SFiTbJJgKLdRu9sJZJGXl0y7MTlr7l6sI +UodkqmGylzSOODmmhRgWUbG3rSjtsBzUDsHHcNzdWb8Kom2wt1BWARJFbSTpc9PfU8whzXgkYfje +2A0WAMUkBQCY2P5OpXle71w22uelsmXaW5a71q0lfBbOVEp4kCloBF1J6qei0k3r2/MVxRyZwcrw +14o5QQkXHNuNdxnIGmkltCmn9ILaieYs3ORAcZY4XbH8nWrrYREBt3TAtQRxYFhLP94Fiyi6QtGJ +G+5AIgYPzBdkgnQtd17vXMj6LK3ZUpDgqlA8BGTbuF+8f7/8ICNgdN1yt/14TzXG5aKKIoZhDFQI +YSaBV1o8k6s53rZmLfujZ73xtZ9s80pNtQZhfY+Rq5rVN9wtcELDnddah5PtZ268hZC24c84qc3w +DVHrYlyTEie00P/jHn6MCiiuaoU7Qe14uv7i/MUftk++o4QGw8Sd6vr8/CPOJWUyxsgqJw6d8KA1 +edmav7LCedpYrXOo2CMrmOvORHemZrCsdc8rrUPJaIe17Rdf/Nnl259P9141R4/dyjH4JBiyNX90 ++fwHmDHDGfVnL4fLj/PDnwy231jxLi11k8bByfVPe5PHKObXGifnT366//Cr7cMvH735rVc9BBAD +/9HtsWJ0aD7k5dbRxc8PHv5yuvdDbfCc41usULG8vhHMMgW1jFiAXa5/7CdnldZVa3DFCJ7lj6vd +q7B+Dvgw3f24+/C71vCRnxwA0bKDJclGhjM0/W2/sgd5wQwOEDJ92C2KV0enX0hyA8VhlWM/2mlP +YAYO9GBfUCcI5g+GjyrVvQJiUVwLJyus0Amq55XuUzM4xOl6s3Xw2ftf4GllPzlXNAC4NIDQ0dPL +t3+pGdOvfvL7//Sf/4/+6Dxb0Mt4YPiryfFX+09/OT/6xq8eoYTf6j+E0CiWrExWYMQmyQGuzrrj +13H9olxyCNw1zAHEVKHIAXZlCnoRc1VwodpFd/7u3gMyl2NoxsepCCdi8EmaraN4TDB1v3Jc711D +gi4hBp7ykzontqudRyzf5EFhqT0AEzvcmyw/7F//qWJ3k/pOe3w5nD+ebD9t9E7caA6TafqTyfoN +rFraNteaRLWzwfz9YPE+rB6DmWXSYaQqwBRkWEkf6h5E1qGozb34YLn/Yb77gkn3Hu95ydoKVoo5 +s+P9oHFkB9PTh58//ewXfmWbTavKt4EJz3bf7T3+MWiexdXl8fHLv/vH/2W29xjnY9na6s3ebO1/ +vT79tj9/xIlJoayIaltQ2rQYC0YH5yu6t7U+/e7h09+Olp/p3gJS52znvWpPWblthfuj1fu4dW75 +a8CrpHmQLdAoKVZay3pvHVRXJN/i5LHj7zW6549f/Ozp659nC1IZNTV9tr3+5uTJ76L2C8mYK2r3 +1//mPwzGVzgZAioeX33/67/4n3791//x/M2vncoBsAXPX/z9P/yvYWUnV9QptuXGp63x2+3jH65f +/tl4+U5WW+uDV93BcQGRcSaSrWW19+r08e9XR1/uHn9hpoXyet3x43QRydDyt53kQPd2JH2rP3m9 +f/olzdaAKgNEW8HaDBbpplapD5zt0fPvvv3V32v2kBWaSf0saYAA3pPNmagMgI2oxnS6867SfJjJ +aQjq+5XdSue0NXo0XL4EXCoXQKUf7h5/BAKcyYmQ6/3qlRms7WhP0CacNMrmtUZt9f33fx4Ek08/ +yedzHCc2otrF8ui7V1/9zWD2DEGdb37426S2i5E+BuzeWlFAnJga2BI3rmY73776+N9dv/m9509e +P/9msX4MjMsL50n9YLx4Ml+/3tp/2xhfGHZ/MD4fbb/i5bbmjnR/yqsjSKy6tx3Ujnqz55LeBbam +O1ud8WeT3e8Wp9/11+80d1xNth+//GWtdwBuEFQPWqMnp9c/fPjq33744e/XJ19Uars76+fbuy+9 +cNEaXG4dfGiNng3nz86uv3/5xe+bw73l6snx2bd+ZV82RoLR5+Q6MDHFmIe1M82euf54ffLGDKYk +VwkqB5AUrGhfD9aLw5+cPP0V+GRYPaz2r0+ffn/59ne91eegk1A6IejIi7f6i8corTrxWDInmrNq +j540Btd2tAIrcgVRkJq2v2X6Qy1Y6MGxV3uYtC5q7VOGT7tZ9YZnbjTVrFbS2psdvW+OL1rDi+74 +SWdwyfAJwGPSPEuasMrruH0CRNqtnvvJUX/2IqztoYQ1WTxZHn70Kgdh9cDwZna4kLRBvXkMXq0a +PUlpn15++d1v/vvnX/5h//r78ep9WFmrauP165/++Nt/QsmQEWqVxsHy8IvF4Rfzg/ezg49A0r79 +7s9PT9+zbCwpjen++8PrH/ce/nS2+5PV6Y+qtcwXTVntkXQYN47i1lnQONb8LSA/zeHjZv95JqtS +dLXeOZe1cTbP5Ap8JifRTBPmGYSA722jqPlgAwP6qpkTKfW6vqgMETwAKHv66neN1hHwVYavgidA +chSkLqRpYFxx46Q7eQyxrOvth0cvO8N9lg9db9oHyH364/XLX83Wn0WNten0dvaeL48+IEDqxNiJ +F93xi8Xet72tN53p83r/3HanvdG5Fy2C6l5r8rw+eWJXdmVz1Bs8Pn70i6i1z0qVyfbrzvBq9+iz +tx9/dfrk+6S57zijk6O3e8ef6Va/0z99/9Uf3nzxFxcvfnXy9MfR6rUXtL/48PN3H35D8wDCAF9j +O9wGH2gOn3vVM0kbt9uH3/7yb6udPUaotvpXQf0sal+Pdz+8/vpvTp/8vFo7fvnZrw+uvla9UaV/ +4VQfKu46qF80h68mOx8Nb2HZnW9/9leACTgTM0JD0MaiMVWdmaz1+sPH063nj59+PHj4uajPNGcJ +gIyzVVqs+ZXV/sW3KWzKlWbvuDt/3Bicj5Yvq90Lmu+wYqszfVLvX5BsojmjxuhRb+ttb/H54vCn +/a23Xrynm4OvvvvDm4+/MdwJkCtR6YNAGC9f17sXUXUHGKyitU7Ovzy7+rLe3vOr2+Dtlfp+f3z2 +5v1vrp98D3rB9Rd7Jx9Pn/086V3o4Y4e7AB9/fzjr/v9fZKwLGc4Wj7rzx5VG/sQbqq7UyaSfNGy +7DHNRqvjD8+++qvDF79ubb3qzJ+3Js80Zy9fdIDH7u6/1fQBRYF4D3EiEoDzuDuqPiXJJJPhCNI3 +zBmAUianoFikGUvN3A4rF0nzAnRZCTUgoBiuDqpBVjppAXncghnglY4Trqqt0zQ67JR5GkbbtCeV +5gEEo+XNgB7r5qjRu7KTdQaSLxeCa01Xb6erD3a8w6vtMuFoanux/crxxqrWBKA7uP4B5v/82a8e +Pvvd1vFXRjhnhGT74J2oAKVJ0pB3po6/1e6edAbnujMUxDhJZrXGtD8+rPeOgtqeCjTMabe7B2Fl +AUlE1Qc3fSsiSgydZBU3H1ZTGDmptHdozne9wRff/vXTD3+IO+fVzsP0oelobtuDhw8/P738CpAW +eP5g8UV98Ly7/AIwRAQuilnN2uqzz3/Rnz7cyDKc1AF4ac9eJu2HENr1xv7W7PIf/+E//tlf/HuU +Sgi2JmmzsH6xf/Xj85/8u9XFj7o1ff36u//hP/xvw+klaDTF2ZNtoND7s72fnL/9C1g1igljkEW1 +XVEFf2tycpuX2ro5bdyg05NX3zU6B0fH76JkrdkT0BokWysTHgZ605qOZq/cYMsNF15lLZuD1e7b +w4df19rngpw2TuoNHtYauxKsWvW0Cdx1+rzauza9JSwxyIRG94wXWzeizwQwtKLj+vB1rf9E0vq8 +WJutHp0+/crwx1k4AHckfdSZvIRTao1Dz5ul9cEEr9E6ZLlGsWhmcirkxFLZY7lmuw== + + + +3Q0/dywZr3BWad3SVMRhtpA9fMlCzzNdLYrzUuWa1nBwvAmEHcQApLWBYquWjMz2GGkLsFWOKlq +OgOMdHR70BxeVNtnce1kvPgw2vlCdqcY7VY6R359D6U8Xu6ATFNBzY2feMEOHKaaQ4YNxltPx6sX +9f6Zm6xVb8IodU7t1LsP26NHAA6g0E13ajmzZvuwOzyNG7tl3FLUWlLf5mRf16uOP/XjdW8K0vII +lJGo9QgqsryV7s5RUje9Tq1/Mt15dXDxw+rka4QwiXQrfn/74LWgd0E6pYXB9cl4+Wy2fjpdPVe1 +rqJ0bQ/0VyVXFCEKqq3jy6d/Chwjqu7TaXFCMV+SQUeLSr1YFgE3gsqy1z+Yzc6ev/im1dkl6MSL +joLkzIv2DG8LJAPgW1TZ3zt6f3b1E5qvkGw9bj3ubX9V7T/zkl2/eihoacH/i+tvh5OHIJYJpioo +/f7kxcMnv9w5/Hw8h9R5PJk+/Id/+J/Xe29JvlPpXbfnr1rTZ/3lK5hwlq8d7j7/z//7//mz3/0j +kFXQnqa/W20/6s/fNAdXQbLj+bNnT7//7OMfJL0PQMoqPdWa+/G+7mzz8ojhmrXaavf4jah1aKFL +8R0ED8uIoxm9/uTi8OILVohVtWPZk7i6v3fy5cHxe1HplRA7X1BcZ3p88qWsdDc3hXxe04zZfOdD +u/9Et5c020ni1d/83T999vZnGxsk6AKUavLSuN44bzYf+v62KtfBfEnv0FxMM4EbziW1rzpLVhkC +zW50n1SbV5XWKcw5MM+ovmukBfknnNxhpY5sThrdi73z77zKTr4kwfVo9lQy+o3BQ7ACsi0rVNNS +b6NrzR4ATIXV/drgarB8uzr94en7P5vufsaINc3qpu6EmhQVgbKQ1CErdoF2govSQhgnE9BZCOEC +C4UJQUkfPsKvHJnBrqj3Fb316Nk3ljeS1BbEKYgC8HBFbXf7F6dPf0amLfYaljNV1B6Qt3r3MG7u +kUx4U9h5THMRguqq2Uuqi63lZZhs5fJKJq+WMY+V2kG85vlQlnw3GLVHJ/un79dnHxuDE4L2gKU4 +/vZNdQgZ4gKo8vroq7Onv7XiE5So5gtGpbKTNPZxxgcXBS2PYAEvDb3kOGicQdRQtL/cfQ0UkU7v +BtcoJgEE7vavxvM3ncELnKqSTL3SvgDSdXNXwSdpn8DTKnDP3/xisfdSkBI3WPQmT2Y7b5LWCcXX +gSsCH1ssn/f6ZxQTWP40qJ9AJO6efdsYPEHJSqlkxtFiufuCl+qi1DPchRPty/qsUj+abb+pNg5Z +Njo7ebtaXslSQpA2I1T8ynp99uXBxXec0CbIEMVcgWvwbL1ctgjCL6NwTNrxygsmjfpCFKrFom77 +q0bvOU4E5aJSyPEkZqliIutjSRuxYgcgOmnsOv6yPXymp41sdqY7H0GOufEuSjgE4ShqC1bEi1ea +s2UHeyPgDAdfzvfe694sX5RUvc+KdVqsa8GclZs45Fm1W28fdyaPJa1lucPx8mXcOg7q+2FzrzY4 +gkQGrqU7Y1AxCOYo2hgkqpU+qTGl+SYQHvD28fQSxCnJVwVtQNA1IISWC0J1CaaJWh+ucHX8BU6H +qtaebb/ojp8CzXCDVa150hlfg0LXzZ5ljwDYaaZiuFtWBEjYpriIk2JOjKNoK4znZVQsIUKhLGdz +Esk0QHOFjRNJbqpCcLC6Ojh6TbI+hJ5kDnmtr1ljy9lS9SGCGpbdrbV2/Xie1LbtcElynRICqjzp +Dx8F1Z0SqtCMy7JVBPUkeQDTxaaNF01FaT558QPDJZubNIraFFtx/MX68OvV4bd2eLyRVYqIDctR +LGs3JWgsho1Vpe0682rjxPIXhtmtt9aSkjC8B2HCim3LXSS1Ay9ag5wkKbfdPeqOr2E1DX9btreK +qE8zdcOYwWE0HelqZ7bzYrzzmhXawIU4oQWyDket89O324tzVUlMu11trHqTh9tHb4GhlRAnkxWL +JVMWOqrU2XjAFQq6rA8BS8fLV164TRBePq8wbLXWOvXC1YMNMptJKwTCBbvuzIv2u5O3YeNJUH8o +6y2adRW9LqtNCEnVmYoaoEcXYxpgL0wpjhu11lG9c1VtXAK9gQxI8jWUikGx8kJCMT5kt+HizWTn +vRcfGPZWUNlVrYFmtkeTy+n2S1qIKT6ihBjU4uM3v3r79V/uPPwG1DpOuiBCAdMovlZCLJyqAXaF +yf6TF3+6vfc8rK5Wh28FuYsSPjgM8BDFmHgxXPbL+eG3nNhWldpwdBwlW4IM5A28OpT1keOtvWAl +ys1sXhAhWZsTE1ResIQsX8Itmo17/QtIJZkMnsmgxbIMApxkG7TUIfk6LKvARdV4aTuDQlnVnYUd +7oNYiJtnFFcplU1wrcnkrN5eEZQBSRMhAlboxjUgdYewrIWyni/KYbQlya1sTi6jLs13VXO71X0y +mr5u9S4hfXBcZTy9CuKttBI4ZqG4xyt901sL2ohXugiirLaf9QdnBOWD4CLpBHygUNRUrRcnq2Ja +gJFm01pALR5MFus4HReQtNFPtb5frR/ghLd98P7px3/bGF3DRIlyD7w0nxcEzg/DMfg8hjm82NHM +raR+ohn99Jk4TFOU6v7Ry2ZzIUuBZnVwuiLrk6R+rOkTnmvm0vohcrN1MJpdARqXy0Y+L29u8gxd +iyqHQbxPkgFSViGWZaXNUFGpqEFom+5ITplJDGldkNrA/EkqoqjYhEgPVlaQMlJBm3PAvigPIIjh +KkDbeL4hqyMnAgH7xA7XOOOUUJHhQbMMdKOddo6zZqAQo/oxiMHZ7gfZnJYxU9XbAGX96aPT66/P +n35b652IRn+0fLo6+xg0j3JlRZS61caVYc/dcG14U9Mdxsn2YvctSUelsuYnu83R697slemtJH1C +8y2SicS0T1OLpi2WCQ17kdTPVgdfTJdvQBpAaOeLiqQMQHxJWm+8/XK29xWkJ8tbArhRTK2MWCQd +4JSLYlZYORyt3g1XryfrD7XBc0rogrSBXDlfvQkqewARmruUjanl7dz0NIHAD5uN7XcffwV/z5dN +TuqJ6hB0UFw7qzQfG84S6ArD1h13pWgTRZ+44T4ckCvKGxtp067B+ErW2yQECxnSdKIbQ15qYeAk +ZYMk7b3DF63ePkbatr/VGj6J68e2uyPK43xR39igsjlO1zqZDC2I1WrraLZ+/+Hn/3T46E/9ZAdw +g8a1yewqTIDMQ/5Ki42AdTjhKsBk2Eq+IKYFedJ6416+oG9ssoWSBv8qCBVDr4m8aRgVzWhB4isj +aU3v+/exe/fKxYIicGk/LBRTSmWBEyplxMXQCMSIYYFyrOSyoshHohAWC0xuk8lnJVGGHJo+r8ow +iWEtg/hENuY4nWBEIGtDTmoRTAKQpVtb1cZ5vffYjldl3NnM8AQRMBzo5QavpJV84sah7kx4KcFQ +DkdYlrUNqwe6cpB+R/PD1uEXJN+CvMnxtms3XBeQHLhZH0T3bPX22cc/Hx+8ldwZkAfLGetmm6Jd +xRiPtl5/9vFvX33+d7Pd79JCYbgVhFumt+DEJvieZi0Uc7szfBlVTmi2gmOq4wBYzVWjCy+KreUK +ehlzVGc+mL8Oq4eK0R3MruLGPsHEgGw017D9dWv4otK+hImy7fbZo+/n++8ZuSmaYy1Yi+ZMtaeL +vc96o0tBqkXRfLD1VHeWTnCou2tJH1rupNs/W+68FNMn+5q11lmje15pHsJsMEILmHAuLwl80zZH +CCKBXqMAFblmkBxI8tCyF6o+LqNeUj0wzHGppJNUzMt9Jz6sdq/bw6eC3AQshQubrV5qwDzTyof9 +IhKARRjusGwiS9Vcljb0dqW6cLxhUtsH8Zs2pCgKlt7ynDGQSRz3ALo1YyLJXYoGCRBC3s/leNuZ +yMogl1MguIB+CHLad4xmq6WSWMgTQTCs1vfKqPMnaa0/EUEA8RQc81HwtKKazTHt7v7O/htI9/cf +MHAAcC2ea3FMFS3r8OYPHmBI2cBQjxVqmQx187WpBcmXk4aCOgaKzqtjw1uD7iuiuqIPo2RvOn8z +3/3arR+WSb+AOJzQRfG0uCsvJv3Ro8tXv5/ufq05s2KJ5WlN4F1RAp+sW/7Mrx2YEWTGhaz1RCkQ +eJNjDVFODGdkOONa6xgEo1Pb1+O1GaycYM6LgJkuiOVq++Ds8pvT6595tXMMDwW+IitNkvaAA0eV +I8fftby9pHWl2yuMAP1rOFbaz6tQZAjSUrQRjke80PKr+36S1nxW1HpvdCLIddDCEDW6Ne/PXrcm +rwx/B9bdNFud4UPLnyCEbfir2d7nR9c/A/gaLd+oxgA0zqAHGvYEwX1F3+qOX51df//k9a/2zr+p +tE9JwqnEs7OLLzu9E4yw0rZ0iEmzNdudK1JHYONSkQvD6XTxQjFGvARwAfPmS8qI5btgBawpkJZ+ +/2o4e264S9B3rNAqph0oVFluDydXDA8z2QV/070dRkyBGkh+Wi0/x8lirMqxJEXN9pEdLBm+Bhgo +K5AB7c0Mi2IeQQYFAE8m0fWxIPWZm2qEtj2m6GqhCP4Mb+WBF6FECB/KSw1JqSXV3bhyAFP6yT20 +WLJg5rM5pVC0UDLCKFANXRBKfrCArIohDk1XcSyAPwtpOw8xzQJUZLtbBBEWMPfeBpnP8+AkktIC +GG90rq5f/P761V/tnP7oJYclxBDkhgmUyeir9kJxdwx/v9F/PV19k/YbIk3H69n+KKof8sZWDk+y +BStwluPh42rjgKRtXgwFpW26ywVkmfYpgiuFMgN50/SAkKctisCldb3dn15N9t5pwTYjtXEqBjOB +L1GsFwSjINkO6qcw55ATywismipKKeDwUhfDbUFqRbXzuPFINXd4sZ4vMBubCEE5qj4tltJqt6LU +hiVO+5UEM88bs3yFID1wclgdQemq1lbSvGwPX+jOXgo1qApof3b+DbiZbLRpoY5SVZyuCnKn1gJ6 +XwPl20or+L2eLK764wvNmaB0BFzC97farUPbGeYLAlA1YG402xKUHhCkjU0umxM8dzwYPcQJK61p +gDuqMV7ufr7a/xoIT76gCkLt4tE3AIAAp5zYEeWhH+8HlX0rvUMVFQqSG8yrrQOSizZyQhnzab4D +DFDVJhwTSFzgmO29ozdOuCzjwUZWZoQ2RlUJphFWT1JSlGU8e9hpn9+Ux9EePKA2NxmCSjihSVBh +NitAZAXJTrN/3Ro8ldQeyzXA2SDFA8wK0qhUdiWx4yRHlf6V6S/TfUSYUyyo4EiK0K1X1/k8k35t +fZ/imCbH1XAQfaQDTAwSB5JubvEB82W10eicjOaPRovHk+3nUWMPsj/HN/Q/PomvNjvDx+uTn87W +X3amr4GxAE9IC3poVYoLDGfhV4DYHznhVX/42WT2xo92EFyDAzQLxGPCpNKsRbGx5U6PHv70+tWf +Q04ppL0aNUWrc6BVjZGdHDBSr9l/Ply8F9URSPXx+CSpLjEqQED2Yj5oc1Hs94YvOg== + + + 4ze81AcmgBOmog4AuFKNhjk4GQDprTZPdk6+IagqQyeK2gOqz0kd0FDAHwSpo6hpAcBCSYDgArkx +WTw/efwzXhll8nKhpAhSxQ+2wAdu9mPMwGlPHv364PynUtpbRwAm2emfdPrHQH2jyoEdHkbNR8A2 +ObEHAZvJsmn/FGucz4vZLI+TEcW1LP+g2nr+x41GhQKP47qmNYCxkJRFMSEQeEUeKsoYQiDdqUIG +CshhKqToCOILPKSIeIKQxNWFarSBXKlyq1I5qLcvIMWTVELgFks5ht4wzRpNG6pSBw+vNfbr7Yeq +OaP59samUCzwHO3wbAgAQlIBy9Ute2572xSdQH68f59Q5Ea3dyQIUSbLQY4rIr5obse9z3qL1443 +RctiNZqMZtegFj/5FM/k5HzZoYWB5h4G0QlSAu6Hm0Z3vX638YD69B6Szcqc2PeSfYL0IYppNuTF +mukMHXcAClQzqkzaGsOk6SAItqvNY9Od8GLFdEZhdSmqDbAdZpJm0nBWrRErVTVz7Ia7urOju3vA +NoE5gD9AlBnuPKgcAwQBWw4qa9VIm9UmjX3FnuZRO1/SWK4axNu6OUwqh93pG9GAXDwguFoRBQQO +OKXDiM18CZLyVLd3gBUwbBMmB2QXUCnwbfBYYBfFooiRDkb4lr1S9S3NnDFCp1S2eaFB0Em+bDFi +DxK96e2CggMfS7vM5GlwIUmuA/CyQlXQppIx091V2DgpIPpG2gNRA1FDMqD0a6o5BVdX9X5//Kja +PNXtMcsEIMeAwIMuK6FetqCimAvwaNg7oPezWbZYEIplFcV9URlb3n6+aCGYQ9Ihm95PqJeKPIYq +IIuAJSr6CAQRkFuAFJKugOIA+QC8lOHbprNqD17B/AP3uGnjpexuP2/WVxRpIWUd4JGmPObmVcxT +Aq0uxgd/89f/o6HXiyWtWDLKWKAY4EJVkkjLUJTLvOtPVbVdKmlwtYUCEDMdSJQgpE2xS0UBJB7H +dyRtIukziu3mckJaP60oaEpVkhv3HpD5guaGe2a4mzTPDHedzZuf3iOBs8lSeoekVFLDaGl7a0Bd +BE1lF0STICaq1gnjlQiSloPU6fyxcgJD+4Y5dP1lVFkD2mhGV7OaJOMU0/Z5siC00vYxRl+QK8C4 +lLRF70B3lxRdS+vw6GMv3lscfrlz+kNQO4Gll7UWLCIBLkcHGBnjTENURl64jmq7pj32g6XlbSOk +z4htAqBYHfvVczM8gJwFzESQupKabupL90CWbZA2OFEx061fzc0NvJBjFBWYsymIA5Ju5otwhS7N +1sEhMaoGpyjmQlCnsrFVwr37GfZBlimWFUlqUqTD0g7Epu5u2+GubG2RfKOAaAhu00CVlQ7kL3Bg +x18nzau4erJ7+HVSOwS+p8s1CEOAvrTLKiQXsR8mR1urD5q1g2JhLieiqFlGjNzNtmRJHfPywPZ3 +bR/+1cpk2HJZY7iY5pJCWcfpGKQuCEzD3g7iQ5Cim7m0hjzN1DihbjoglnfzaUtTXeEb9cqOyIew +3OWinFZvLin5nJDPyRiiuUazVV0O+3vFQloIK+2vwVZBMsN0ZbOATmUcN6PqIaxmNsNybBWQAQQs +x9cxzN/YIB/cL/NsIMl9BPOKRaMMdKJslkE8pj3dPHDFTEaUxFZ/eAFAVEZ0+HEzoxBkhRe6sBaZ +jFSrLn7+m3+XJNv371MPHigM3yBIF0GVtAoNkz4NwTIReHWpDJox4LiY5SJZrZt2X9W7vFB104aV ++0DJ0lsuaQUPn2ICjDBQTKdpj+XTvQQY4bFcbDmzavusNTivdo5Ua8AKMP+VMmoUSyrIYZ5vMlxH +UIBOz8A9GL6S9izD0ruIrcHLoPbIr1zb4ZmgwIlVmg45oQpJHP4SJQ+d4EQzFvACLV/GzMwmTaCm +oQE9Ng1z4biHgjQBfHOCXdvbR4lIkWsQUwQVE3SNV8DZWozQ84I9z99FwRsZb71+IqktoB+COuOU +tHO9E8wUvYuToPJ4Te8H0S6Zdj8HZ6iXENBBLOQ1hvVKZYnlAkh2DAfmNMGHMzk1XzAZtuV6a4g7 +YFmlkkHRFZgWhm9RDCQ4NZtXWaFbbV1G1QOOT16+/cXR+U9YsUcxDVbqImSUK6XaluFqpRT3dIg4 +QR4DEyAxJ58T7z8gNjY4WeoAFoELpVvUubZnL117zvONXFqpjy2mHffUTAbPZRhAFZKFy2sBtkhK +v4y4GxvMaHQBcQrpEiReJisjJYNnQsfqwTt8eg+/d5/EcR9QMZdVNje4HByA+LI0MI0RZO3NDJ3P +C8CmgJUB1yXJuFx2MMyuJvPp9JIko2xWF5WtVOgRYRnzMCouEd5GXsjAbJR1WeoF8Y5mpuIIKFMp +7QUjcpwPyavaehQkDzmxK4htlq8XSvqDTWozyyOoSzEVkMkwGyRtpZWFuISXu6wA8rYtKu0SbsOb +g/ChqYggIKglmvHFtCN2349WaXsaoQ6X6if7lr8NBCmtf24MnGARVQ5ZqZVLm3BpIJrSKkl0CKHE +sSB8OnH6PdocnLxQkMFAHlQSDYkyEcSmKLYhJ3reXBAbaT8yxK22HzvhsWYuXH/F8i1IT5pUq1SW +JUQjmdiPD53wAD4LrEBwZzPPAhFl+TbDVAFngDyUykEJCSFU8wUjk+XLiBolW5xY28gwhaKhGAs7 +APKw54b7IMdyN+UZcTKEj84WJaDEijZ1K/u9aXozBHgshLPv9r/8yR/2Dl+C7qMAu5QhK/VItqoD +wfCXKOrwfBRWVrm8kstLEDtAhCiua7iHXnyWyXAKX9uaPCEJFxypiADBsItoENYfzlbvDGu4uYGx +pEcRHoQzTDtwbyBXDzZFjKhZ/j7AYCYj4FgI1sGswlRwbJjuKSUCL9qttS/zeaVUNOFF4jDPc3Bm +DHWBbuWLKmg64FH37mH5vEqQkaoOILuJYgtN/RZ4piZKfYwEBTdhhD68aKFbxNxi2UhvR4tt4EUk +UxGlgeWAQG6CvqCZEPSpbkwb7Ws/PsKpOoIlJSTGiVquYBTLNtAJAugEX5fVXrphm6/A+wO7Tjeg +sklYPZL1MZBbDD6lCA7M0rSZpl3Gl/S2FWy1B9dJ4yGTfrkWAEJKYqXeWPdHl1HjlOIb8HvdGPBc +AuwISKkq1XjOl0QvbRlDu0BK0y+buIQg7EJehMzuOlNVaXNcIikdimvgdA2yMM3X4CIRzBSlOlyn +5W0BXRTlHjiAKLdMZ4rTIBk84MBx49xN9sFbOHF40wISYKQCDBMiCCBR1rbg3SiuotmTAmJ++mkJ +ANDzd0S5AwIwVwA04AF2hrMXo/krcFqMsKNkD64QkJAVKvmiAqQiTHYmyxfrh9+CWAbrmp1HwBJR +wi+hNvgJgFsmK/F81XKHxRtdeRN9XYBfnAR2p2SzHAGez1ayGRrYXRn3SRYox9AOdtibntogKyRQ +3JgLCCMrwJanDNMBwgAeLorpTadclkfLzoMNogwhqfSi+mlQOzt7+pv33/37auPi/n0G0AxemU0e +iBngW6EAZKzVaJ23+ldSuqFamc6eG+YURf1c0cwhPs5UnGBr//jDL/7sP6UVDskEI4Csdr3wWFLG +4IQQLOBIFJOAFZIE9HUBsYBgMPkdSe3waTuVLsi9Qtll+L5qrDVjp1By0k0XiI0RDvAizZgB5gBW +CEoHIwOUSG+gJY0j2YD3hwWCZOqxLMQL/MWkKFvSmqY/m67e2QEAVFdUuwwTCqynSJEoQSJLv7tJ +6kd+uMYJH8NMRW5JYhVBpWy2DOwUQXVYlPbgMUBBGTUh3IT0YZwqUpaBjTBMrJnToHpqR3sADoWS +CgsNroUSFic1SLaW8hwPAGdpunM4IN19YQzixokX70PmgqADKiWrM9BuKAqJRlS1UaVxxcsdRqhJ +xihbMu89wDHEUJRWqSQV8mw+x8Dnykqv1jr3wp2bdsxetblWNGCqrgC4xDQh1wNhWB1/PLz6PqqB +13UX268hdsDJdWeLl/sQzgzTADmPoBpoYVlpa/oQWBz4CbA4nAgopk6zNWBB9+8jmQwDiSObV/JF +DSO9NHxwD4RAkBzSdAJ03TS3Wa5LpotrF4vyxoPyxgaGlEyarAH80nw9aV3sXf44XH3eHj8Fblko +WPfuQVpMHw0A6YciliS3HW+72b4CgQnZHxQHsLLt9TvXWxaKJkLEin84Xn/+2Td/+c3P/+rZyx9K +mE2QIdA50DWSMgCQAae66S46lrQBI0C+M7MFI582j0tADkNwwTWDfCPZBJCTuLlvX05TYQI+yfEN +oEYo4ZBUBDnLTVtsXHBiq4Q6LF8rIloJhUTZYLk+Jwwg9im2iRPgYImQfqPtA7LRfKfRe9QYXEOk +39hlA4tDcRNwBiNcBAOAainaXFHHgB6g43I5mmMjKu14CzPZEkAXREfV1jOWrRUguW9SdJo3Q4Jy +GKHCyi1BGynGXFQGCG4WinzaN8rd6oyf1oePOblPMNX0RgduMXxEc+muNpCToCOag1etwSuCjjcz +VD4vUXRMUG6prABzwKmqqIFD1lgOVtl+8ADL51gkfWCBTx9kEwBGWnCiqLZ0q0fQrqQ2kvqlExzZ +wUo1u6CASC4GqNT0XlTZKaM6hruWt6NaYwA9DPXzOSWTZUolmWNjUIUP7pUh6StqT5R6ZSzK5IG5 +ySmjQ4CW0A82KCC6DJtwPNCqES/2aCa56coKsKNvbtLFgoIgdrGUFjkEccQyLV1fwurI+lCzppwI +ach+kOE3MhpBtSSl7XqQl0e5HEyjL8stko4gpW7mFJqvSnpf1sa2uw34A/AFXM729mx3K61LzwTF +goQQCc22Wa6dT11IgVcJsVRtAHoHsFH10vtFhRJwJDmTA7rl8NJINrdFbcrLQ1gIBMgeEYJDorhX +KBnwgnzHCWmNX4J0EFTFSR2/CaL0eTGuCq4IehykHDDbdvfJwdVve6sPQF+BAIPnUDScW2GEWNJ7 +tf5Tt3omW1OKrwPMFoFmFDWYEEh8QIYpqimrK808tP1DkknBfzNLcnyt1riIKmeyPkfwiGDqoIJD +fyHLDeB4IEvrrdNK+5pgmiXUw6kYaHZcPTLtERA/+FdVH26t3h2cfSvq/TJhl3BD1kGWjiA3gXUM +13Cjk6B6qZrbEK2bGbJQFIB9AchAjMDHwUwKypTmu0D2VLkJOEPTkevPxotH1e45K00woporqCDr +RKlx0zhbRTFVN8bt4bPu5EV3/BynK+AGxaIKqAvuBECUz6nlsqfoPYLyCpDgNum05CMdkWmZPjyT +4XN5XVaGte55CXc3s1w2zwNoYzhoJRmOT29bPWDQm8CHYIf0iqT3zyuC1L7RI26+aJbRkGQaXrQP +lm5sciAb48pJVD3X07YXFvDbTI7Jp306knJBuX8fL5WsuLq/f/55rXdA8m2UiBHMRbHAtLfSrr5k +KBuzWufRcPo5RoJ4aVFsl2TqaX4vyNk8zElcq52Mt97N976t9V7kS9ZmVkovDPVQgA== + + + NTomuaasb1v+nh2sRaUP2JgSg5xcLINmrGr6CqjaTXX9lD3mCtJNSx0TEA+UNcU1KRZivGKa4yBK +m91DqjWsVVw91Y0JCFKM0EW57kRLRumySs+tHG0d/hDUztNv5XJ82lwbM1S577i7ICUkfSrrM0kZ +avqIJNIa44Wiki+ogMB+vKtZk5sv3BskXVe1MciEMh6gZEWUR63Bi0bvCTghAE5acJgHqtb2gkm9 +eypbk2r3crB4PVi8E9UpBDUsTRjt1dpXjDDEyAYvdngRrIgxMm3rgxOw+pPW8Pnu+Y+avy4hKZ0g +KeADHUGuCUrixnPF2qbZ9MYIhBUEVzYHOi69P5CWQLd6uj3VzC2gQILYE/hOPq9tZthSScexIP2T +cCEwAfxlbcgLvVLZBnS6f68k8TUmTYgeBDgwjaRx3OpeAqAVSxyKKX4w8YPte/dxAH+CCguog1Mg +Uevprd3MTQ1Mvq3qW4a1hM/lRcgCcaFgK8oMVHYRpNkGCUfCXKFkDdJfseRms/LGBkWitigk6Zca +TEXQ553Zu+XB1zGAAGRwOgJ63589dYIlJP0cQAEei8pcs7cBfAplHTyBoqIoWtZqu7XmKcxtNm8V +Si5gF2DLZo4rogbB1gx3L6yfGsE2K/dosBcLb2i8eyMxYoYDQB6TTAfF40w+7XMEoMRLTSda29GB +Gx+KcpdmYuAJGJGugqQCMZ4AHAEIS3KTE5IybgDkQjzO994fPPm16izBezczXCG9g1fj+QRJ72Mo +kGtMdw1QrOnTbBaENguSHEFNmvUFuYESLmCant5HBZHYKyM2wCYnDXipr1szgqmB2pK0LVkbgWrg +RSD8NSdc1npnu6df75z+JKifYlSjhPrAXTVtdHMnqiPrizA5NNwFyddB8+ZS7HJNa+QCVfMWpNDB +mTon9iwHPnSC06CS6t3JuagOS2WnWHIKZYcV+iBOU6DGnGyWIkgriLZcf1u3IbnUSmUQdA6Oh4Y5 +M815MRXUoWkvFGNGCy0UjTYzymZGxFBb5ptI2Ujb/YCmi3drrVPb2wbyXERU0xo3W6eGPvjkkwIQ +UcOZepVjzd7npW65bD14QBWKmuOuJLmHohaCuMAkZYBcyI/alqJOAO7yOYkgAmAdWUCMkoUzEJ4N +HPMozCVBO3A1xZiG9bN6/5HjzXm+xaSpxPfD+XBygSIGICqIEZSMGalXxPxsQSthXhnzea5BkDZJ +25CpeWFMMyMMqxXLfqFsZfI8yVaom916COXRYjusX0z2fhb3ngLVAb+C1ANRaTs7zc4L1d67+f4l +ADSDwAFUv2kx3xO1GSw3cLkUmZmkWNIKJQ3ckuEbQZI+fF1GHYjuzuCyOThUrAYtVAG0bf8IkhFF +ezwfF8tKoSQpSgPOhUSfT28sm+ndbCIIwxUtRLJamayeGz4IrpBi6+mT5nm1WDZVc8TLwFJcBHeB +wMvmzPJ3U+qFQVyYYLWitQy7oWg1ko0h6Y+2PrrRKSz6TasjVdL6NF9BCAclPTtarg4/n+185ngT +UYiBjajasNG/poU0oEpIADJH0iatwSMvAhxQS0CwsQCcU1CnjNQvojDhwJR4jq/YzhjkDy8NARVl +bTHe+mDa20CAKSrJ5YFl1UWxR1IgtyMMj1luyPJjRZ2Vy/b9B3i+IPFCK1/UQUYRTKPSfRi0HlVa +T3ix/2CDefCAhpkH8cUKzTIRwTtAWBn2jgoJgq2DKNjIMARVgazKcs0y4irmtmQCyFQgjWKIA5hZ +yCs3bLyRy6nZjFQsAZ9Jv/cHIkGzEYJaG5s06EdB6MlKP/36gwSkNaNwhwCaV1aLhFtAXYSIIIoZ +bmA7uwhqs1xVAE/gG/mivZFRCwVIqbFhL+xoTfFVjPbTxwfkQaPzaLb3hVc7Ab6R7mPBvXTVSJ8E +WkVUBGVb1vdEdcYKQDCcm3uwNcfb29oFTDgBUg00LAcEDwUeDpIcfMwAJu/HF/X2C8ObY+k2MBnD +LYqtMmITIdxcgS9jjmYtRHVAs/H9DTLdcVRIe6hBxofUgIBpRAABbngrWmpvZEWciCHuCkWbpBIQ +gJDgaL7txScg1TfzEoCw6Sxs/wD4hmGPVb2Fk5amNDxvlt6XUPu5krWRVXJFA6CGE5slTMuVZNuf +TZZPdk8/3OzfVrJ5IKKmpg6iZA8nA1A0lr30gn033NesOfjPvXuFUknlBBCwTpkIJGPlVx43+p9J +2jj93goxNzapMqLDkjEpCzI2gUtvMgCzijaW1X4ZtQDh48o+6LsHm0K2YJWw6EFWhqUBZmuYcz3d +nbILAhkhvBJeyRTdzbxNMf1q6zpMdkBfYJgFeWpr/f7k+hdx7Ri02EZG2MhIGB4CuqZiLa/xUu/6 +s78drL5g5cFmVslsioLYTSqnwHL/5L/NfXoPJ6na7PjH+f6XujmB64SMA/PAS3Vw7HzRAqpAcdOo +/uzp+3+wvSNBHRZxuJgAsAUhQaoA7+ozwgiiw7QnolItISKseL5g42hVkeedwVPBGOQRzfWmq4OP +GF2huDopVAvAYYga0DaIU1aop12hCQ84ba31uj343AkPgO4CBSJwVwEN60w1C97E28gDQ65p2l4U +P1H0VSYL5FMHA+PGlROdElwthxi5mz0h6Wxn6c0Mg+Oe7R0E1XO48kJZ28iwqdBGHaCgwEs5ZRjU +Hi72f9rb+lyxtwvwEZsiQ9dyOW1jI/32BKYUIxPDWZ88+l1n/LoEKklqhtVDPz5V9BnIw2xRyRY1 +XmibaSNmG+RDejeMbfjRgR/DitTT+zBEigMMXyWYECXhx4ig6yRdZdhKKoXyMoKBnuoCyS+jNvyY +L8g47gpCS1Y66cZjqaXZq6hx5cWHkCU301viwN51YP4IkpZCArqe2WRxItA0kOpTUH/ZPNAn03Fn +QM43N3lBHI/XX5rBnihNWbYDc2Lp3UZ9gePK/QcoyXZFdceNr9r9d5I2zRXlBw9I15nsnXzgJJAS +8qcPyExeU/QtYMuAFSDSgVZZ6XNVS9UYZQsSxCNKNli+3+692Fp/jRHRvU/Tu6OgZRipDbTk/n0a +JAC4DSvC7O2CQCsAvW+cw6z2pp+Z/n4m7/zf/0rG6f/fF/D/1bgz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN +O0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu +27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz +5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaNO0Nu27gz5LaN0//rX8mYEv9Kxp+wbOfFRfvs +7dknu/1P2MbAPYGfF2efvb1888n0E/ZEb7x52358/vbxyxdnbz4SEfzK0CyH0BeXZ88I4Y9HEnAQ +MXvz+PrxC/jl8vzs2aVIKHBoDP99YhAmYdz8b/fjJ2pg2J5muqbjmYYRhA4RGI6vWUbo+17gB7ZH +PE8P8i3N9n3Ls0zTdYJ/edCz9KA//i6E93E9wyL++SzT9s3AMZ0/HvQvPu6/6qB/8XGPPll/8uKT +rU9CQhCJ3TVY1bj85PV/Mc5MjbuZv+7jZ5fRH//avIQZ+X8nE86CCeh9orcv3z8+v1z0msTu9JOD +9OR0Pv/4B/FfjEpNtl3N94gjwjJMwjS89PxH/3VnpFf0z2f98/8HhA1Xafo3F+wQ6bnGJyx7c42p +A0SEZ4eW+cnu4L8hqLRjCYpbNBszXIVJW7LECJaQTJsVuyRdw/G0MD9JR4o64MU2K9RRwiuiJpyF +kR5OhWkLZczkuEiUm4Y9lI20PRcD53ItXh6XUCuXZ3I5qlyS0r5Scks2JqI+5eQhJTZRyi+UNd3s +SmoDIwJRHmr63HLXtNDB8IQR+wRdRVC3WNJxKqG4JsM3dWeOMclmTiyhDkaFZdQoFFUM8yS5a7sr +UR8yYqOEmhjlY5TNCGEBVSg+MrylFR75tSvZWsLpJdwpopZpL4L6qRXtmf6OG5+I2pTk60XMpLka +ycAkOPmikssLKKbhpMWwIc3FuYIAn4UTcaFsFRG7hLlE2s+tSTIJy9dJOsHIiu8fmvYORtUKiJUt +KLmiWkZNRRuIcqdYVoslheObgthNe+iV0o5GCGoJfCMMdxHcwdKOUvVcXt7YZOBfy2W7jMDLpdk2 +zXcIuknQ9UzaC0iHX6JYgGEBwzYoulpGHIJMimUrLUeNuQjqlcpWCTF5viWJ3bTfDuJlC9qDTQZe +mayQy4EhFkX6NDhASS8UJAw1Mhn6wQaezfOFklZCrGLJxokKjkfwbvkCXLlOsdUyameydLGowUVm +MjyCuCRVx4kaTbc4oSuIrXb72A0npbKI4gEv9jR7KiidQkkt5EWk7MAbUlwboyr5kpUvaAxT1fWx +qvQw1DGMEcPXyrgNLoHiHit0ObFH04GmNvIFAV7gnIo256QxyYJ39cA5027eVFAsyjjpKcbYTQ5U +O+29SXDNEuHiZHh49HW1dYSRLoq7kjINksemd0wyrTLmldIu5UYJ0dN29GUd7E0b/7LNMhaUMT9X +UDJZES4bDkgbE3EVhPBxOpHUsRed1luXs51XOOuUcV1QekawF7cfW9ERJfYpvg0rst75YjB7gdBB +vqRJ2qzWfuFXLii+R/JdBA+KJQ2mEcXctAdjQd7IsIWSkfbfLumbGVgdrow6BDg8WyVgwokQwaMy +FqFkBWfitIcnVYM5BA+Ew+DEYtkAR83muLS9ato80yyW1HxeLhX0cskABwNHwlA/8taeu725yWxu +0LmcuJlhH2yQsIhgLEbWaLaHEQ0Eq/LcSBCGubyS9sTAPJKqwJIBICAY4ENH1Wco4d7fJO49QME5 +AVMkaSAKfQiW9N1ycrGYljO//wDNbJIYYlFUnWYaBO5vbNJwGSjqZHN8viCCLxVLzmZWKxStUjnt +MUWLgxRYCiJYkYFJyLAo6hnmjmXvmeaa5Vq+t/3+879Y7D3/9F5eVIZpi8X6CSO20zriEERI2jQj +V5TTwthFmF5X1vuS0iHBw8lwuXyjGP18WdvM8yQZe+GJ5R+SVEiQVj4v3DRH6gPCIERUwiOSbSva +zPHXgtRBEV1R2n6yq9hDSkgovgEzz0k93ZqPJs90a4wRLrilZi5Ve0XxnTIS4FQFwVN/uykuzuTA +IkSHAMRJiJ2YpJqAbCRZxwivUJLThidcBD6PUqFubbeH7/vzd43hJco4FBfJRl8yh4I5IoWO4e7V +20+C+KDbu/KTHUBgDHMVfWz6K0EdYXSDYMGEOoaHAC9pA9WcAFCQzSkYkdy09lVggbI5EcPTSvm5 +kpYtmyVYVryBk23FXONski3wMM+iOs0XjUxOur/BAc4gqFMqA4IZAFNlJP2zVNRzWQ== + + + IbPJZjOwlGqpaMhSh+Ma4FGbm2xmk/tjF/TNDF0o6RiZCNKE4UYMN1CUpSRNiyXwiko57WIUICgs +QRMjG6I8dbxDgknub+KZLINiaTcwkkowzAcogMu+aRJr3b+PgWvl8zyKmARRR3GAULdUciiqJfAt +mg55LoZA2MjKmZwJKI2l7ccjhGwhANq4A2+7sUmmWIf5LNuAAwgSUl5d02e11pXqjD69V+CVpuWl +HQbKaQ+lCqABioe5m0Tw/5D0HlySXGW26B94qMukz4zIiAzvMsOk995nVWV577q62lT7VlvZlveA +DGgkhMQIBjN4KwQSZrDCWwECCYEYZkDCDDNz39x3111vn2KtXLW6qivDnG9/25w4WQdthRFgIjhg +KkhKnNKVen9wlJcK/pAZZtM82bSkTbEYSQ0EwjBpTWsaZjdEJwSlzAgFVijT6Gu+vL/tre44E6X6 +VtTpWYmeZnciUlnSW6rZx1eWL4bZXDo9r5ktl09y+1SKSktyh2GLKCg4hGyYEAR9of11jy/qCyQ5 +voGhFiSywRHGlo3kInxOlMuSVudl8hf0Y8lFzZ4K83krMWvGJ0W9rpstXq8k8+uD4eVS4yjGHz0C +MtHVOhh1zMUDQqrWz+QPoTqq3pfkGsNmQTvk7+4HouAul0cBBkKhJAQozICmElC9ACrLlGimxgk9 +M76JlgnScduekY2B22eMu9Vxtwa1wkFAeiHahooxkQL63e+Lgp18Xh0vgjGXEIKuMdn9bYJkl1vz +eg0g4cBoeH/7sjgv1rwBy+PFlcS8PlBokherGG0IItkBDMQYNCkmFxFaqCM4jePyIUoH/wDY/iDo +yAFDhiGjVGJ0lPO4NbdbGhlhAoGUIDbD4Fum6PfHuUjRtnqxaHPMxeHi3V6ifT4/sF0UlKmYM6dH +eyC30bGI2y2Cu0bH6LExlmXS+eySrHWoSNHjj6IjgpS8v7N6GTWS9QmKLYbCZItpmAFRzAeDCk1b +DFfg5bYeHcYslLJIhx2IY7l+JESnUGuoBtkNQyQ7pOE4aC5N78Uzs3A7Yx4JpAeyFaUGsK3Humq0 +nUrM3H7T44vblykuEWIdToYl65nOXDK9nC2s8XKF3AWOHHTocFGQ+mp0XjXmZG0Kv0aHUyKf06Jd +bzAOsfYF4hhJRevJWl9Qu/H47PzCxUp90xciW5RH7ZlMcTtbPpQp7+hW37Ymrlz7oJnru/xakOzJ +VsJYwR4oSgv2Zt+l6BCXyP72azgyXn4iBPA/WYrJjI5THrJ1mBMkbZt3eQyfPxEMZVS1LauVURe4 +RfUFMoI8pRozqjHFS639HV1g2FAa1eMRyL5PbsHr1xgoC1dCBalQ0uczfT6Ii+DxSBAgYmDcyti4 +5PYY4ElACwoCynKBQFyRAyMBeDC3W/V6Y4GADaJACYAZyOKYm3f5lCDtALSy2ucENEUBw46OZhgg +p4KDg2cgeePj0vi47PNZdCjjxV14dCrkjI+zILGR0QhkC78fCtmjhC3FEMxeEHqkh1kMS4Zmc4Lc +wqBFuAo8GBUCdzF4YyCAdyVdXmnULY26ZNxdrbLr9vLwpfAMZBcUJk0xBUmdSKQ3Eql1w2hJQiKT +moinZyNiGQCDbWaFrK43M+nFTHHDF7AUpSzKJdhF4jr4Oie2FG0qU9hx0vCxKdgSw+yxfCFCSKlg +mJOJ7GK9dejs+bd2Z47SXFJQa3K0Lxt9RIa/71TGClWAHESHvhCkmhYdqMYELzZltQut1IxBr3O8 +NTjlDSZ8wQQTKUlyXVFbeK+kth1nplRc06LtEEN2S47wJfhAK7GYLmwp0Z4VH548fV+qNA/A+0M2 +uE5U23DsYFT4YTBAIJTAvyEZVMgm2xcrTfASkRKmwETKXp/uJeUW8fJ4wOfgiipoM5Umuw2Pu0Xg +JESlA1SGbF0SzrFcleOr4XAhEEjif0fHGbeHhxcNBKLgJVmqC3yZ50qS2AgEE+CoIFQ1aI+7FI+X +7Jvn8ajAmNutoLJhJuP1G1C3sbFwIGC5XOroKBRTCoYgRuhZmOQYhIOGbIWzQBrLFkj+YvKAGSkN +k+W4Ijwzjgn/hmPi+gEtmC43/Dx4yS0T9+4Wx8YEwInIsUv8O1MBPyybhzxpRh9WDfYeGMNhUVA6 +nPR6VHg2HJDslU1ZYxgEJsNweV4EDh23RyA7x4IkmQyphdxL5w4Vant6dILnc4qY7bYPVhqb4Uia +E8u8VFaMhuUMcoVlNdZ2eTRVq8tqDR7Pic/FrIWYuYSe1a05VgDeTIHL50pLvqABN85GirnCTq29 +15o82Zw6LllNQalUm4fN5JyPSu1vh1Iy43PxzHoiuyGpXVySrNbJzqJBJ0CBTAqmMxNPrdRax+3M +ki+Uo+G12CxLbgSUW9WifVXvkkQZzmBgRbkK20+zGSs+1+iejCVmdXsyU1qi2JSb9GAWLg5JBMoL +HYGl5/kaTgThGHdJfCRnO5MIv4AEKgJrp+pTvFAPeNHd+8zjNVBximxtVObEDr7CGDN0FuMwOi6M +u2XIFq4N3/r98GYZl5vsIzTuRsm4QDCGDI5aw6kqUjMZXxDFptePHG3sJ7I84OH1IEyZXp+Gt/j8 +CGvIyI7PT9w+2Q3YA0sc9UETvQacP73vFkCPnFBF0ZEXgARFbeMrDBK+xYlUrQP5gIhDAb0eLRiM +u1zK2FgEPEZMnUsGEwYDZFcZwooexDFoseoCwDwKTkSFUsASTF2YSkpC1eUFoligcWw04if7xhdh +SiG74x4JgxaizfFx6pprvHCwLCx3wOI48GeNtL/WDHNZPxHlhCpVSuX1qDPAYVW9B+8d5lOclNGj +JUGCZllkriA+B8ebSq+ISgfROEhn3H4nRGfhY01zUjGanoDKcEBmUTXaoloT9SYtlCguZyZmm/3T +ZnImCHKQ6owA3PYMe1aNDSVtgLiN3/fDnISTQEKAsiW1o5vzojYVFpoMshJXgZMB2e7v1JoNhBw0 +r9cPM5PTjRmyCWFAA59ArHG/cFw02SS2wPIlIzqRSC35KdsfisH2B8l2vjDY0BQF1gIVFIWKZQ2C +aMMxFt4bx98P3bYX5seNoltIdiAQfGXYkqxOi9IA0Zuh827SxWQ3V/Ty6BgCGu31WaFgHg6ZFD1A +NmNHngVcwUgAxv6YV+hwzuOz4J0AEp6vwpkzdFzmC6FQbGQ0CDQCV6FQOhiETqUh0KFgQka49msH +RvwuspUuGM8Mk4aCLwXMNEXpKGoX1YGGwjMTn7+/qyF+Mj7O4bJxCnILRMvCeIEAA/54MJgE3nBh +MNiQfiKdbolsKOrRYNvQEZDdfHp2afbaURd3zYEgDhWm0hrcsl6kaINcjBuaboyNUweucbnGKNBa +AA3iUWAj4TBRDq9fRtKHqVbkpqa2Fa2BsiI+y1qbEfMev0izFsenZKUIvrKS82q06wvFRK0dZFIu +ssVTCgCznDk7MSsqNU9AR1yi2CT00U+ZVCSFBCeq3XRhNxZflPROiE2azhAwQ63JNtFSM57Zytf3 +FGsYFsj+scAVFUl7Q1G8S7eXVXNZBnL4kp8ClkwnPhu1J5E7SI7zaWhMqBIuHt+iUuhWiCPSpSjX +7fSyZk2zZIt1sgEdkp2iNeVozxuyRt0CfsILZXQfxipCNl4m29czdBqnGCUlCKCIcETBQIyhE+hH +VBytDWb2BXQMKdCCulMUWjIJzIyOccR4g7WCMSjsGPEtMvSFuCa3AmaDqkIBw0zaTzKjQ5SX7CIL +vCGKwmiJwJU/oLldnCQgHNX2lRr3qI2OiT5vDDVFOhsZ8dKUFWEzfrJFWGwcAkpIRuO5qmZMgZOJ +Cnvlv2+9SzYFDTnItqApQOXAiG9snAbwEHjDNKRNRh8hkIK+CNtE0gbCMpPbn/1gDpDttUXcS5hN +ISiRrREpSxAyXp8wNh4cG/OPjwX9Pl3gS7rWpOlo0CdG9TIcJijX7zeI34ukPYABHeX4NIoFfSeD +g3DtVcjkm9KISCV/QFWNKsOn8RMyUQODGiDUkcxuyXoXrsBKTvopAwPu3d9C1gfXyiat+FTUmlD1 +ejw3G5HLDF/k5QYyqQ9IYNLp3GamtE2xUORCurhlppYErYPY5SObc5bsxKKTWwLpwadJsY43ZJJt +Pz1kyzWooWVPg2lxC4pWAwzgVYj79cWCQceMDVPpZU4qBQNGtrCg2HW3X3D5VDduLUS0slo/XO2e +iahNKpyw4pN0BLoDNyLC8aKUkK2EPSvL9XF3xOcTw2FnbDyMTke5AQCyqWk4EaAgqZEQbSFF+gM2 +rDXUyuXSxl2oVx4BzedXveRFpsW8xL0QHI6O8fhlQWjCJCBxBGnLF9RRxJERYni8XsiTwDBxv0+N +MPFEvBOgQHRIDdY+rZUCftvnBXOq4+NMhE1TwRiIC5oVCDhBsodtkmxQSWZ0MT5JnN3lEdxeiey7 +7saFSVAo2CeXG3chBEPRfYvFjoxQ4GFw1H5G0A29fersQ2RybDTkdnOwefghcAspdOPgAatQWCiW +pgEqnyfMMVGOcRA/99ESA1Mx4WSxvIIshjQK3O4znukmOwBHda22P7UietxGMGCHyI7KCV4okqmn +SKbe3uaVwshYxIXsSSyxyYmVbGFTkOu61lraut7l48kcF4UcnWLZjCiVAC1Vbxays/Mbl6Vow7UP +DFA0yxZj5mxn4nKuuktH8oJYjiWnA0zcF7KgXBxsfGwyUzxoZRYT9uDQ4at2duLAGL3Pz2RjcDSj +og5Yvoo4X6xswT+PjyvwDPgW/6vpXcRkspd7ONPuH+XU1MioD1xBdo+PpHip2OrvtabOiHrLUOuD +qSPekDoy6h8dpRg2TXba5Iqx6ACChTZhIgmKtvblifUSSiG5GGgPs/FgSIva4G3z7xPdo2PIeki4 +eQkeLAwj5Gh6PcLnDoxQIyMh5HToyL7opESpyxL/4ARo0+Xh9vlEBOcgbYEh0emwW4ZWdZJdl0/a +nxZD0IDBs4lIuVS/V48waUNrhgAhJiEIJcQ6ECnZsBpCBuGmnGJxmeXS4C50BKBIhTK+/aaDOQei +ONZRFWAM0IqAkN0umC7yRsg6EuVw7ownILvHWSZkIYCAu0ZHycV7vBCXdCI1EzVbrnGKoTSOjYUC +SBbIKSobySpqA3THSzXYJDfE1KOMjyO/aCEUIpKW5BIoHRLs9UQpIISNk8YkaEzb5lS5scWJeZA8 +RWb/0ODWvmFOBsl8aWNh44o3pLFsSpIqkUgOPMZEsjSTpBmnmJvZOnqb4fQ8xI4m0Duy1DRiE6nC +Cq/UvPtqzmsVV0CNCNlkeoaO5EIIwkyGk6qt5tbV259sdDdxXo7Nh8FpgSggGuHaWnRO0SfszFqI +qyCOqTIcGpgW+h7HeeFjRb4StQa+kI4RlohxygdCRpCOgnvDfCYcSdXyC7ff8Y5gODo6GgrTph3v +g2lRo7Fx9I4GqxazOog84ByKNkMhg6IdiAKOjBu3ot2jZ+8LMkjr3P4zKQtfKSoJ+Q== + + + A9XYTm9j64Z6eweaMjoadLtZIAHiMuYSwb2oEScUQQ7wddBTsA28sWucHRtj4OhUqRGLdngpP+6V +oZjgyZExFgoCURa5nMjlVbkai3WYcMKxuv6ADtoZGQn6cOPEJyfRp/HkkBczf6dBj0fYj4ciyYmQ +b8rS1Lyulfc34oZFJMgBwGAI8UKBMICjYxQSja60QI/XvMk9NoqDIwyWQLZIDYiQ4+Osj1gpAafG +v0PBOLhr/yGCEqLhdfWRMQYcBWUMh5M0kjiVQFoZGycAdhHiEumwTdOOJJZTyXk52oXJJxtshswA +eSKmUUwcoOLFkqI3ESEFuUIxqZg1sNIzLI/wnuPFIsNlOCFnWh1OKo77IGc6sdw+newwDIXyydBi +QSxinHH8EJtm+TzI0OXFwdNGbJArbyTLW5ozTfMFbyAK4iVh3Ce7fArLF5BGmUiZl3shphQz52PW +NMyVN6CiXrhCjJvHi7TlEKvsj3n8AAw9OhbE1zCu055JZOYTqX4mNwmTA4cjo5Ruamw8hG8xFKra +48VmREDetGGVQ5Tp8Ymkm5B/pSKA6jgLmcqmizxyktBQ4+MYZHQ343KxPp8iKhXN7PJSlcw+BXWv +h3e7IygEqh8iM2YZr9+ByY9E6lFzmWZzJBL64LhQDgXG3usjc3cRoeGk1pAmiFLvby8/BopwCSG/ +5vdqYSoetwcAg89ngpOpEPRR8fuiyCO+AHkuJkk1/M4IbPYYh/MGAmRj5DFiHTmSdsGT5KlNBMwj +iyWSQciLw8vnNxi2CJCAsqgQ0qiO1kNGHhsXSET1k4uRhDqE3uOSVaE6Msq86U3wXWRvbWJOPJB+ +llAomdAQIcdB3ClbBm2CPMmkhwvQipPdmwMAkgmpJVqjtUWxEoRjoW1ZLTNcyh+yg+F0gMpRTMWO +r2VLR+zsKgJLhMtBRkEjwDAoGiLoC8YDoSRUGycNUwlZKvtChiDmJKkkyk07uRy1Z2kuiwgPr84i +QbMpikmq5oqV2dWceQppMZSgmHyYzDMkvUE5AHPIlbKFQ2p0kgoXfEEHrR1mM+AWtD/uKxSCi2tG +yDbvWQ+ZIJJIBvcqYFpOLtBcIsynaQaJLEN8dYA0I0XbNBv3B4FPG8kCiZVmC1Bh8lQxnIJYw2ri +jvajfYmXWnQ4z4RzZK/7UcrnxTBGRkf9UE9f0IKfDNJphvguA5SCgkIgXOMckSHkxAAOWGAiwF7a +F0wzbEXgq8GQQeCxP1mKGoXCmTDODufJ5DS174PhGY9QQZOCaXSLPg8kqRqiMqFQwu+H2wRgYJiT +wC3NwMBXDL2vKU1QhN8b9bjJbslvepMLJspFPA83MopGI1OpHhJ+44gbfpI1pAOjDFjU7dbdblx2 +1LZ6KBBQHQ7aoQB5kAoyxI3gXZA2hiomYgsIm6OjMGwCovE1B0IgcJ/PIBN0UFuERz+4NCsINVAK +pN/tUvFGls15yVQG5yE843CRimEMMMK4AIHPJ1NDinXIxDud4aWeYS6lsjtKdAJBDKPhxKfF/S2L +UW6ezytKQ1F7HF+GWLjcssAWUolZbxAULUGLdXOq1NizU8vAjy9gabEhL7dJP/qjZnJDdxZprohi +hdm8bk7HEkuiBCecUow6E8krejdIx8n+wBSSfk6QahSNgeLh92BsvP6EN5D0+G2PD4qW4Xn4nxJw +gqaguSQnwlm1gsh3QdPl4r1uVSJMGB9zhSGCktYQ1JovCL4iE4aqPmHEpv2EObUgeRoI2c0h3VNU +2u0x4JNpdJBfGR0LIX+RvdNxp1ANDJ3fClMQhaTHY4wcoND+sN9wI+Nk1gsaZAlSNxZb0o1pMlMk +VMMMLoAhKc+ngtUZYqjyqtYN+DUqqAuRzPgYPYrsNibwbBNvgWKS3of79cdgNoIhB94J2hTwxxk6 +h690MINGu+YaD9TNNU6eTh44EHrTmwLjJHWCOkyQiQvcEkpCrw+MsDSdC4UwelmKypvmQBThaZOG +0goF7b9bR49LAuqoYAKZJUylRkdZD0maEdCX16MZ0RmM0v70hYxGBszc5EEDdFn3kDLFg0E41cQY +LnJchBKhyh4PeRgBM+aF3xMaWmyCLD7xqSxXZLlSMJxAJBl1RcCH6B0rPoTM+cjCkniQgoYCnNAF +lWHSAl9R5JaswdWzIdpAlXmlxErkUZEIA693Jb0XJJNF8DYgEA2HdXlECCIMbURqhoV6IJiZqB2e +nDnugfB5NSAZEqaQtUDQU8tF7kjNpKY95EFejGYqotxiyIPUIhupBqgkxn9t9brl9cvIaLBVYy4k +cYMNJzg2m4gNmLATJEE+C70ecdFjbiHCl43YpJ1YUvUBXBYvZHgxN+aKjBAJiBPeoJLkFbTIUpyQ +zXH4X4E85Q9EkfFh+QSuRlN5r9dCz1JB2+PmEc0QynBV+6sCyOzWmBt5MJ5JLMpS2uMBf8Y8PlyY +6HJDavHLEh0ypUhKk0qQJw8MPzIRIOqG1MLzsMQD0xjAOogFkTPotyJ0gQO18jWWLvq82oED/gME +2DyQgH+4xxWEApioAOI8xjAYF8Q2ZMXjjeKrFzToNkZdiJn6/gOIkqEPIFvIm7gjvMg6HJDVCE2u +BBYO906uB+C30XrjRHB1huzrDilRMRrIjxEOloPM+YNbcFiEZdy7j9QIQsy64PC9+v6UBdrNGB8X +IHYBsp88EEuTaWdgwI93xUBuFBIom+fEGnyOy8VQFC4AIp4I4XT7D+LhOR1nKKilERcLFZCUuiRX +gROv30I7+/y2nxA1R4cMLpLABXv8MTCMILVVvZ8r7cQyczBdwI+kNOEcyDwM2nmcxQXQ4RTD5j3e +GEVnQ1RqHIBHdTxKIGDTTMqKTzd7h8uNDSQCmiLTPhB9IIoKObCvkXCSZ9KyVMKAgHbIlCysmpcA +W1HrqlIVpBIwvG+D5f3p/TiQD1GAlcIQATBgKnhCQ28iT2EwA7gdMpFujpGt1FGXmN8f3RcLGeN8 +4JrggWsCrnE+4LchHDzkPhjze1VRQCEiJAJAXr0YLg3O2edRUdZ9WZfGxqgD13iBUvzQ7zVYKiWK +5X1LpgpcDtYR6oxsi3CKUwBOo6MRnII8NSAiiPN6Rg/g4FwkbLO0Ewwm/MGML4h7bI26hBFotxdZ +PgHw83xZN7qK3gmEyBMNMsk8xlxzjRtSG/QbAZ82NgZ449YQCTEO1P7saIoKJ4LBGKHEAIxBio1k +yPooiuQ+YAyZN0jmcm0yA0YaEOJruFwyOh3XD6BSdCLEJNx+HQMIvOEtKBb+DVcZM/uJ9FzMHgbJ +9KMB24b46Q/KQQr5KA78y/CoFgx/wRPA2+Vkap4XyXQQWccCCiVPgVEyE5FQ0yBb6f35eVgXGLwy +zWTJ/GckR1bc+aI0kwFTob6gRzh5AiRCGlE0rCDWoVyoI9wOCopGQHhkhaJhT2jRLh0ucnwd74UD +GQf4QTiRfDBoAx4YEzCJL5iCJUYdQ0EMlCOKRfIUm85xXC3C5P3kKQAunofc7D9rFhF/4Fq9ARMj +mUkP6+3tA2A2L3xvan+tlACdGnfB+Rv7T5dMFGV8DO3P4St5ojcaGRlh3dAyXxQ4gcaBHILwul4J +Xg6NDAlD+fxkARigBRmCdYmMjvhHRwBODll+nNxpLBVfiHDONdeMH7jG7XMTLOHCQAtQTPf+80R4 +J/wXQgf+gYPgLDRZcNISpAasGmj8wBiPjEziz352gNjhav1ByHomTOfgVcB+DJUM+vWRA4jAEWIR +gSK/BePEi2QVSkQowOpQ4WQ4Utx/Ukwe3olqVTW7crTtJlEUltUmTjKSw4uUyQPcWhTeRYJYzBeK +ESdPE58jkSWUBTqcFISirlf1aF1Wm+FIiRPKHJmJqoVZ27Q7ljOFgBwOp1Aml09z+VT48073hKQU +kdCpsD3uVUbIrRleuAXyQL9KVnLypTBZtmGNjMuj43KIJk4J2QrsDSUNRwqi0ghzmZExCtnZ5RbB +mZBpJlKCWw4zZYDZ60OCEKDg4Ui+Uj9Wre9Jcp+NkGeIaByyBMVLHp3sL/WU9tfapalwHkEJgR3U +h87yEvaIBYJpUWgpMuQjAeCRaYf9xTZkBns04honqz1xa5reVKJt1Gh/JjNKcvoY50cw9Kd8fiQU +stTES2ZBo+Pj8sgIAxXb98OAluyB8wmSKdAwnZD4YsAvuV2gNQd6igQHrQkEyYJSlk17XJFr3gQI +ecfHWDAw8A/vx7JV5C8SKMZCXJgsb4B4uV3S/sph00eeg+MeWdzy/sMpDl4lQEJoIkilyE35yfIP +D5nnF970Jt+BNwXIVREJS9DhLENWr2XwDw6QCNuA5RhpH+3v0AqGMrLWsVOzUXvCsDpWaoqTkOLr +otaR9Y6ZmHEyy8nCBhUph8jCEgRABOEKikuevdLo+jzNgM2ihI7YFPApa8jpZdQa9ZU1CFZHkAq6 +0YiaA15qCFI9Qh6al1St3WweLZY2NaOFIE9mn0JIZFl4IZhkpCFeKCG2e0MwHjJ6H8ihmKyoNmWj +J+ldhDW48f1nvvr+StcKwxV8cMhMzrCmk7lVViKz3JBO7z7vjbkVxElZH0jaFBR2lExagtksxWjJ +ehNX6/IgiMVDNFm/KqkNqCrSJZgc6AIJB8nyHgSQPu49xGQANrgdWS5xfCXMFAFapLwADZAgBSQ8 +ZLKacAIRRAg3nWC5AoULDsT9lOMNkAUM8JkhJGU/WjXj8TthrqRoHbhWr88ic4w+bX/tAQ/XBFuL +4EnTaS5S4CN54ArX4yPP0InukEdLYdQ3iyTuJrEXmgsagV3hfT6kMwusyDKgF+h72tBrHq8A4hXE +vBWfQiOAPwFLTqzA7gZIOEqpaomsbfYZKDQqyPK1MFcOkAW0iTHCeAAPeewIQSE0Qjkgiqg9bcen +ncQQ5UaCDvgJXMmj2GAcdRQUjHC7UF+1MkOkITMxJeptDpAwu6n8cql9NJ5fFdUWechLW05qKCgN +8EOEzAzkUR0t1hbUStTpc0JBNVp2ZkbSyfI8SWtbqdlceT1dWIjGpyJSDRIWMyct2Cqpyou1/d9p +qNFmobou6fUgk8SN8EpXNqZUcyjq/TBqxxcUvRXPzoKI7NSik13nlRYVyfFykwNQxQoIYf+5ZCoY +jjN8Bi/FaBjWwErOx5wZUWnxfJWNlCCdfjJlUaDJwsUofHUQ3pJFZaHLcBdx8hiFzeGAePES3kLW +xgco8IwuiAUAmGJSgtxADuXFiuVMRhHG1TonlHi5GmIzbugaEMjmDHtKM/thLkdqFDDJM9BIlsVh +JUhAL+pMcnI1IpZwnayQhougI2nFaOpmH62Hy2D4Ak4EeQWAA4EoFYqFacQoU+BLglARMGgchh0k +XMAdAa4+ONKAibfgW/xvLNqHWIDqPX6TLLDx21BwpBVJqph2N5mftlL9WLzVmNgxE9Nk/U8oxYl1 +XmqzfEVSKnG7HXf6rFAIhBOorJ8sA1NxfNwOETUafkkJhvSoVacZWxDTslqBhUaOQw== + + + YNf0abJwTsXoZeFJoH1UOM2RAnXi+Vk51oklp+PZOdVsaya4q2g4rWJzvdje1u0eMBA1692pY2qs +w8Afak20vJkYGs5AjjaVGMl6hdJyo39IUCohUJDaslMzwFWqsJAsrAhaT1D6kNoIn2A4VDkJfrCT +U2ZyUrf7QIufTiixnqBWeaUi6W3VnDLTy3ZmOZFbjcZndKPZnTxlZxZ9VJyTak562cng5/NRZ5qT +SmEuDahEyNp4G2orSvlcabnc3M4Ul3Kllag1CVbxBR1Ja/FSJUhWMDr7SyNiiG8w2/sPfzXy4Q4m +xfEFSW44iXk11hW1qhptWMlJUStTbFzSG7hlvHR7EgOVLa0lcwtmeiqilMcQ3umkKFcVo6PbU/hK +blBv2snp9sSxTHVVsfuJ/GKysJwgS7gnstXVRG4IdElqPl+Zq7Q2ErmZ/Sf7f19sX+DkkhFtMRGo +oQrh2/9EQEWLDaAmRFCS0wSlYokVwecYTLyxELUm6u3damdXUJugGlYoIaGTR/ZUjI2ko3a30Noo +d3d6cydXj9xcbO/yakPU4YWqbh+MUFVUmpY92Wjt5qubuEFZb/n3JwTC4TgvFeGOeLKCt5bMzuYq +K4ncbMxqkg/ssEBClxOqFFmiVo7Fp5zsjBKDvnTIR3L4PCcVNburWhOGM3Qyc8XmVq2/E403Daee +yA+d3LSdm06WFqKJfqo4r8cHcqwlGXUwiaCUJL2qmR28K1/amF26NLt6IVdZNpNTUrSDWpjxvpWc +yFU3E8WD1e4ZjAnLIX2APRKcmI85PcixnV0UjZ6gd/L1Q2Z80rDasgFg1630ohGf1ayhGpvM5uZm +li/EkkNP0EThUrlVO72oxgZqrA+Q45cFtRZ1pijW8Yc0oNeMt+10L10k95IsLMExRqSSbvUCtBMm +lEskGwwAjIG1RKUWIJ+IybJcjgrjJ046v1pq7uQbm7nqGl4YLtwmOogVi4JeM+ITRnyyWN/OltdQ +LMPp+YJRhk2KIsgkI6ltKz6LDs2WVxv9vZVDt5W7hzC8qeKKnZ5H6XuLZ3tLZ4vtTTM5kcpODBeP +Ta+cbk3tAipgQs3qy7E2TmElBopeK5eXQKGAlm728FIMIiXtqePV7m48M9Pqb6UKw2DYYfhczJnI +lVeL7Z0S0KU3Q0zaSU2yYsbjEzgxE8+AsiaKja2plUsrR2/LNw+W6qtbR26w4sNAKG84C7HEvJmY +K5Q3e7PnE/k1YNXlkWja4SIpw2xmyktObiFdWuvNnav2jqKO6fx0b7Atqo0QBW8Gj12U1b6TWck3 +jjQGZ2Lx6XJtHQ2CQMdLZTuzlKse6kyd29q77/TFf1jfvrJ55EqiMBNL9EvtzVJnO1GYK7U2Z1cv +rx69PVla5JUSJ+ckteikp0BQjYljnenj6eLi9t4dvfnjfLTGq2U72U/lp0udg/HSZrq+E83ORVPD +Uvsgw8f9IUVSS5nicmPqTGPmXG14ujZ1OlNan146m6vMmMlWrr7uZBfBVPHcUrm51Zs/hTcaFrA6 +GQhbrJiVUGWrZyWmErmFSudoc+KUqFVkvWzF2wxvS1o2ardy1fXa4Eitf6Q3PDm7dBEWTrf6mjkA +3+L2k7mlXHmt0dtrT53JVw+BaaGV4Uhai7ZT+cV8Y8PJzsWSU1ZmJltZ0eN9TqtpzoSRmLQyc4X6 +Nka4N3dGNztsJC4IGYZGEDB5sZ5ILU4unevM7jUn9/qLFyrt7UPHb8LIQD01s1ufPLK0e+PWyVt3 +Tt22vHE+mZ0wnU65uSmqddloC1orlpwZLl/XnTlV6+3OrV5G44fCjhytgUXjuYV678hw5fzkyrW9 +mb3jF+6ZWjxhpQYRMaeQT7UsZaob7bnT5c7hbGm1N3uGEXMMG0tnB5pR8fklRS/Xe7srx25fOXJ1 +7/w9D//jZ5zUjBlfnNm4tdQ6wsstUe3GknOS3guTZUs2mCpEm5DCVH4yU14oNMAPRxL5pYhUrrc2 +3vexr6TLyx6/mkhNzixeSGRQLxDjqXR5C8R7+NitvFb1BWMGnFVhuTk42Z48O7l0qT3cO3XunvO3 +/IPu9AuV9fmN61YO3bi8c93k0pmlw1c3Tt69sHzx0ac+XZ8A/ZZyxZnG4Fh35sxg/uzsxuXlI7cO +5o9vHDx/5MLdENbppePrx67WJk7Y+aWplYubpx5ozV+OZwaFxnQs1YqIGc0aOLnFbGM7W99oTu21 +Z04ki9ODhUPl/paVmoxnZ+RYPZGbThfn04X5ubWrlfYRXs1pdj1XWdQsOKsO4eHMfCK3lK8d7Eyd +6c6cTuUH6fxkLN5LFubL7e1iY7M52J2YPbZ37s6NwzeCLXWzVe0dmpg7Nb9xaTB7qjVxvNw5GnOG +i4sXlrevZ7ikrJcAic706cbgaKm9s7h14/rOLVfvemJq4XRYKADzycIaYJ8tbzi5zXR5rz93XTTW +jUQyolKV9WqpsRLPzxQaa8nCXK6y1J48GotPQsWS+cWo3S7WltuTh8vNDTvRkdUi1HBy4bydmi7W +13C1utUtNdYbE7uZ6oqgd+P5ud7MkWpn3bDqtf7BRHay3FiaWjpd6+1kSvOd4e59D/8TDhW1O/Pr +F9eO3ja5eqk+caRQW9PNSRjaTu/o8bNvqbbWWd50ku3e1KHF7YvLu5dnNq5bPXqnlZxJpJfVaNvj +k2APUqWtua3bpldvLLWPlXp7RWIqFlrdjd7kFs1aoXAcTjuamnWIuC/lK+uEXe3GYHi4WFtBPDdT +C9nGoWR5o9I7lKsuB8JmIGTAfYly2nR6yexisbFdnzjamTnXnD6L3JfKzOeqS5nyZL2/Vuls5hur +mdLM0vzR933kC92ZIwyfzBRmljbvWNq8c2Hz6vLu1VxjfTCx8/ij73nsnz8HlzK3fmHt2J2zmzf1 +Fi4s7lxdOnRLIrd44/Vvedu7PpKpTXsCumFNZopr9cHR+a3Lh8/eO1g4tbJ6+t3v+0RreBgY6E/v +NQa7gNzOibuu3PrEyeueylcOLc7vrW9dAjxiTjeeBagWy61Dw9UrO2ffeuL6d0wsXjx85Lr1rTOq +WU/mZ9KlJSs1dNLTpcbaoTMP7F54CLqQzs0BeLJewREMu4f4yQi1MF8tVLanls4JckoxivHMJEoM +a2FnYEGnp2ZOPPDQexfWzop6dXL5xs7shVrvyNKhm9vzl+38tp1dkdVaLr8qKOWIkM4VZsvN9fUj +Nx48efvMxiUN7kVrDocn7n3r+3WzWqzODRfPDpcumekZXFupsVVqbsOU5kqLmeJciDF5KQ1yxk0V +6gfXdm64ctvjIPMjh687snd91GoUKnP1/sHmxLGFzSvnb3rw3kfeDQ7Z3bn2rY++e2H7IjIRJ5cR +FpCXa51zg8WbJhavS2Vnjxy5cPnK7YViX0Chk5NmeilR3CjUDq4duS9b2WL5bDI3Az1FC1gJKP5E +urJhp4bV1sYdb35q79wtYS4B0yXI9cbkqUr/mJNdEORmzBxcunT/Wx9+byo91GNtIKrYPVztn1jY +vkU2GuFIQpBy4Uicjdh2fJAuoMWOoUzN6fPZ2iFRLM/NnklkOjSn6Vap0trsDfem5o9NzOwsrp0y +nIYvpNqJVru/1xqcrLYPQ8WszERnsH3p+rccOnsbJ2WbE7v1yWOF1vbkyuXq5F6yuIwqX7l83633 +PZbI991+3YyDkZbiuRmAdmr5HAZtY/Pazz3/jdmVM5bT3t698cwNj64ev2vrxJ2nLj+4cuQu0xne +cOneW25/XFQr8fQMTtoaHKt1dttTx2bWL/cXzpqpyQsX7zp4+JISrdZ6B5vDvWxlPV/d6A5PHjrz +5pnNq+nCyurGFTlaH/eI4Hwzjlg3IRl9ZI2oM1trb1VrM/2JLUHJWRD04iI0MRqfyJfXhsvn4/lp +2ahOrlyx0lNKFC5iQop13FTSx2Q1c7JUP0yxCfjJQmk+kZkcLp2c37xQaG1JMJNSvdM5dOcDTzuZ +Tq2zurxz/cTCuVR5NRbvmomeoNVEo4m7yBaXImIyFm/EM1NJdE12NpUf1tubME7ra6c3t8/D+Qxm +ji1uX57buDy3fn5h48xw7nAmM/no29/11W//6PCpW4LhhCCXVaMN2FQ6J8sdjPmKJJfuuvNtH/zI +s632Iixcb/ZatEZv/tLs5u2LO3fBBMoqvNeVRn/HTz5TbCvRVnPyRKW9M7N8/v7HPnLo9G3Z4nR7 +sE0zccloRpND2WhBbpq9I8fP3L177GrMbPWnDtZ665JR4aSKavRTuaVa91i9czjCZzKpiVxhjpfz +GLpEgaSzaHxW1ZuZ7DTLOwFK1qL5Yn1hdvn07uk765OHkS+8AcMXVHk5KSqpeHpQqm9Xe3v9hZMr +OzcevfBAGoIVrbUnDlqpdizZOnr+ofWjt7em9pr93d70HvgkzCPUO3ZmVlCLopLP11YBg6mlM3Mb +106vnrRzA0FOZAoT5dZqY+pIf+Fca+aUmZ4X5GKhOMyX5pAFTKefzs4aepXjksnkxGD+VHvmeKo0 +1505UevvqrFqoboIMOh223D6RrwvqPkQ47CR1MUL95JP97h4js+j3YjP0eE0GpxUFpRivjTdndyB +BLR6B7eO3zO5eEO6uLOwcmNv4ZyVHXYndm+85ynVavz9kx28VNPNqXRlt7t4S6667adMSS00u9vI +ULXuznD1wvzmTbt79+4cuaM1OF5uHrTtxrkLd0/NHQkxFqeWebmkRMG968niOgghVVxSjcLJUzc1 +mysCcqI1KDc208U1KFeqsNoYHM/nZ1c3L1U7m4AuKFfRKyBJx+l1+9sT04fUaIUTcoKUB7wTmdlU +cdVMzlRaBwuVlVJ5uZCfMYzq7MLp1vC4lZ0znIn9aaUsy5ei1tTazi1OZoqOpKCPVmp6cv7aiYWz +E/NnhgvnYs5kvbFy3c0PqWrOsAe1ieNoiv78tdtn7187fGMVRlEuX73jkdXNUyESSPOp3IYWq/NK +JsRayFaWMzBiLThSzWzGUrPl9qHm1Ak0LFmoyWeNaD2bG/iDMs2Y5PPU5oSZnJfUgRaFpZnwBzVe +sJOZdqY8lS7NlDvbiEVWerrc2Ejn52yn0e+ub+/dVGitalZLM9ux+CCRnrdTC5nyVrW/p8TqkONG +e6s3c7w7s9edO6UlBqyc24frMis6lcr06UsPHr/0SGfmrJWciggYjSyyOfnUD+W43XwoqGl6BdKc +Ls3FCzOZ6hKn5sEqc6sXUU01Wi/W1iYWLoAV2xM78XRXMfKhsOnzayHK9Pp5X0BJZ2cm5053hqcH +i9en65vIwgzv2Ileq3c0lVsWlBZMuxKr8UpuMH14Yv44zcdxAZnskigXOSGtWl3JmgAHkvmKxMBJ +TtJsvD3YW9u9vdzYaXY2pxdO5iprKFw60T1//u5iecJPG9naRn1wcrhy49Lmran8qhzt8UrZdtoX +z99Trc5HuEy9vbW6ff3EzMly42C5sasY7WJxYX7xHC/kcvm5nb17Z1dvzJfW44npRA== + + + akaNdnCntfZG1KqiUrJSyJWX0oWF6YWzq4du1mPdYEBLWJWH3/Z0KjURZlOyXo/ZvZg9KFS2ZpYv +rx28GY69Xptb271etzvhiMVGTEFMM0yKppNcJM9zZG5z6+D15dY2xSJT22EuRbOpUDirGoOoM+3x +6QdGaGRtJzHvckfI2rawCecZdfpatGka9aOHby60l2nBjsgZTsoD1U5qzklOy0rO5xUlsZDIzsdS +M/kqGmeNE2uQYIq2ZTkfNSuqlilX5+O5aTM9zFTXe7MnM/mZYmH6xPGb13YuKNGcqGTL9eW55WsX +16/USdxYjCUmObmA8aw3NyDoegx6cXx994651UvHTt+/e/KeqFPrNGdPn7+z3luH3FDk0SGZWMsV +10pVZPZaiE6oWo3lE6GQqkfL7eGxld2rM8vnEK+On3t4aePGcnnh8O4Ns8vnDbutRGsYEByH4TNx +Z05TmyHyQNNQtLyd7MBRJ0qrEaUh6k0EdrSAbrUjYlo1av2p08Uq4WE9RlxEIKhHuKRptn2eiMtF +EZbIzTe6hzuTx4qw33KRl/L9qeOzyxfRCKJagA2odY8W65vkz6foxXAEY17MVRZ0qynrtX3z38oU +V7uTe/PLl/VoO8w4gpDNZIfoZfS7HmvBqyAsJ7JLmtZimZSslmJOX9QaotaKZ+Yn58+t7dy6vH1L +s38UWuALyHTYoMIay8VlrZosLFSamxgHx24lkl2PV8EP0T5g9ajVkeSKrFQ1rcHS1uLMznU3PcQK +zthYMBSQJD4Vh03KTEciab9PjRmV5//lu5sbJ7xejovYmQKOsJktbFUbR6rNXfLHIrxSLjcLH+Xx +ihhYBkYLfRetRJ1mMtXdPXypPrVCC1HJyKaKU/H8RDSBilRxg2zYLuTnk9lpaBkvZzHmNOvwYlZS +yjG7q5NBKxw/ebU1sRXPTShWQ9ALopKxE4064l6yw3FW3G50Jw62extOqssKCW9QA/0i3JUah3Kl +JXSKlZyo948tbl6CUWn01uPZHitas3Obpy/fYSZq4x5B1rrRxFw8vWA5PYxPiEnCslZbu9F4laZl +y650p4/Mrp3fPHLTwublibm9dH6qUJi4cuWOc1fu9QRUQa5E7SnTmc4Wlg29xbJJBkUU06KUQRWA +7WhqqDszseR8rXuyNXFWUCsBSosnG4XyvGGWcb/wpZpe17S6ptTYcMLrYoK+CM85ql6Op6aQ1OAu +aCYRs3rx1LQZ7wXpaKW1Wu4eTFeWlVgFoYmNJBLJXn9qD/HQ65N8PlnVG2jeYmW10z+aKyztfwRG +FqV8vbXl8QpatJzOT3en92KpoaTXqLAVoqLQQU7KMHw6nluYWro8v37d9OK11daOrLUpJoORwfVQ +tMqwMUUrZctLq0duHS5dzhbXtFgTB4+IKdWsambFMBvxxLBUWatUN004KCUfjVbcXt7tYqmAxNK6 +LGZDQYMsJvSrttm8dP6Oan7gcUUUKR/PzGjRlmG0FaUsiHmfT2OZZK26rqp1LVoPhOQwi57NZksk +8g/XdhvD5frU4uTS5vaJaw+fv7ywe9IpdTSnmi3OJhIT2eysopb8IYVho7KctOxqKtvPFCfsdNPJ +tqqd2ZvveHjz+KVqf142C6pdyVUGg4XtbHeB5mL4/WZjPpvv+wO8poN54HzMevtgd/ZcsrzGawXT +KVZ788nyIFnuqvESoyQUK5eq1odbW/W5NdHKiXqWTI/rJYqJudyhEK0B2KX62uT86Wi8KMkxw8om +Cl0lljGT5Xi+rccr2fJgYW1n/dipVK0fUZLxzDCVW9j/nII5Pk67xsM0Fa3WV4sVmBy0TwKNXO4c +TBSWkJIEvcJKWUHL5Gv9WLJE8UZYtDS72hkelZSq36+5x8NcOKbLWU0p8HySDptBOsbySSveS5aW +RKMO4RCk1Mlrb945eSVd6XspPsjGnMxMurAoKiWXi3W7Iz6/zPEpQcz5A+QvIQRDlhGDpM4Wquvp +3IJpt06dv3ro+IX6YFEycj5KhkNw8gM90aR5U41m6/1N3WqpsSYgDY0WlebU7KWl9ZuTmaE/KAFa +mlHKV+bNRCPqtE2na8c7TrrTHm63Zw5mSoNSba5c36i1dvLFZZ9HPnCNb3SUVtRyJj1Fh9Sx0YBr +nAkFTMvsdnu79cZBVWt6vYrHzfNCwrDro67wmDvs8nCq0a02j5fKBzWlEQqa8WTPssut1vDgzom9 +4xeuv3rXQ4+944n3vvfDz3zia9/6xiuv/OYv//Gfr/3bGy98/yf3vvWJ4eIers27vwZMFvMNeN3G +9ERvaTi7tbS8dfjYqSs3XH34sXfc//bHb3vo4Yu333nzPQ/c+7Z3vPktj33+2S9+5gtfOHLi2r0T +VzqDFTgBQUo7qU4i09dihUSi0uvPrW3sHD56/OL1V+54831ve+c73vWhD9728NtvvOfBBx596gOf ++NjzX/3yV779vS9+/Vvv/uAnDp24aCWqvBinw5okOLlMr1SesOPZUrW9sLy1c+zc+u6J6eW1lYOH +N46ePnnh+qee/qefvPjTX//2N8997Wu33fvWxZWj5cqQpmN00GLouCRky6X5Xu+gLGcDASUWLc4t +HZ5aONgcrFQ6883JlRPnb73jgbc99Ng7P/Pccw8+/uS9j7zjgcefSub7sFKgOyqox/SaGevYzoRp +tSQ5kyv2K43JTn96anZj4+CZC9ff9cQ/vvepp5/++re/84uXX/ni179x9e4HNrbP9vprUbPOsMkw +Y4OCNL0EN4sDhkIxQcgVy0uDmSPl5ly5OX3pptvf/eEPP/mB99//tkcefse77nvr2+9680OPvPMf +v/jNb7//ox9984MPX7x6j2HVw+EYTemqmo0nB/nCom11y5W5VKpdKg2nhlvHz1y3ur528coNN9x6 +5x333v/M5z7/+z/+6d9e/9MfX3/j5Vdfffp9H+p0Fl1uwe1W0HS53EqjsRvwx/w+KcLEzFhNUWts +JB2JxBU1p+mFWm14+vSVq3fef+nmu+576NEn3/Peay/esrB+YXLuhGk1yFrWN9FRNTM3uXL00Mnr +Llx31223vvtd73j+uWd/8dIvf/O73/7slz9/+eWX/+tvf/vt7//1i//ylff+84f2zt7QHR5jItkI +k8ojldvlSq42iwhx6vKNN9xyx113P/nkk1/48le+9PVvfvxzz77vox/+yje+8eKvfv3s81/69jdf ++Nvf/vbcV1549z9/8uJN95Rr863O+uzS0dZgJZlpNOq97c2NW26+/Ogjb/7AB9798U995Ovf/vor +r7327Rd/8sUXXvjOj3/6xht/+j//9//+6T9wJb//9o9+9MiTT88sH80WhiBMWbIKmepEb+bw4SN4 +nTx1+q57733P+9/76Wc/+cFPfey9H//Yp5979ocv/viXv/rFH/79d//zv//nld++9r5//vDV2+5v +thYto61J9Vx2odnZ5fgMz1qZeBXEffrU2fvuf+Cxdz752NPvefRdTz/35a/94Kcv/uhnL/7pr3/6 +83/8569+/dvf/u53z33xq6fO3lZvrkejnVRy1oi2sqX5TH5yerixs3P82vOXH37bQ+98+h8/8NGP +P/P88z/82c9/8etXXnz55V/95tU3/vz6//p//wfd+oOf/PIzn/1Ko7MaCOnQRIqKBskKybislOKJ +TrMxu3f87EOPvv2hJx794Kc++qOXfv6zl3/11e9+6/mvffmV11599Xe/+elLL/7xjT/+f//nf//2 +td98/JlP33zr3dX6tKbBbwvBoBSJWDGj2Ousri4fOX/u+je/5ZHH3vnOz3/puR//4uff+uH3vvKt +b/zuj3/463/916uvvfrKqy/97b//9tNf/eJtjz8xu3C41duJp4YURRY/ez2ioeRiej6X6fb7a/Ak +c/PrZy5ceegfHv3kpz/54ku/+M3vf//lb3795y//6n/9z/+88de/fvLZzz7+5BP33v9gJjNlGD1d +SixNrx7bOX7D+Uv33H7Tg2++/V1PPPi1L3/23//tt0D0K6/+8uc///5nP/fhu+++evjw4XprKluc +4fksy9ianIqpiYyTnmh2z5449ZYH3vL2R9/22OOPfviD7/vBD7//vR98/wtffv6FF77xxp///ONf +/OyZZz/z2c9/9vZ73nLw8IXh7I7j1Iu5QaszX29MVirdzdVDe4ePntnbfeudN//LFz77la88981v +feWVV3/1x7/89cVfvfziL3/x2mu//o///Mtr//7a177z1Ycff+vBIyfy5UnLqZt22TGz/fbk5vqh +K5dvvHjh4oWzZ95y313PPfeZl176ycu/+fX3X3zxa9/66i9e/sm//v7VV3/z0m9/g2b52eeee/au +ex4YDDckMSMJmVRyUCyvKHLRUDP5ZG2yPXHq2O5T//DIl7/w+Re+861Pf/4zP37xR6//6Y2//uff +XnrlJ6//8Xc/e+nHzzzz4U8/8/Fzl29OZnuwQyArJ9HNFqbyhcHS4ubG6ubF8xfe/fQ7P/bxD33q +mU989vOf/vFPf/gf//1f//r6H1/85Yvf+e6X33j997/9/WvPfekLTz35ruHMoQiXQnAL+lU6FIuw +iVi0NuhtdFqzZ06efuofn/zIpz7yic8986Of/eT1v7zx+l//8sOf/ejlV196/Y1//7c//O7Fn//g +179+8acvfvfpd7/zzrvvqdamYmaBDkuAViLZzKRbxVxvd/vY2x95+xe/9KUfvfjjb3/vm6/966uv +//n1V1/7zS9//fJf/vonHOd73//aD3/8wk9/9v2nn37XlZvvPnzm1pjTdrvFMGWHKUOIRKmAoAj2 +/Oz6Ddff+La3P/KZz3/2s8+jmp/64Y++85///Z+/+8Pvf4S2++kPUaiPf/pDt912y7Ejp7O5Ybd3 +NG2Vhr3Zie5kp9ZYXpnf2d1eX1s4cWz9gfuuPPbYnffde+XWm893O5VUwlRlLRJR+Ugs6JeCfpEK +ijJnFpxSt9Sd7c8szs6cOn705InDBzfnr79y9OEHr3/87bfffdct99x3z3VXb1paW8/mqpbdyBbg +vTsMrUfCusRHFUGHcbl49sbjx880ypXpZvXs0Y3bb772kYfueOqpB7751c/9HHTz8s9e/e3PP/rJ +9950y6Xl9ZV0ppRMNRVEV87ieduKZs+fuf7GG++aHC73elNrc7N7Wys3XTr+0Q/8w7de+MLLr7z0 +2r++8q3vfOFLz3/88595/4f+6aF3PnLbtSePT0+vpHM9mjYkKc1EHK8fuUYIBOQwpcT1eKdUOLO7 +/fj9t3/hmY8+/6XPPPfse3/yw3/5059+/6lPvueeq2fPH9+amxp2OgNRNEJBQVXSePFCHC9Fjuty +rJAuT3Wnj24cvOu6c0+/88GP/PMT//L8R1966Qf/9off/Pkvf/jZT778ofc9eucdFyYHbYHXeS4h +S/lgAJaGLFH2ujkp4hSSrVKytra4cmh78/Ll87ffetN9d9360P13PPvJ933zG89/7g== + + + mY98+qPv+dgHnvj8pz/4xFvvvu70yUa1r6iJMKuzbEwUkpqer9XmU8m6xBmlTOXUkRNvuf/NH/3g ++//pXe94yz13v+9d7/z+d1944ZvPv+PBm9//6H3ve+LBW268cPLIzsJwvl6fnVk4lclOezyCz6sI +fI4Jx6iAyDNao9g5ffjoW+6+7XPPfvy55z/zvn964uknH/70R9/7/e9+72Mf/OBb77pz79Dhfndg +qHGBd+iwHQqoIX+EDSs8q8lCNJlsVCrDmen1jc0jatSKcPCWepjRaVrjIpYkpUIhZWzUF/ByPGNL +QoJjYgrvqOQV01WrkG1kUhWOESIMx7Girpqa5kSdOh2J+wIiFdIE8jmFZIASXW6kWl7kzEhYEyIx +O46QkjWMeMKMKxxvKmq9kO80ayuL82evvbBzeLdUKqGOgaDgC/AIHbDKFBULBLVgSDXNcjrd1vWs +KNpRPZlP5hBH88lUvVSolsrtTn9pZSObzlZy+fnJyYlGPW3YAqMjNQtCStOKmcKsoldGRoNwOwm7 +Yxu1jFWcanS7pWo1lSwnU3sHdxYmm71afnF6slxsG3rc0DOKUuEiyYBP8ns5n4fxummPm/37X7LS +1LITa/YaS7V8p1tqPnDX7ZfPnBhUi0sT/clme2N2uDnTb5XbHCONj3nd47TfK4yPBsfHKJ9XAHdF +GEcVs3GrnkPMKtQrpaZpJLgwZ+nxcqadtkutSndxuLoyvRKPxqrZctrMK7wZCqour+TyylQ4blkd +x2lrWjbCGhyDzs3lcwM0tRmtTU4d29q9urx6wbEKPB3OWk4tW07GUiIHwhSBItPuTM1dSKTmfD7l +mv/HDSMqCjmaMhQ+bkhOPp6v5SrlbKFebMG+G5wUE41ErJK0m5lkJ5uZoih0ip3NT5tOf+SaAKDi +djPBgBQJG7JcjEbrndby6Qv30BGbouEtK7rRjMbayJWSlA8zDkaAj5C5srGxAF4uN+P1CDxrq3Ih +mRiYZiuqlRW1QP6QVFD2BwWWT7GRHMZcVyoCl/L6IhSt0EwMxkbibSashUKqpJY0q2El2o7TYBiZ +ZWRFsgQ+pihJ065FhDiyvygV0Uoj5MN9YXhdlk0IQlqUkoqaCVFaMKgyjOn3CxQlh0KSJCSRkS2z +qaol3ajxfCJhF2NmZtzld43RLO2oShGyrmjNZHZFkmsejwgPzDJRryfidYUpHxv0hoNemgurKacR +09OyYMpCiqJspG+fX/37R8uDgZjAZxna9HuEEPmkUswfNGk2HaRsaJwsZ1rNudMnL9VK7YAnGBMd +U87F5IyC2wFHjVEeNydyOY87cuAat9vFiHw6ENDwQsuH2TiuRwfyc7Mcl8BVJZK9WmMzmZzIJtoK +F2dpnaXU5dmjupIB3eFQvNyQjL4eG9hOX5DyFGOH0dH7f/zWSUwnssvlxtF65/Bw8XIyt+jzQeNi +7docx9ojB3xe8hct7GR8amn50tTMOUmujo2GvS6mVV0U+PToWBjVDAZ1PpJy7H61tlEsLIf8qnuM +ElmIZizgVxjaZpkULxSRmnG6ZHp+fDzictNuD+Xx0l5PmEVulUs6mbheluVSuQAvtGLE6ppe57gM +L+Rlsqw9EeFzNJsYGfGNjQVxUr9PlfisoVYNow74dZpbvYlj4y7W5aJRdEWv2olZ05nEYSOsE9Oy +U5ObWrTqdrMeD+PzRf5/kt67S64ruw/9BCI6VQ435xzqhrp1K+ccuro65250QKORMwGQBAGQBMOQ +Q1EkZ0YTpLFG0jjItvxkW5at5Sf7Dy2/5/XeP+/bvH171qqFhW6gqk7Y+xfuOWcfDNML5X3bX9cy +fUEoFItdJ1tHUAneG48DYNoonlO0YbVxScBEhAk0DUZ6BB8VT3DRGAVRhxG2ojVVpRMNCqOxAGUk +aQFCEoQNI5ZKqQydt+wBK+ZDYRRBTMMYmpk+y5UQPMvwjXhSD0cYCL9Egp0LTi4kYmEsGsYSMYqh +HEg3As8ASCaT2rWrch/ptIGi2XQ6qDnAsiUMd+MxkAoWittBJb0wF47JMFauNylUZgRlQU8jIYwj +XYjAhbnEQnBWnQbzjiIZz17DEDccJuEVjdKLC+lojIMRDjYY0HnbXXNy22nEFATPcvuMUITYTkS4 +pWB/O07jdq95LPK58BLKsx4vtVKInUiZyaBaVNV0VrXMGMVsmnbApHTHd/zyHkWXaLacSOqhEG6q +1dnKPRJ35ueSNJvnuLIiVi2jReA2qPf5a/FUjN7dvMMwfjjCMWwBp3IMVzHM5XLtuqL0omEuFmEJ +3ITUCC0hGKJwbEFS+5I6NKwVSW4FJShxQ9V8QcuHIngsLgZVQJW2Zg+y/upgelmqb/JSQdIaglQ3 +nbHhTFmxkca9xNX5Vkj2NHJ1xn+BYCifonyccFSloWf6i0t4EAa4RnG+4S4zcj2eVuHHot85PH6g +mJ0wjCGqkxSEugOeCKYmlZKAH2/ffLx9cAmhhQOsMUWer3NcTVa6qj6GaJcE37HbKCotLqZhLgjC +ZPmCrPezhW3TWqOpfLm0brt96EtAwWmZJB0AFlluQiZimMVTTre1ywklmMFwiIyEeQTNphA3lbbc +3AxE1/xCChwKC9QfZ1NJDsf0CEx6UCLS5rgKgEAqDa0qkISPoPZSGI8lRJwuZ5xpubYlKrVEUg3q +m6FuGrVB3nN8AbIjFGYlscmzpbn3ogtzoD8s01yR5S6KOEHt5RALbkISC9AeDNETSTl5tREFQTNB +SRMSRsbb3L7fGx8QtAMtF/gaxxQ5psQyJQSx4F3AqhgiJ5MAm8FmbJTIFyrX909/0h7eSqEWDIKk +VEgqKJiGY4XggJXVd+yOrrZVpc3QuWQi2IMaCwI7sbSIhpeIxYWAiZC0YlkdgsxCrEpyNQbyIwEU +owRHz+bgf5IYZuOY/d4fhaABNGHQlBuOSKGIshSW5haI+UUKZOTN8xfbJ8+WYkw0KXNyT89u+Y2T +SvfMLqxLamN1fP3RB18TfC6WlmIpBcF9gipJ8jDj7sZSJmAChphXhsLg+bLAl2kaBsQn6DwgCc1Z +vOIzUpnkC7zaVK0OzRc4uW64M798pOg9gG5RLuJ0cBDMAKljNinWwSgLmJdhAoxaWEwtLCLxhAjh +JwhlTWlwHLAtDZwCEA08DtieQm2MKrNCT1J7qtbRjB500/N6aUSKRkn4KMAQmimyXNm1exfnLyS5 +tBTCIxGSwLMsWxWEpiC2aK4EQwe298H916XKNAjdCImlVdBUstKGNETSOoCqZnYYzlsMoaEwEYuz +aVSjuaJhD3HKEaTyzvFT3elfm09du5ZMJTWS8mg6n7EGfn41lVQjSzhLWrxYnF/Arl44vDAsZ1nj +nLcsK1VVa6ZRPRSh40kxhWg0U4KvbvVvbBy9FGSIMW28fNrun+G4E4nyoRATjfAoonGMA4y5tIgw +rF8o7/rlXYIuBMevkIxk9uuDW8tbj1WjDWDF8k0Yc16sJJNCOiXGo9zVQT8L+H0JVF+MCw6YpFSS +cHDUTCXkSFB3QkAw+/DopanXrl2LhUIUoKipjxmqQlOldBroEksmJPjAhflYPEaDVoGkSKOWZPRB +opRKKxmvGwZ/RFgEV6Clql3c5NQmxRdMq3d2+uGTNz8QnEcyWd0aZL2NnLdRLO7o7spihBVYf3N2 +R9Pb8/MAIxxEMk0VbWe6tv2iPTjP5/v3H70V9CanVPO1zUr3eq1/2hzdbEzuqvYyzeeLucGf/uJ3 +a/t3ISUxTEMxAyNcQWrl8ruKNkgG1eAtAA0sKJ5TppgqQVdZrmnZK1Z2mkLUUAghgx1BwekMlHAp +ugAvQaipWqvePFDVWtbtOt4yTrqy2jbcqWz2Ca6UwqwUkoHWgmq6OoSbEaSG660IXAmEouU0cNIg +cINjPYirRFzCCZdh8yCfKNZnxYqo1oGCIYtjMRbUezRC81xREMsZd9zfeEyKlVA0qJIBIEmQFmgz +CL8UYgDj8KA2SUht6tpcemERh/BA0hbLNhWlD/pE0Xqy2uHEKsnmebkG4hYJCk95olxXzG4qKStC +7s3rbzW9AqARChEoagId81yBYbKgtZJJSRLLolhkWQ8aU6hslDuHanbslDZEtUmzvu0MKcoLLZHR +iIChLk2XZWmgKpN02o1EJZrM5nJTUD6gpaFfS4vY4gIGzWOYup2dlSq7YDGiYFuC02QyjtrBobCY +imCuone9whpoWk0pZaxCLI7FEnQiKQUFZIhg4RVoK4lqot6kpRJCOU5xQ8+u5Ipb45UH4/Wnheae +JJVKpVm2uMJykIkWQZmA20tRBj6z3ztR9KBODoE7XDB6eU1rNrvHudJqrbb++PlXglEXzVprcjZY +uzfcuFcfnpU7J5zc4MT8bHL49//pnx5++GUaUynSUpSmqvULpaNa80KUu6bZD5KU9IKDwFRF0iZm +drtQu9mfvp8t7aLgN0nTcfo4mY2n1Bg4UCan6G3QbJxYy2Sn3e7+209+3Dx4P5kG79N0i5tWfku2 +ppnsZtbfA2WSRg1Oql1V0ckGZxzSdjIWlA5AEaNUmGlaA2I7GhU4JmdlOoJcl/Webo/ag7NK64ig +s6k0oCIdi7Kg6/RMN1/fqw5vcVpXMnq6tQz6LR5ngrVCdwRv9PKbheI2hMpCUM6dgG8BBIjHwao0 +JLktyi1eCgraCGpHyYxFvQeJHLsqhk8xReiRkelk3f766ilFGRDPAFaqAlKhDAEWCpOLi4gi12Sp +BN8Yi5ICly2Wp7nyCqfULG8mKG1BrNvOmBfKQSWroGpuESe8q2oAVjwoIlcwtE6lvAm8gCI6jmcS +wONLJMeWaabMCVWAfcA0oJU0or33XngxqLQD4qosyw3NaEPfgXBz3hh8+eJiLBYDptBgUpKA+ZQP +Ximb3+ou37dzK9nSmmIP9OzEyE1z1W3NnoC6WOsd/fTL36zu3wd9DuYFB5OCZVS9k3HGpjWOJfh0 +gqdpP5nSwmEWQRUQ6l5xrdw8LDb2WCFrWrXeylmw2VivB2cN/Fm1dThavtzYeXzz/heimsdIxXGG +Qd1UtQOtwiFsGM/1Z359J4kaoTDt+TvD1aejzce52h4nNTG6kMYBi5q15p5m9VipwssVSQX52jez +Q+DxjD/0q8uD6ZFfW6Npczg+2Tj6qDt7JOpD2RjBK57SZ8tnn3zx62pjLRLjQH+SVJuiWsXiYa15 +O1/aC1ScXDXtHsiYCAjRBO8WNrb2nj9++WN7dJNkctevP97avgc5LivlWu+wNb3VXrm3fvDq6PK7 +Ru8uqFCOz6pmgxZ8UHHAmzRfjweFL7R4QgiOh4cpFAXqd9JIcISTYMtSZpzvnDuVI4KtELRlWh1Z +bwGO8VJV0ZuGO6x2Di1vDBoGsAWsWSwmpIMdDgKGGSiWCUfoWAzcsRmPEmnw1KwHLO/4a15ph5Pb +rNg07FlnfK/SOIsn1MVFjCDzgtSm2YqitslAKuc5AUKlA0jIcflYNFjNDCr2oGDuKg== + + + othw3AkY2PfeC0XDZCREhJdwgDJwFqIETrwiiA2WySfjwNFqPMBzEmQeJ1ZkrV1u7pcaBxvr9z/7 +4s+z+YmgVOv9G34FJm48Wbm3svaw2j2No3o4THF8kQPeJLOq0uKEShBOEQjparW5TXM+9FdRqpns +2C2sFVuHVm7VNNvrqxdvv/5tGtNhiEqNo2aQ+AfN4XljcO6VtnDS0nWgpHEsDtaeoxkfAixf3t+/ ++GS89Qijsok4z3C5NG7FknI4xgLIKOao3Lqxf/qpl1/J+tNya4fis+EYSTKu4092Tt9/8/Wvnr35 +cbrzUDLqlXz35u1XpjcMxXiSKxTr26XmnmxOyo3D2eaFaTdS6Uy1fdP1t1m+rulDxeinMRMIt9U5 +6I/PoFVgwEGi61bfsAeS3oynNQQzV7bu1Lq7CKW7/mi6fW/9+tPRxs325IZf3ZGMpij6f/Uv//7l +669J1gJx6Pq7reVH9dFdPbMSjUkwR9Px8fnNN9fmwLTaqjUtDy6Ge88n+x94jeM0lbOdzr/467+7 +uHwZiXLgap3cWnf64Oaj78arT4PCcYtJVfJ5vrgUpiIxHiJWkHuyPgZ3BjYhneRZxuH4PIpbkMXN +8a3BxuO9yy+P7v50svFElBrz8/h05ZaTncaDUqsUfAWMANDEZPN5obKfDqp/qKBXZQm8jwnOAvRY +PO2CoMWpoAo3qPcF0D8hiiZcHMuwTAFkNoHngCsxFPS8A+DJMBmYygQEJ6pTXBY8Tq600RoeU7wn +ac3W+Fa1d5GrHIxW7mcLW0E53BhPk6amVzECRl5PBgU8tWhURhAvA5ZTbQJgqlLV9Xo4paOEdrUN +rNLoncz23l87/kASi9PpWXt4THAuqC+/uu0U1gW12+ieDlbuZguroFIkuVmq7nr51VxhzSnMRL2P +kb4kQeYWFpaw+SUcxaxydbdYOyw0rmeLWwyXB7CqdfZUq40Slmp0gYB6o6O7jz999tG3e6fv82p5 +PNz79ItflGpBZe965/zu0+/f/cnfbJx/qWU3SC4PUyNwlWr9IBbUeaOJoE6gm0zrFJO3srOgPkBQ +kVsiCC+VVjEyS3Il3RllC5uVzlEmOxhO9u8+eptxBgyfI2iDkSq0XJOMRqN3cOfZN+XGevB4hHQG +s8dAo4Yzjif1eFLGcbNaWl2e3gRaJEmPVxqCWueVlpldN/3VUnt3tvvwgy9+Pd2+vxhiCdq3c2u6 +NWGFCniopSUeIMXQmqpavTaXiKcU3VnLlU4MZ810VkEOgdfm+AAqCco5u/vmxbufn9z7ZO3gpVvc +BqhfCoP3Ed58/rtaax+kJkH4ljvFiTwvNMr1ffC2kEcoItfra5pSBtt4DTxgmOOUvlc7zddPi7Xr +NFXBUMc0hwTmLs4nQ0v0VRFUFrwkiKJkMjgBNF07AzULbQs6S9kQGxl/S3ODjcEQWpo7YIItahU1 +M5UMwLEOQ3kSn+PYLIQQDRBKljm2DS+CrBJUGWA2kZC6rYNyYy2oqhchwQvLWq81vBis3a/1912r +/sHLb3ePHiOkUaht75293Tx63RnfXdt5vrr/QnfH4SibsUdgdQkgXEKHIWX4lmZMIR5ko7UIIBzc +fePZ7oiTqhRf4uUmxVUUIzgdySs1Qam7uRVBKqlKcbB8Mt64O9y40xjs7x0/W999aNp9NzfpL18O +pheTjZtWYTVN5oOyzyk1505q9f1QhF0K0ZLSNt1Vw1oGvSSrfQDkdEpj2TwWlKCkBbmZK21Pd551 +l+8Vqtum2bi89ez7X/8eeBPGkKRcLTNtDy9vP/r6xWe/mew8gdBNIrJfXrbzMwS3ri4bYiJxiSA9 +MCY4kU2nFUmp4UFdYiaFWJI2LNT2bz569+WP/+r55/8i3zqOJjVRqcNQILgNMwUsRlNlVe3LSh8M +zsIiCtDk+NtcUBleBxMEcwdkbYBoZzxAgNXNy+naebG6ni1uC9qYldu80gEqWd76gGTLsbhqeeua +1Q+qK8SkNGIF9e0XSZywGq0DHNPnr4Xm3gunYASCQ9Abkj7AqdzCkpBEXHBV4VDwBCwRV5NJI5ky +wEORZC4oo03nKp1DnvaqlVWayUbjHHQhXz+x8nu6Myu0TiCPgG214DnVkBFq0DvQ/ACVyYScTChI +SgfbAsOeTqqgSyHUr8oSyo4zSgblqlCYiGhCgpYISkMLrszo5vzBYHxqOwNJKq/vPt48ft5buZHJ +9XnJpzgPI10UzZhml6GcVFIEZahn1iuN293R4/W910RQ/FkQ+KKdHYM0SqQksOcYWIbM1HJnoH4l +tT5ZORuOrnOsQxN6vbl1cOPjO8+/vf/8m7ff/K43vaWqnY+efPH1t79WjBpOOThTEMAyVI8mq4+3 +9z8iqcrcArYIGMKULG/VhEQmfcjuWIQHsQ1eLB3ceaQZ9jjjTgxQd3yJZvKqUqu3dtZOnnNKM53O +tNpnw/GjSm1/a+/xzvXnotZMphTban71w19kcitLSxyCupIKmnzGia0UYoLUB/pwc1NwcPGkICtN +v7RdrO9NN+8++vCbo5uvRKPrOOMnT9+B70ujZsaZFMrbldpBqXokKaPgPqw4x3M5EFrAa4tLoJ/t +cvOoN7tVah6AQiMpK1+YJFNSPClCaEESnD74Zu34dX/9ESs15uYJmsg9fP87TikDI0DAp1APxYt6 +ZrXWullv31oMnnElUkmW5XKLS/jV5W4qAm5daFnelqwN4RvjUYogdLDJ8ZiIkzlWAD872Dl58fjN +z9PQI7GE4zaOB7vXTHdsejOntO9WjmixytC5ZmNXkMB6GzLgvFxXtbaiAFKVkbQO3n9hIb64mF5Y +SIeDaufsVckyFUllGMqnSTuV5BWlbjiDfHUjX99uT246+VXwwrn8iut3GSHDiRYnuIpSkdVaxhp6 +3joKsjYlC2yWpOxEkgeBKokVlgtK/GGYK/I1cNbgiSDZEVQH8ATCikRFoGZJbpUq2xmnT1EZls7Y +2UbGq+dbs+HmzdW9R63uYaOxe3L6otHdYgXfy89q3XPFGufKO5X2meluYVgRx3O63paVKoirBHjD +mHglHmyeLYO/4PkmRWZBXS+GknMLMRTVHXeay+82u5f7Nz8DDZYxm2cXH7nFNYCvZEpGrw538HzV +y620hydLET4cYmWxDagYS4gLSyi8EilZUhp2dkpCqGMKpB7H+amUAkIuTZhosAu0Nl6+s7X3CDyX +qtWGy5e8UEHSWjwqRK+Ke8djHM/nkkmeYhwEszm+5ngzDRqTnYhaWzI649mlrNZFqTBaPumv3IDf +kHw1TdgIntGMXjYPjvskKDQEBtAaZfO7bm63WD/UzFEsnoHYi8eEyfBga/NGUCYuTKXRjGz2i+3r +nckdw15eWCRcu1erLYdD6PxcAtAAhIHnTzWjAYmQiAkIYsFLVuqS1uDFIviycvu02DgZrT0rt06t +3DJK6pbdHU5uGVafoHLJlA2mNRlclsdFo0wkQocj1B/uZfhDNTyGKpGYxxKeb3d29+4xoi+q5dHm +nfsf/OzBx3862Xtu+uucWHTM6uHOzb29p7rZTaNqMq3gwWpjliJtz+1RpJlKsRmjamhVMCwUXcSI +UjyRuQpgOhGs2bFLS4CNFKAouBtFHchyD3wERmYkudhfPtjcuzi88ezk7uvTW68uH362efC00j+l +eL/T3rpx/kJSCgimKHpDN0e82NPNFZIsIkgGuBjMNYaYOOaSZIHEcwhILFSHQZaEiqK3BMk3zBpB +ZWg2x/Blmi/LZtdy+/3B4aOnX2qZtqrVwVkIUk3PdPz8ZiYz4YUaiOGcN+i09uJBHWwkFpdRzFW1 +nqS0JLnB0J7jdAF14V9BR4ElL1YPxmsPptsPz269g79D7k8mx9fPX/6huByBZ6hgKw6Po5oo5mky +0+puK1oVQAwCD9JNzfTzzcPhzvPrNz/PF2Ynxw/+2//4354/i8Z0XuyDp2h0rr9884tnH/9Ss1fm +F0jIGkVpwrdAWoWCGoNCPG4Z5oqdXTPMLo4ZIJxSSSmVkuNJKZaSQzElHFzkYVrOWNFriRQPJjoe +Z6NRKhrsPZPIYDsH8H6e4WuKCc6oC4ar1jnI1dbz9Z3G6CJb2VXdCSjk8eTm6cXnGXcYC0pwB8VP +RL5KUT6KZIAQgSWDyuTB5Wh80Pe0haYMGrc8tzWZHTm5QW94sHfxstbfrfUP/Ma+aI4prpS1O+fX +nx0evyGvLtFIpSWWLcpKhxcrmtZiuYKmVuv1dYZxwGujgB5CV5T6nFCPXxV/DmYhxkGOA61crYar +KObwUlExGzC//cHBb3/3H/72H/55Y/8+/AZg069sTdbudgYnq9PLvZ27llWzMk0z09WNrmmNGbYe +j+mLC8EVS6ElHEIrmZAiwRoWuriQioTJWISmSde2R9OVy72jJ7GkAKoGDy7mc1WrW24cVVsnpj2k +GXc6PW1395GgSr9M06BIgyUwMOa1yqzV2AgtYuElkqZy4O8I3IpEuGQScsoUxbKTHUJgBI8H2ZJm +tPzymukOZbUpKR2A7unyydr6ZSwmQjN4zgcmTSdlAtM5Jkvghp8fieCRlxASB82TlbWm4Y4sABC9 +RVOZWrn//PlnAI+i3K83bzXal46zXCqt+YUVhq+CCNflWrO2AWm1sJi+urOgpKire4df7p6808xh +KMSAZQBmR1LitbnYXHCJhpxIOgxTA8NF8TmcttKIMj+f+AO4CXK10NgD0wdeO18/8kp7vNQoVTfd +wghlDTM3aC9fTNYfnN/54tmrP/3o3W8vH34jKhVJLoPMwHFwnXYkyiwuIuEQnk4BogocX0oGdXJE +oBIkJbNUhqJN1SqPpscPn3+xdnAHhR+BHOuH7eFdQF3T6mVzE9XsJxGdFUs0l8PwDEA6LzYVtdcd +3Bwug1WfRGMyBcwiAKp3WK6eRuxowowmzasL/jSa8SBVUykR8gVB5aw/PDh5enLzg/bw4OD6w8uH +H2e8tigXsoUVyxsdnj5bXrtDMTmc0DKZ8vHxo2p1Bd4FDhpB7OBZIp4X+DKOZjBED4eISFAoLyj2 +CH2MhAmQBDl/VixvFkprqlY+O/9otHxB8p5s99rT+6ONZ8XGoeWM9g6fdvuHAFMwIPniRj6/oSpN +IMd4gg+FsGvvxVJxkcQDTF5YjIdCJIZmcDwDeikerJgoLJ1PBF4Vwwjg0zLohEb7yLaD1StoD8f4 +GaMZ1HBbRAFOkZRCkw5DBWvc0QiRjNMc7SYSAOxUKEKDnNDkoip5mloUxWIuv/zxp7+4eectgmZo +uqgoHeD0SuMQFCxDaiLvXFV+phkmHzwOFVuy2HSzoMOL8SirKb7ntEHhvHcthmABzYHyCQc3YVHR +GJtCVOCd0BIai9EgVADlwNEgqMkHbqtAc3lBaULq1bvHltu4vP9q9/r73f716dqtnZP3Z3uPC/Vd +Ua5Ua2um3bzamWPCCCwuBDuOGDKoDGZZYFtqvcE5TmXDYRxFFF4sVdp7Fw/fPXz1ww== + + + ZPXW69ffvf3qN9nijOaKLF9luLKi97zCdnfyZLr32i1tSnJpMLxR75/YuYluDUBIx+JBfeNMZgbu +Y24hNTefWgwzrNSTzBWab1yV6dNEoVpp7HNCDvRkqbJy9/6rn//6rx88f1fu7tuFNUltnVy8Obzx +ke60CCbjeNPp2u1298B1B9XqVNMKMB3gfDm+DHomngjuGA1uz0GsoHoDBcYwszAfoFYqIeha07Kn +vNimmbLndY+uPyiWx5zkeeXZ5snL03ufLe88aU8faM5yKq3XS+tPP/gpxTuRGJUONieDzQ8K6MUj +IoFYhlzb3rg8Pf9gfj41PxeDzwcStHNrMCA0UwDs6rR3rp+9BC+MEw4nQDrneT5PE5ZtA6rnAcYl +Lqtq1WSCTySCnTPRMA3fgiIajuqhpSSBK5KUBzcEkdZore+fPto+fJyv7fVGNwCpJLmyd/0Fz1eS +SS2o/x8TEzEZw7OKMeCFEuRUOIQBEkLcYojG0lmGBP1Dw5eGl3CQwZKYn7sWnbsWvvZeeGE+DlEN +HG0oVZF1e92dAhiHOGPqVQQzRKWm2kM3D0r7cLT2uD+5sb928t/++/91+eA1eEY90ys1tnOlDei4 +ld1gpQqCaRLvHx2+T1DZpcVEJJxMJqhEnAMkBFUJalbVSopWoeicpDTt/HJ/+fp042a7s/XpJz/5 ++N13bmHIyfVi9bhQOuiN7hxefLG5/3J165GdXS76y7fvvtLsYpoEa+nhZBl4yrSmqjFBMCeeVMCU +gUOJJPRIcBEYDRYJfFausOv6m2DW7tz6aGX1TLeabmGl2jntTx9sHb669eDr5+9+25tdDsZHD9// +LFvadLyRafUFsQK+GFQx4KFpjBFMj8WDjMNwV9eWLWsVDD5BePFYUJNZEmrRKIAMBiITx4tB/Uws +EywPKXXbG4pamZfyMFYY6evWcO/o+drGbYiNTm+DFbOKVnSdXiqYRCOdtpMJHUlaHOX32wfT5RsL +Vw+RSNIAPUAyeUHrCFobUm+2erGxeUtRa7IMRNmxnK6mNwQhb9pBZSSWyXUa6zCP8Tgdi1IQUQwJ +ieCiaS0WZgDTPLddKgbncWTem66f3Xr05taTr9zSLiu2cLJwfPz0P//X/9mozEBAxmO8wJc0padp +Y0UbpBEdZIZpNFY273u5YSLOQDjFQnQqzhOoRmGGpVc4zgFgl4RqJBxU2V1YADchkZiVjqsEagP1 +5/3ld1/9IpkSGM4T1KrmDLOVzXL7sNrcPNi5+fNf/avp2jkQ/WByE2jRL29BaAkqkBdICClntf/4 +u3+tud1r15YWF6JLi+kI9CguArPIgr/S33z8/qem28FAFWgNyahlC+NSY220ftoa73Nywa+sNgfn +mjlwvZnrr4lqPWP3Va3jZVe6g0PdLhVqA80apBALSIFk3HhKB+fL8zVNH4LDpdhSJKHOL+IgulDS +M51lQa4rcvX89MV0dmo6nVx5ozO5Nd1+cnj+8YNnX60fPfar69u7d/76b/8xk1sGdQRQpugdrzCz +3HVNXzEyU5J2DbPVH91Q9VbwlCZp/qEiKLxYtipK7XCwnM0uhTCIsTRiQDNkvV+o7g9X7hk2zEt5 +bfWi2T4QpMry7Gx186YCLgkzaNYHB6SpjXhMBjUIH4sgDpq20YQCLA9wEVpiLKtnmPU4sFhU0O3J +8s6z+uDc8pZxOocRzmB07OX7FOMxXMnzVyuNvWxuTVOBH7MQUcmEwHPZVFJIBgttWQw1Y8F2CIO/ +OrkGXKlrdfhwr7i8ff3F9Vtvz259cnnv3eX9T9dmewILttTmuUKwtxMJ7mximFKwW4Pxs+640dzP +Ot1kjCVRgyHcVIyn8QxDWEiSj4ZJnqt53hYKlMfbwQVS83g6oSbioE/KIFxVteXnBhRtcXyOZh1F +q+VrG+v7jy7uv7m4/2795AXFB5C7vvtEsXoMZIpQpdkSL9YkqQz6fG3jDJzj3LVIMsphaSuVgG6K +6ZSEo1KnPri490Iwighp+7XdjDeGTx5s3qmMbohGW9MqTx+/Pb14AcqKJAE3Grn85ub2o4PD9/PF +TdXoDDurf/bnvx+t3r72XjwaY9KAJEQu568ORres7CqKmecXr7KFyfwSGolxKLAMHdSs0zK9fHmt +3d46OXmwffgQozOqBUM6cXJ9zW50hod3H3/+9M0vBA1If6/eP2WlBk5mKbaA4Nk0FqxrV+p71eYe +imuLSzjPl7Ju4BlJPJ9OO0shIRTmUExfDKeTaZ6iXSe3lm8cNQYXzeEFuOZaafbjz37/8MU3qbRm +Zft+dc0trVneFHAbJywU1Qy9M5neE6VWOMwFz6uDZ4PSwgJGkQXbXl5fPf/k3Y+i3AQlaToj1Rph +dBl0ZrV9enzrc8cf7ezefv3pz8YrF6m0GWyPxLyg8D6VY9lgvQ9DZJ5xQUgnU0GJ7KUQG0/qKJGz +vc1277xQnKyt37h++/W9D76998FPLx596uSnaTwjKZV2/3i8dhsCwLRa4HYZtkjRAVDHo1IyriRj +AsBUs7Jlmd2596KhJQxJy+lgvVhKp0EZ6qJYO7t8lUobf/RHiVCIBZ2smxPHW4P5mptDU2kZJ02C +NjnR191Oe/nG9vmr8dYzxZkpdtevbrbG5zSbd91pobLnV3aKtUPTm5BcNhIPCqKmEgqaUuNRDlBx +YRGBSCBIC6ecFGYkENlw2qbfZWSv0FjfOH7RHJ42+8fDlcvuCMxUA/QzERxgacjgvtk8y+VFuaTq +1cl4/+WHX7q50cJ8kmE8yxmqehsnvauqfXma80vVdUEtA4DE4iAggZg8zWxD9IIIbNUn5+f3puvX +Ccqsd4/2zt9ePvzpjTufbew/mG3fzZVnRX/029//3Rc/+5fB5WJUrj+5tX/9k1bnbqtzx87OEMyM +RMliYahqNZij+YWgyHMkqqcQj+bqxfLGh2+++eSrn4NpjSXlFJ4h2IKa6fXHp8PJ3c7kIS3VIerK +7V3AaorzWb5Cs0WMAOx1JmsPdXsQTYgk7YEfv1JxFsQwACBIVpZ1qo1VkFWplK5mus3B6Xj1/snN +V9uHT0FzGnrp7cdf/d0//J/j6UEsrohiC1BUlrsk5cO0JlOqItdYNhcBl40oytVYSVqnNbo8uvV5 +vbV3enT3L//q3x6ePN6/8cHJwy8n+y/HO88OLt+d3f744s6r1uC40939r//0v7/72V/SlJ3RW4Yx +AAQTuWLWGVl6D0Ps+XkSHCsIoaXFwC/PvRdbnEcDI0kUDXuqmf16Y9fItEW1oTtjxRrq7tTyN1KI +ppr1cmNjPLswnE5jcH1l78nujVe7F2/XTz6ujS7N3KyYX3v6+CeX9z4V1LqotBv9s0r7RLO3ZXUV +Rb1olAMblUhAvgjhq21sKMwa64PjKzW2is31znDn/N7rG/ffPP7wJwc3XjRHZ6LRo9g8CBVZaRBE +JpUSUMyWle5w+c5s40mxuisoINEVHHgHN8FYQTKygJbayM7uFStHWqYLM5tISSyfS6akRJIXpILp +DMr1zVZvF/603L4geK3+4Wh2OZyeFSpb1fZBrbOfcXoFf3DvwYcHZ/dJ2s6XNuq9/Xx1NZOdSFov +mTYgNShcf3D/41ZrG/grFlNRNI/jZZwoI1i2Wtt49fqnaxs3IhGaFytuaavYOp5uPfngk19++cPf +7N14R3PVcX/34eM3ilaCGKs1j1e2Ptw6/LQzeurkZhhhErj54v0vuv2TYA9zlAc3TVB5cOjFxkF3 +ehesymR0uLF5AXjOckVJbytmr97c3dh/2lu+VSjNADbr9TXT6oSD23upaFRghbphLTvuDEEy8big +Zzrt0Q1Fb4Ea56WSqFUJyrKsdquzo5u11Z0H919+15/dqrR2VLMJLRT4fNYbPnj25c/+7N/tHz8D +Y2XZM1FsIGkdTQuxMBleCgrah5YE11uFiXjvvcjSIh6NcMkYWAaXl9rQfhx37EwP6JjmCt2VW+eP +v3nw6k9XD16C9eiOTk8v37588/OtnXsffvLDzunTUndr9fAJKKZ8+8QrAsW8evHRj5sHTzSr7/rr +reFprX1kepskU/7DbQtLixhDezTtpIOdtALN5iStoRgtv7pRqK1d3v345aff5xuzxnBvsgXZfbPS +OekvP1zb+ajeOcVpm6Qt1ezySj3jTmx/Q3fW7fyubIwZpowG624iyxdYqZ4mPJKtBaVohUoyuNog +bzs9Mniyyl0dPF+drD/aOHi/MTgXlJam16brF5XmGit4hfrOzumHTz768eLRT4qtPSvXZwRLlnP7 +h49Np0Zxlmy2eKUZwKZU4plcq7Geyw1BN6aDqvjB5SwAmCjm5otr7e6+JAenEhgGFHtftzqG1WoP +D3ZPn1c6hyTjXRzd++77P/O8Fst645WHo9mjVvcs628lguczDFi8Vx/8ZDw5CQWXzAY1VE1nWm4c +D2YP2uNLUch/8ubrFx9+EoszkGu1zunW9Y9ffPqbhx//Kt+4juIuQ1t//ft/d3HxLJHW/3DDiOVu ++KUjQWyFQiSO6cvT82b/JBLlUDRDkMF+A8Xo5Ipbbn5NVSsff/LdV3/8576/jBO2ZnS9wnqjc3Ry +88MP3/1ytvVEVLo8X9WNYSq4PBq5di0K3YxFRUBXlmukUs78XApHtUppHexkJAT2QcIJH2gxmcqI +fBV0HYye6Q47o/PB9C6vdM1Mczy7vbx5Hyjj0eO3X//w29HaWbY8e/zBn7z95vfnD77dv/7m2x// +/d7p64wzbtV2bt37PFdejqfkNGqBWlOkPI4pyeA2IrPo9WcrNxSlnE7LBGWrZrvWP+nMbu2cvFw/ +emL7/aPzJyu792vDk+rg1C1vq/ZA0JtadljrHbvlNYx1GblMQO/cWal7QcrdJOpRfE22Bn51h5Wq +stWRrCErdWSty0tNXgzsbRrRIPU4IccIDgT8wcVnB5efzXbf701vVTtHMPX5wujs/ptcba1Q39y7 ++WltdNP0VwynB471+PpjijGTKbHSOLSyK5JUs50hQWRTKYXnc252KMnNuTlkKVib02W13OyeWO4Y +Re1kXMp5I4qC99IIIvRGh6/f/ezNZz8enD2v1jZtp4uiEk0aqlIFtxUO7gIWeaHQ7h2223vF4iyR +4BcW0uB6CCKoYcJyWVmpsLzHs3a3vea41XAYBW2/c/rixuMv1g8eFeu7rNDEMFeW8n/ys1/u7t1J +pI1IVAgKywTXQwRPYEDOMbTT7e1adufaewnwoRxbNjID3Rrr9nKwqu71f/LND59+/qOiAHuWNnY+ +HK0+qrUPAAy9/CpJ5mPBEQB5PLnkWD8UomjSl+WeKFQ5Jkfg7vw8mkpwq8tHv/ur/xQNU4sQdTER +FIVpTfz8dsGfyryzvnmqG1XgLF7qK/aMZfTO4GC0emt549Zw5axU37DdXn94fP3Ox0eXT5c3zirN +nXwFkGQMntfLDmZrN02rG2xlkWuSWBa4LIRWUBkA0+DvslRMJNhkggNlmPWXd45fPg== + + + evWL0zufzrbvHO5d/M9/+udPvvzByk+y5c325E6pedwcXBzeePvs45/tnX0wmp5/8d1vM/4sTWRz +1Z328u3+7OnNxz+7+ez7zZOPJpPz//Cf//m3/+ofMDoXT5lXd+SZJFc2sqvF6kF/cPj6zZdndz+a +7NxfP366vHOv3N1d3bu/c/T00YuvX3/9y2p7rz8+efXuV19+/5d3nn21svPEr2xKWktSOpo5SaGA +jQKkOUaAPyqrWs92R6Jcl/ReGnUVtU2QRiJFkYGoGxrOWNO7NJ0HejIzjY2dexm3U6oMB8OtWmvX +zm0KSo/nGzxXBuf1h1ukISRwPEMz+VRKC4XASkscWyQJF+ie5/O8kBfEgp5pZewhqLJIjEFQhQH7 +RoB5141MNZcfzzbv7h6/sJw+y2dxKjjTcbXjjkGDjVVZUazY3jJBuumUkozLgLTJhJKICxj4PsLu +jE93rz9b3riTK20xQiWRlC2j6ecmNO1BmNF0AeyebQ0EvohAfHL5P5zSwtLm4jy+MJdemE/BjzRp +sVSwgsZx/vy1RCohxqJscD3iEna1BCMm45yilFjOgUwp1rZLjUNVdmuN9fbgYLx22RpdZPMzXa+D +c6y2NxXDk9RMxq1rZqPcOKz3zsHrpYINro5p9HSjdXXGlgnOACIqy/jppAydDYcwMMIsm2U5T8s0 +87Wt3uhsa+/B9et3Pnz9+d7x3dHsxq0nXx9ffv7wxfcXdz/pDg8cr+Plhr3uzpP3P3ML4Be21vef +HV+8Wtl53Ogf5MpT02vXq9NP333/waffEoyXzW+a7qxQPbj56Lsbj75tdg+2V0///r/899dffZct +Ljd6B5Oty/WDu6++/Nlf/u0//vt//F9/9jd//+z5l3/zr//jn/zy9/n6Tr624xS26t3znaOPn3z0 +6+PLb0S1oynVtc27kERpNJNGdIb3wTza+e3Z9ku/vAmibmX1UNcbljP2yqumNwQxqWUG49nde8/+ +WDHKrtfI+gPZ7I1XH6zufuiVjkiqznB1O7dmOBPwbhmzAvEA3Iqk7UTSCNYUYpIgVtu9E0VroHgG +9MDW4Yej9duZ3EQHk5hpEpTKSVmSMTFc4gVH1kqK3lDNRsbtylotjUiKUb1+82W7twvaTzW6BG4B +fWCopWk9HDNjMRZAAEILJUxBKVv+WrN/S8uMRamqSgVVDqxlxuqmklokzAlCwXYHstoGfAMZiYLF +WMATcRl0DgkRmzYo0onHeNDVwc7ApMqzPvwYi3KQO+GokEJB1eQEpcpJRdcftgaHJO2X/Va5uqzo +pVxh7PqrljtzvZVKdbtU25DVrGF4VrbBCZ6dnbjFLcOdAA2JYt331orF1XiMQ1IyRWQwDDSJHFpC +r2oKoSTugO+jKEdWK5JWHy2f37zz5u7jT7rLh4pRzBX6O0ePy/VZsz0r11YktQJBmMn0LKvv5caQ +wrXWVnd0ZFhNQW1QrMcIuYxd97LtenPdL42DIpBdiLd1yILN3YeTldNyvr02Wvvqq2+2j244bnNz ++9aLT759+9Off/njn7/7/tdv//jH+y8/2Tu6ePfFT568/Gpr58H7r37YPH61ff3N9Yu32wdPwLRy +Qr6QG3z9w1/tnDxZCtPRGCfKFd0eVbqX4/XHklrW1eKf/PAb1+2CQMJoLwfGeXRxcvuL289+3Dx5 +rWrlJ49e/fDz303WLhixotljVunw6nBl4+m95z8frN2nGPf1669H05N4UgmuRE8aBFXgxOZ4Cjrk +qWX319cu9k9eTlbvdpdPVbtDMnlZb5nZQWf5TDKaCCZDv0SloGhVTsyCAeHEkp0brR88++zHfzPb +vmeabddfwYNDIkKwpJsKnneBZeiPThW1ruvlUmVFt8f9lYd2fpMTwToB/HY1vQ90lk5nOK7o5SfF +6ppqtCnGD67JiwAiYTDRNOMDxgYHiMLBZrZwsI0wuOEOxPzCAk6SXnD/1BKFEK6VW/bKm05hZmXH +hj1KpS3bKPGil0jxNGfLWrVY3am2T8stMIBd3SiXykPL66KYms0tdyd3moObvcntq6KUQf29eJTO +Zlo5GPCUEAohoSUEQAy8MM8CQZclvjIcn7BiTtMrWYjk8XUrv6xkGrY36oJklf10OtgIJCqdSv24 +0jqzsjOK8kgi43gjUa2HYzyGu6JYhmzySzPdbFO0l0rLsRgj8B6ogmQq2EnCMZaletVcs14Za1rB +yZSHg82VjcPhyma1MbW8jlMaldubvcnu1vGdZv9gY+P85Wc/bp+9gJG0rKbIexSpU5hQ9Ts3L1+2 +Bnugn11nWipsebkVIzMkGWB8JqNlbt16wLCeKPe84m53dHn99mcXD9/tnX/ol9cNJf+TL376z//P +/3dx/2NebVW6Z83lBxvnX73++q8v73/SG+16Xu1Pf/0Xtx68SaMGmLuMt1Ht3VzeePr4w19Vm7sl +f/TTn/761Ze/iiVVsCcIbita9/jG2+ef/ubZF7/1a3vDwf4Pv/m3vdExgugorutWtz+5e+PhTz7+ +6i829l6Csfrg1Z8023sLwe08eCwmkWQBoqLe2Ns9eq6rtVcfvvub/+MfVa3OK307vwPf7hb3Lx9/ +/+Ttn3fHd0nc/fTdzz/5yS8K5WkkxoUiNPyJIAZNFWRluBTctcrdv/3y44++AgCZm4vNXYu990fx +uTkcQX03t0cSzs7+3enqGdhSwwbca1BMnqBLCQTmrgImi2Vs120RhI7D34WClZtWWkfLa7eObn6U +La/SdKZe38oV14I7T1ETdGM0JgbbI3nP1EoEKqYTpMQb6SSVTHIUV6CFCtgZlqvQXCmNKpbVAgk3 +3Lh749EXB5dvlvdeFBoniZRI4qpldXAiePR35fRlNG3IUq3a3BPkOmREsbACTUJxDUY7mlDALQbl ++wjHVBvJYD+JWm3sgNw1tYbIFTDEYEkLwKdcXhYkN5kkeT4LgJPJtmfbt89uf7R7/DibG5VK41xh +mWGzipw3zaok+AxpSqwtcPAWMRyhwVuJfAVSnqEzJGGlU6oulyTO4xkXLDkkuCxVQTAzrCtIvijm +DbNe8vvLo73+cB8YARq/uv2ot3xerEyMTEXX846V96y8qZeDtfsoL4tlHRosFmjaxjEVRySgp3xx +RbXGyZRZqOyUmwdOdrK+fW///HlncsKybrs6vH3nRb2xwdL5UmWzUFl3ciM9U7ecJrhycLKa3mBY +P3x1OQVoxay3ni/umpmBJOYtLdfrzGZrJ8Epxfb1QvN6f+1xf3a/0tz2KxuCWORI5eT6/dObLzS9 +DlLQdsYsB+orb2jNRIxLRJms2fz6q1/88fe/Ai8T3K8aVRJojpXbldZJub7vZqq/+/2/+ea7P03E ++IV5NBFXFLVX696aXX+dSqnpBK+IMI8DhrYBNICSYPBB+y2vXYAQ4mH0ZP9g73a3t4OgBo7ZIGIF +qQKDQ2BiKk7GIyiBULqk4ShGoLQkF1rjS9vfMOwVQWlKgru1enJ568NCddWwO34ZzPI+xdYQRBUY +S1cKSEpAUxJDZTnal4VKNrsMvowg8zxTzKgNU6mOe7u7+49R0gZaoWgXRYwkwH6CUwW3Xl9NxMVI +iAquYI5wJGHDmEhSUZR8CAw/P9SMMklrXn7YHpwUKrt2dmU8vZMvrpOkNRkddrs7SDqoTIITYNXz +yVSOJBua2ocmpRKEYxRcuxMH35TW/7ACiKJOcBIfsxMJ2XKCDOX4iutNveyQ53LptAoyWBDyFGml +kpzABjsSWdqCoKXIDIKakSgHGcHRZiJKBKezEwKSFCTWFfmirLZotphOi9XGWrE+w3GwqK6RqctK +0dSrnl3TFR9Jcpqcr1RGBA5pxTK0CeFtmtDgKnQnkRBSSZllfQzNUKRNUy6MEomqhpyV+SwYChwz +ustnhtXl+QIvFCnSBb2kSCXLrHJUJpVgwkso5CZLO4sLSGgRS8YogZZUwSxmO+36FuTp4iIWDrE4 +XmDFJsMVaTrL84YIpqW7nPNai4t4cC4st768/nD75NX6wVOwGAyEE+NQpMqQasAOpAH9UvVKzh94 +/hAiP6PlbbMocDZMhMCCJy3RjM3QViJGM4RGoSKD84ascxSjiLrAW355KBk1knYJwnD04o3jO4+f +vLZsEGmFYnlrOL6fL+0zTJbEJDTJpuIMgag0mSEwlcQ0jnF5vqTpA1moUpjp6pWHF0/fffNLgrYQ +TKEoCwfgwi2OgpeZTDDxCIWAsEyAG9Ix3Loq8qCgqC6LRS834IUsy5jN9la9vVuobHqFNSe7IgMk +Epbn9jxvAP8ZZiFfWC1XrjPsgCTq6ZQeC2NIkjTVrKb480EZGQQCmGEqPNek6AKK2gTh5oszSa6C +UCHIHPB48EsqB8IYgDEoALKEYSmBBO8cIYOqCGGGogHiyizlMJQei2Cu2awUVijCIlGdxCyOASVg +YajUaM78Qi+RoAXOUdWCKHiykONog0BYNElJnFUtt5FEmkjjLAVc4/G8D1+XiPOhJSwWoUH6Lswn +o2GSxMx0QsRhvkiTQgA9IMy06ep5xqhiaVHgfZrKMbQLGQHzGA2hkaVUMkpxZCYSVKggwB4yhJNz +m1kbsrtC4878fAqocGEh0NJXx2CZRJzRFFeVHYbWYlEC3KIkVc1ML5sd5EvLZqaTiLNIGvgUX5iP +YCmKpmCCFFl0uu3VSmVi202aMlGEjcexdFLgmCpDuQxlVIuT/sp5KApYgUbD6Vg4zZGiwulZuxRU +IvJrilFIB1DvT3qbDVBBik8RSrkwcJ0mMBFJO5EIg6REDFEMMC9Gg6YMSJx0ksXSPIFpgGnxKE9h +lmfV++3VdnsmcIZrlwU+CxoV3kjhGoFo8/MIQBaOBF1bWkzEkyqG5yS5ncmM3ezUdrokLgP4bO/c +0jNgRvKg4nSjm8+vtFq7WS94cphKCoKQlSQPQj1YFwsuoGRI8P6EiqTZWARJxTCWUEgUmiolEiBj +PNPsqkoAFCiqXZmsIWCOKPVz/kFwyIW0U8FCG+AqGwml0LQINkcQilamJkv5q9IKyWSU2Ns8v3v3 +Fcc4iRiFJDgiJetSHjpFYmo6yUWWEJrUJAHQRksneRqXeVIWGZWjNRInU7EEg5HwI2SiIlcksRSs +U8dZNC3BHM1fiybCdCJKRSAM5hLh+XQ8whCoLrFZUy2BbqkWGvfvvgCRCWSHJCRAFSyt4mlFoBwI +v1iYyLlD31shUZMFjkgr0RA59148FoF5MeAbF+aiPJNRpHwqwafiMEQ02LdoCGMwXeULLGFjKUni +fF3tLYWQ+fnY3FwEuszSpmWC/DZzmdyDB0+zXjOe4JC0QtE2L5REuclyxUSMcDTv8e2Xv/qX/yWN +6+/90dLiQgJPC7qUs8xCzqsYsv3o/rOTi0cYoUTC2NWifLAuz7GWLFmGahc8UJibqlznOQ80Ho5K +8HuG4GROzahFEpcIlCHSLE8bvtcVBQdHYQSSuijkPIhJKYWyaYQERjCUqqmN0XQGmA== + + + KBTGFuajBK4rSlEUc0RgWi2CcBgyY6oFnjZxlM9kqtX2HkHBN6poOtifefWvJceqxxP00lIa3DSa +0gTGJ1AtEadIQirlK+Wsr/FaOkEk4iRJ6tncoNHZg4hKpyRoUX94mC9Mg1uhQxiEE4EpTMCAeUNt +sZQHgVT2B7XiEEcYgHRVyHCkxlG6QKlYmkonUPj8R48fs5QcWUzHQtjiXDw0n0rH+aDMo+BeLQRr +BOrgKQZLYrFwIrKUQJNYzjA7pVyvVnAMq91d1gw/GgEPlQoHU0xQqI4m5dBCav5aZP69SComqFJN +EUt4SpJZK+9Ui9m6ZdaSMZpAFBoHrlFjACxz0aX5RCyEInFG4fM0riUiGER4PAqRL7KkRxN+OqEs +LaSW5uOGUoKADC2mIA6BdgXWdY2aQNrpmBRZJLEkZBYXXkRiEQpLAXjKyRgh85LCs6bCtovu8vJA +lBUCDJJTbDcHeb8sSjqO4QyO58A0tsaFUm9hIRleQrCUaKt538zrvOCq4rBWODzczZdrKYSOxSkM +BQ7NqEqmkHNr5Vy9lD3dm33x2dvxeCsSQSLhVDiUkFjVAHmUMSxFpVDcM9Ra3tUliKgonkooLF7x +tW7NfXRz+/69o+2TWbsPH6ZZGRAbOgiYK1NMQ0syaiZrG5apZe2cxLkZrS6wHsieRBiTWbVZbfeG +K5lMoVYZiqJDkzJDKGiKCy0ic3Px4FkWE5SLgaFLx0lQv8POdHtr29IMEmESMZImTVAFOa8hKz7H +u+32qm3XMpmaohSSCRZHRIgZnlENKSPzDoUrQNmyWJEFzxB1k+fqvpXL2IasurquMJQCQcYTs2Hx +YHeiSoCKHInKREpgMI0lMkBkEB6AITwoTFTCkkkilcCTSUdRx5Xsbte/3Gh8cGfy/Nbq9z99eet8 +q+TYPKsTmAzcJ1EOBNi1PwotzidT4LJTUiqCswin0IKvm1nNsBWdhuRNEYakKALPAz7yksSoupBz +zTqGiKHFxPy10MJcDMIDyDEErjPEzc9hc3PpxQU0EWEh+JE4QaTJcr7GEiKL8Y7qk2nQ/JxA+6qY +T8bJxYVYIkpyoGHSNJ5IKEzaN4hBRdoaeQdbrUEv16ga0272yfX+26d7FyfjcdsdNXNFz7cMj6aU +xblwPJyk0oQjyr7MZphk1SSOp4VBJ+vaomMpWdfRZaGUVfoN43DZ+fb12bef33r3cvfzV0fdVikS +TkZCCIWBYPUtWc0qXE4mfYVYa1nHs8JqW685xKyh3dwoffvm+rdvT/7jnz/5f//Hz/7X//1Xf/mX +r8/26+WcYKgSz+dJwiexrMY7dd+ZtJ2NUWGtX8obUi2X1UQVSaJ4Csmq6qhdnc26J0e7337/fX88 +JUgqlSShAUsLgFeimRnz/z9J7/kkyXmde/4DV8RMm/Ims9J7bysrs7x33VXV1dXe97ge72cwmIEh +AMIKIOhA0IveSBSNSInmrkRR4hVFUiRXFGVWV1q5jdVqIzbu3dhve3IUUTExwFR3Zb7vOc/5PVmZ +57CV8NLcqTkexyuOM6jXmuU8mcsSWSyXwRRBXW7VHty5sTIZu4575sx2tVoicAZBaEUpCEIByI0D +XcqBEPDwqrmFTrkOhbDhSk2TuLRTv31htjEoLpfVk1nptacPP/DShc9+6Nbbr1x64cG53Vm3kndo +BMPSJJKkWdxWpapAKQJOGRzZ9YXVljFtmTvLzq2d/EuX6h97fuvLb5/89gcv/vVPfucXP/7KR185 +uX52Nuk1LFGhUBrPMkiG41lPYlw6i4GpbprKUmC2HWGjYx+ulLaXKyc7y88/efbBjc2XHx2889q1 +D7z84MHVK5N2p1rImzJHZLNAX0iKi0cICKd4hAJFnT8Vjy2mc0kcS2ZNlq472qRT8TXJ5ul+xe9W +yyWrULbLdI6fOx2HhEWSJMCWQWbzdGLootfXjNdu9J672nv57vgLH77x9U8/9dn3H3/u1cmvvvvc +P/z8k3/4tZc++b4bl/Yn9UIB7EM6nkbiUQFJ1KTcehHfKKcP2rl7O+bDi/U756p3z1afuTp4+fbw +g8/NPvzi9POvb/zVH731dz//1Lc+c/2FS6WmTWQTyWQc5WlNoBUGxTU8M3Fy10bc3XXpzeuVL7yx ++4n3TD/6/NLn31z/828/+w+/+NSff/PBT3/v7n//s/f+j//48R99/YV3Xtx98qTXCDw6B9kqeIpV +d9WlsngwNK6t2Vs1fKdNTcr0wcg9nvpnp97Dk86n3zz/61/+3k9/9rUvfe49b75w9uq5VUOmU/EE +kiKxnLK4mJ47tZCLx3wRrci5ho75QsIXU9OasjNw9sf21XX7o6+e++ib19564fxvf/zen3z/kx96 +78NBy93ZmG7vXDq88IJhtch00uWwooSPXPL6qv76rf5LV5s3VuW37nX+/Luv//j7b33mld0vvjr7 +5Q/e+Ne/+8o///qzf/LlG//00zf+9Ov3b+15eQ7BU2FPQhZTmBwpY6mikN6pUy+eD77zmWs//t6r +v/eZ2596afy1D2z84Ms3fv2nb/7pV+/+8AuX/unn7/2bHzz87Evtl67VLm9V657R8KFWFh2jorJC +Sc5NCthRi3/2yH/nmbX33mq9ebv2+5+7/fMfvv3Pf/+tX/35J3/6nXf/+9989P/7f//qr3/2uTfv +dL/50Qs/+f4rn3z9XNXR0jEMiizYWJHRiUyGhpKPxC065VDR7TrzYL/45GH16pp1d9d94/7oD377 +xS+8/9IX3n7ynd98WPMKGCqAAmsk3Ta4jRJ50mee39c/9+6l73z82rc/fvVHv/Ps3//J2//j3/7o +Vz/+2A+/fOOv/uuL//zL3/raJ+5e3KhWwUFyimf6Ck07LLZkk/t17PaUeXZHf//V4FsfOvjR1579 +3mdvfv2dM3/8xRt//8e/+e9/+el/+cVHf/69Z3/53Qc///1HH3y02fXCIggQkkmiZJbwFbNjansl +9q0LxsfvB595uv7tD2394hu3/s9ff/hvf/zeP/zi1Z9/6+4//NnLf/uDd//wc+d/9IWzP/3Gtf/6 +mQtPX6gOqwU0heNZlkOpo5XW2XHhqK8+fWB95fXpD7945Zsf2v7623u/+pO3fvrd9/zBb13+/ifO +/sfffu5//scP/uEv3v7Vdx79H3/9zne/cONkFWIhGV2MZFMYaLvLC5s1aeJkx2biwSr76gX3PRfc +991rfOHNze995sI33tn70def+re/+8ov//CNX//wvf/6N1/80288d2O/vTWb1htjAterbqGXV6cB +c9Ihn1xlP//C8Ce/e+cX33rqO588+62PnfnR7z74l19+/CffevTdT579b1+99b//7IM//9q9b7za +/vyzlRsrEqiKyorxxfT8ExEinijy6Y0AuTUWnj5w3rzd/PRLG3/2e+/+x7/40P/2o9f/+gev/vUP +X/vxV+/8+EuX//BjG7/1dP3JTW0loEsqGbYTFSyetn27Me0NjyaljSq3U8bvz9jPvLj0B5+88IMv +3fjDL17682/f//WPXvubP3vzJ7/34CdfOv8333/yn376yq++/9Q3PzD5xH3/jRutQcnEsrws1gTO +MyV9qWoPPHrFJ2/O9BfP6G9csj9yvwqr8Zf/y7t/+u37P/7anf/rH3/n//6X3//WR85++1O33nzu +jEhyJCoEilqS6KqETjzioEHdXVXfut76xgePv/epa3/y+Vv/9vNP/M9//5O//eHrP/zclc+9un9x +u14yOJGkaVy2tLKjlT3VL4h8Q8V269KdjfILF+q/eSX4/seO/9fvvPjrH378y+89/NKrk+9+ZO9H +X7n1tXfOvXyzc32nuVRv2ZBTcoUhbfBiAm3UnHI379UVarVAX191b627D3fdTz3q/+CzV3/27Re/ +95mb3/rI+S++dvj2vdEHr3WeP1M6M9aHFclRODTLKXzds3oqI7dco2GwbZ3abcovX2x+/f27f/y5 +i3/x7Qe/+N4Lv/6j3/zHn370z373/o+/fPmf/uy1f/3JWz/7yvlvvVl/41pppyXzWCabwl2jVfPH +lui6HDW06ZGR2/XSz2yKH7hTfedB+3fe3P23X338n375zq9+8J7//tP3/etff+ZH33j6a28fffq1 +7YOVwNUtgXXhdHq1JVsUSwpzdsmbBfhOEbm2xL50tvj2k+M3bg5ePFf97HOTn33z0Y+++vQ3P3j8 +5VfWPvLk5P5msNuEmoortMQSBpBMdB7hMU7BMj6TXslT55bca+u1yyulp/brv3m9885TKx99Zuud +Z7ZuTqxbY+PGxNlt5QNJ0RlBpkVgflUMZL5oKlVLLnSLpbajtQzhqOvdWqvcWXXfeXLwjQ9u/8U3 +rv/jn7/xp1++8zuvr//Oy+P3n7iv7hlvnq+eaSsuleFzhCaXHXvMUB7YQBplRDRbYJCBSZ5pizfH +7Ctn7fdfK33p5cmv//iV/+ffvvoPP3vfL7778lfff/3+bnutUTAkA80ZRE4gM1kuvK+LqhvCwOXX +yvJRz7yzXX5wUH3lcvu33zj83Q9f+egLG+8+6Wx0LInDkFQyGcsiWankj/vdw6I31nnLpJkl3765 +N314eWtWpu6uGe+9tfSVDz357isrTx02njvfujTzpjWjbApgcHjaDdsV5lyaKYGRBwdd9vsFPa/i +hMsyTUtrOXIvLx4O8ne2Go+Oh08etK+uVzebwUYlgG0sG5JIkxhKZzJcKiVydInBdTSJYMk0j6Au +y61Wy+cmjTubheePC194Zfa937r41ffu/uAL937w2Tvf+fCZb79v/6uvbH364eDBtuVLKJh2hTfC +1sdUgSHdDBgihO3kg3HRq/CZaT53ZaTdW7ef2XO//faZf/nLT//jLz/x377+9Hc+eeuDjzYenm/t +jzzwxrpadt1llvE41iFyosZbo2q3qvItkxnkxZbG9i1pverOisZ2ib+3WXzhZOX2Rn3i8l1DKcuq +yYgsxqeTQizCLswBAZKGFEg4LSCIiuEVw2j7Xs/3B55b1/iKxDY0sefKBTYHLFgUlWF9pPAeuBIC +SB5TqpUxTdrZFMA2TWQZndXahcb+6tHu0mzoqAcN45mDxoWu8uR27fqsfLalnWvrezVjp2r3DBEB +LIggGKILXBPPgQ3MgtOML6SodLiwNVUaukpTwdZL/FFTerDpfuTR6iee23792vj6tF3meRljHb3m +V7aWZnd5xjeUokBrPAkLYliyofOKLevDer0T2M283MxLvsY5qmipOs8pBKWAVY9G8VxOV9QKy3uJ +FIsiiszlbcWtFmrNUptFkEDkBr7bKYKmORojqYwIhiKXYcFJIRk+EadjMRongmJlr1zfC28h06oC +a3G4aCs+nYMyzVqCs9rb2hztTjqzwMgbnGRJBTe0MPT8QjyZYnNEwAk9RemaWoenrehCIr6YBF9v +yV5e8z3NqTvmsGLvLfl39uonE/fWVvXu3vB4UF6rmNOS23UdLJ2bn49l0uGz7dEYMQ== + + + N58Gv8mwtUp5u9vca5ZGGst5Etlz+KZKNhTs4qj81lMn73v39XtnNvd77bKmKDRF4zQveDjuYriT +TMumO+mPb/QG12rBmsbZ+2t7T919lsMl2C+R1ApauVFod8u9qlPVGB1LMHhGi4MtnUMhqBA0n05b +6ZSOY3lFLKEJjMpArafiUTy8/JVm0axE5AyOyvO0R2NSJp4lMiyaEtCMKIbfWNkcHWjhwywrmYwK +tjed5GjM4inHMTu6OoDEYXOCzqrLtQ6RzPpKoeK2XcnlUY7DVJbQk2Gn8QyOuSxdSsTYd/2XyKl3 +RcBv0pjmqnlPD1iMY1DKYOSCrIfP4pI5hyUcjvNEKy+W0lEyETaEGTWHlz1/1XZWRtOL+aBLkDLD +5k2rX28dleo7LOdQpGIqhZXxVjyFLyxm40lBVAeWt2Y6q2LYWausSNXp7KJq9+IZnaDDhzJIuphF +TBKzOdJMJ4iF+VQ6IdBEQZY6LFsDmcphDoKYslgBLEkkpUQqHHVEUr5pdd38wDSagT+Qwls+wi/a +CMKFfxLltqJ2NKNj55ctt6/Igao1cCrI5qwcZiOoTVA+QXiZjELgBse5ul5TlJKut4NgxSsMbbPJ +EZLMKRZsrFyKxbKZFIljlqaN3NIRwVYSSXZhAZ2bz0JgEFRNM0fhA4kJJh5nSNLj6QKFchRCmYLZ +rIIuWRiukVReeNwrD8PDhufws1HIFNxS1VateSTInUzWzWa1HGZ6halfXItH2UwKltdT1IZuDXN4 +IZ0xUNSWpa4ktVNJORblGabRaJ+z3KmqL+FUMRqDyBE03tflADwaL7Xy5a1ia78dTqRdfzxtXGWZ +/NLoghh2L7ccdxqUdiv140LlIJYy5hbp+UUym7USMe6Jd0Uji7iqLxdb5yqtM5Y7g+idP40gaSUZ +l554IrO4SFBM2bBX/dKx5cwyiJNI6YuR8GspgfUgmBfCq2SxxXkknWApwjbVliYG8QiSjmN0TqFx +nYLtzijhI0sZDSUK2Vz+id+IOcVtWqyKcvHs8d3R2gnBBZzSoLiyrDc1s+u4o9Ha1QyuZnMqJ1bs +YETyFZTwc2RRMceD5at3nv5wY3C4EGPTKOjEtlc5L5szmqujOTOVEUnKlZQ2xBtGeDhVVowVy9sA +RdT0nizX01kDyTk5wmGFpuFOCuU11eyTdJD3Jo32oaw0DLPHSQ3ZGlV6F4PWWa+yY3kTSalPNu7J +Wh/FDNVscFLdyE8ErUdwdYqv2950eXrt8MIzJBtE4kw6q3FiM7zBjy0zYvgIj2t1x5MT3V7S7AGv +DQm2RfN9WZulsyA7hSwa3hOYTLO5nKqqTUWfMmwrk5KyaUlTO+LjJxoUY1huHVbaZ1lpwEr9HBkg +mMNLDYar5HKmJNayqJVK6SRT5OQWyTVjaXNhkWVYP4uIsVjYSBYjCqLc44SmILZIuszyDVHumM4k +kVTQnIeRFYptYmSJFVokU16MUJFFyjCGotxIZYQMojJSk5batNDSnbGshbdl4mSeYKrxtJFCHYyp +5atHWn7DLe87wd78AhOLCbzQkNUmkrMxHHI/yCI+iDNJlRDEjkZZmqu63szNr+awfDh7NGNycl/S +xpbZw1AVwvLUqUwsQqUTXDaj4ISfCZ//tREEIspNREiQNYZy7fyK6a1p7qrirFJcY36O5NUlXukG +pdmNW6/2xkcIaRFcEWd8N1h1ixthxzBrSQhvtlnzSisZXItlxBRic1K/N77dmz1ZH15m5DqKm6La +M/IbhrdFCV2MqcL62/lpUNk2vRWQlwxiqubYr544waGojSi2ghE+HICsL2Gkg6C6qHYgKiqt42bv +Qq19xi9vl8qb5y4/L5k9Vu3Ul6+uHT23e/Li5pnnGkuX+is3dX1QKa4cnDzKEjbBBhBaRmG73L7Q +n97pTm6X28cE4wtKQzWHgtyj+TrEp2SPZWOwvn7j3NVXFaO3EKMymFOo7DeHNyutG6y4jBJlBC9g +dPD4XjgVzanRcAqzHvb+JQs0W0Nx3/FmXmmT5PIYnYdN5LWx6oYTlu1gA2IsmzVWppdtdwznG0sK +IImM2GGloWLNeKWN4SaKyJbZNexlkGI0BwLoadZKobxfrB2WqvuJpKpoS6oxldQRfFYWLySy9kJM +RLCCV9xh+HrY354q8EpHsSeyNeWVXhoxILCN/CoOVSPshNYn+YYdbIv6suGt8/ooixVUa8Wv7MVT +EJY6hBbNtGR1ZOVX4YxyWCGHeYazAoUYIjAa4xDUUI1hsXbASYOwZ0uMhaNKZx1QtrlT8VOnkqcX +6AxWVI2xlZ8JcjcZF9IpWZZbAqQw7sErbJ5JBro5FtVRs3Oh0T22vDHFB4LacooznPNFtSkbSxCE +sjEMKhu98QUjv5RCNdkakGwVp0qMWM+Q5RzTw+jmf97Dn8nZOdJXnRU72OpP7+5ffHO8/ShHl3A8 +X/On+/t3sqSXRPMZ1CeZtu6sV3qXKsPLqjMMB6vVNnito9pDSe9Jel+xR0F9v1DZYOWqE4wv3n3j +8Prz/dnlcuesUdiCmIQTWRqeOTx5BlZM1jvNwaX26M5w48nW+KqaX8XYulda3z5+ttE7m85YQWl7 +/9yza3v3xxv3zlx91fQ3QMQgfiSty8s1jHIorrJ58Pz63nv6s2eC1glJVQi6oJpN2R4sxIRkSgXt +Mqwty9stVI4qrSOcNlWr69ePnOI+6EN/9c7q3qNK+4zlrQNoafYIJVxZbyvW2CrMoC4o9noKDR92 +c/OTzZ27LFdKZ2GX85a7Uu3BCqxL9hot9FIZq9U+U/BnsZSaIytZtEDQNdvfL9TPK/ZGFiuWK+vX +br6YDTv7cZG4DMIlgoR2zh9ef78o9+8/+fqXf/f7zc7+YkxKZm3ZmvS27q+df89w8ynL30wjVqW5 +B6kRT6gLizTOlFESdHVQ717JFw+SCR3JGrLSgpyKxUnQroWYFM8YAoRQcFAf3njiNBqJ4BhuZXNu +FslDTGJEMZ3NI3jRKmwVG8dQoBMpORvySZFkqn7tDEGVKXBYQgPERHNmvdHtteN381rdK65Uu4ft +4dne+HypsW24Q1hMxer1pldh18KxuWrPDXZbw5ut5ZuOvwWnmUR1nPVBpqDCslJbMiGzNhhxaObX +R2u3h6sX8fDe45npTVV7wisDLb9mlzY1u7+zd+v8tRetwpgIu8pXgYQHqzdmZ1+wy7t5f7S1denD +H//twexslspz6lJjcHVp7cF052FzeIZkvFiSZ4QqzVcxJk/LtSxVkMyl6c6jvfOvdkbXJHMZSudg +5aag9QmuqjprncnNfGVftaagV155fTGGpVGmUBkVG1Pbn6BUheS6ujUr1ffPXnzu/JXnF2NsMq2I +0mA8fWr73Gtu9SIrD3mh/vJvfr7VPcqiDqji1tHTL7/vcy9/8Av7V1/WC+tAC6a1/M5HvuoUViJx +KUdUjPxOpXt9vPXM8aU3uqMbnFCZrl+ut7ZiKS6Lu5w68huXd86+Ptm8t7p1Vwkb5TXq3bPhJqKO +ao11b10yV1hpqdm7srZzDyMCQGWQaNWeKvZyeFMr2wRmO3Py6OFL74ham6DLXnHXK4EBnnHKgOFb +QCOC3O+v3CiU9xYiYiptWYXVQm2n0jnTHl0CXUrGwKVvrG7dAQBeiDBQ6y3/SLGnmjujxR7Jdhaj +YimYPP30W7bde9dvRKMRkmRKbnAw2nx0+f6HWoMLqbT+1DNve8FqBrUyQPfqJAfghAdwLvnS0WDl +4eU7Hz2++rpp9a6cPLU8PQvEZTpDr7jeXT43nF5ZWrte6h7IWrPV3e+ML1NcVTQ6ktWnhA4UVskc +28FmY3DCSnWgNUlfqnWv9VYfLe88ak5viEbX98ZnL70naKxDGNj+eqVzbuf4mdv333v7mXem23cL +werK9GS8esl0liutw6X125XOhfbwwu7x05fuvl5uz0aTc1u7D63CGid3aLlJckUgMV4eOsGuqA0M +qzvdvqrYfZQs2IV1KAqquybZ0+WNJ7fPvwQx6fgbfvN45/zTh9dfa0xugU9KYx6CuWZ+qbl8No0J +er7LKj1Rn1Q750qtY82dwFlEYgzNljVrSbHaor0s2VtmsOdVDoLqDk6F06wa7V3D7YtqxavMBps3 +y92DSvug3j1Xax3ilAfy6JV3vTLs8jRf3QaQNvx9y9tsDi46wSyNqL3lc6ONO2Zh3fHXZXOgOcus +2CqWtyCqBbnB8tWdw3uPXvnkyb03146f7k5uOoWpIJSuXHn2hVc/m0YdnA4KpfXRxt3ljbvD9ZuD +9TsAaQ8fvbWzc5Mg8ixf6q/d3Dh+Ybb37GD1ycnOC4I6isYVTmigmJMvbeYru3ZpS7SWAH7K7bPl +5snCopDD/GJtnxO7i1E8EqMWIiyGl2GdwQhY5jidVk7PZQBfRaXHhlHXZPh2KmuDlJ2//Fqpsgm8 +ilM+RAIUR5qtQ5kG4sqXtuu9s5DLklTd27xUa68RlGOY/SZI7vkXji+9NJhec0tTRW+szE5Gm7dT +AHVMXs8v17sXl2cPG0tXa/2TYnNfM/qNzr7pLtv+rNI7KfbOaYVVTuk0Wme3zrzoVtYIttAbX6m1 +j1Y3r12/89LOuae98pqud7Y3r8+2rklqs9bcuXn/zat333dw8aXt8y90JldMu3r39vM3br+CUSDC +IF9dzRlDDJTbJ6a/y4rdanXj4Xve9msznPYrzSO7uOtWj7urt688+NDOuef9YOvStZfXjx4IZqfQ +PND9Pd6Y2sWDcvtyb+WObC6rWu3hcx8ATcjieZwu0WKXkfuCPuDERrN9tr90cvb8nfW9W4w0EPUR +CHKW8DEmsAqTtYOHoWxyhXJjqz48W2rtd0aX/PoBRtUIplLrnys2D1DCE/VOqXOmsXS9sXxreePZ +5tJ1Mz+TlNb9R29evfOKbPQArhi+CQahO7pSrB+4/goQLC9Wtvfv7R7dK1Znlj+GaC8U15rd3as3 +Xzk+9zT4BcNanm3f2bnwvNc4kJwVyV4BfL115+Vmcw1FVFVvd0YXmoMzfmkN0k0wVpKIF42rqtbF +CHeydfvC/Q9sXHy5snS5Njyp9C6I+iwa14FjV9eui1IrlwPz7mQRlwbmMVYEqY+i3sICiaCWrAxA +lBYifDrjivJIVMZO4cArH4AvS6RlSCicLIJr4Pha2EA+q8IKUHxNdyZ+ZSfMDi0kT1muKlqvUF6H +ZFTNAeCxpHRKjSPNmy5A8SUdCK3+5Hp/clvLr1BCNYnoolBdHl/Wza4glkHo1o+fgfXfv/DS3oXX +lrbuy84Qp73x+g2GB6TxwpTX+7q1VK1v11r7kt6mmbznDYJSv9ndKDY27WAmAIbp1Wp93SksQxER +pNbjuRVujnF0b5Iv7/mhjGwXqisYaRlm6+7DD56//Wa+tu/X9sKHpt2hprX29m7tHN4HpQXOby3f +LbZO6qO7oCEMsGhGLQeTa7debPb35hZxkq2BvFQHl7zqHqR2sbS2NDj8+Ee+8Mb7Pg== + + + nc55CBGw4sApHqwdvXDy5McmBy9Iav/KlUef+vw32/1D8Gi8PuM0QOi1wezJ/evvg13L4U4ebFGw +yggQb2WSq1JsVVL6pcfqdO7yo1JtfXPrhutNRa0HXgMlgiRiZsBvqv3O4LJhLxnOslmYckprsnp9 +Y+9BUN2nuXBwUqO1F5RWWdg1f6cM7No/8RvHijmCLQabUKrvUkzlselTQAxVd6vYvhI0z7Fik2KC +weTMzvn7stVdhDdkdVbq1HqX4EeC0oZpDsL+YLRZqmwQZCkeVxYiAtTERNIkyHK1fr7TvyWrg0Zr +t9Y4xHJuJq0B6kcTKkSaoo8L5UOCrKj2smz2IO8gBVixDoguqAPFXsHZOkIUSNZX9FYG1SWtVW4f ++NXdfLDdXb7dWbnLGf0MZhRqm1Zxls6ZFFcDmyaAm+ueM+0VeJugtHHC7i6d704uFpu7hjcVzB7O +F0mhVqzvVTtnQBzAoStGX9UH5epGvb2TL60msyovBF5xTHKWJPm61bfy00YfrOUmOCNGbCA5VzUn +kjFMo5Ji1oLmdn/l8vrBM5PtBylEQcJb8Zvj9Su0VAfrFDYGl3rd0YXB9Hx/ciKIdZ6vayb4r0Ik +zkAW+JWtw/PvBsZw/TUsbE7IRBMc+GiGL8aTDOiGXRg1muuDwe7JxacqtVUE80x30/Z2TXcmm0tg +GUDf3MLabPPm7tGTGFVAiWK+crYxvu83L5jequVv0GLY8P/g+GG7twdmGcF9mm82exf3zr1nZeNW +dwilc6vX3/vIR740nV1HqVqhcVwdXq70LzRHl2HBCSrYWD353d//0XOvfRxgFbynYq361TPN4dVy +68j2VkxrcOH809fuvMlKTRBSgm8I6tDKr0n6mOI6OFkOgsnq1lVGrGF0PUfVUlknmdJFudHsHWwc +3CXovCDUVK2X99dm2/fWt24yfCOR0qIx3tD7W9v3OL4+P09Ho6IoD4Yrt6vNc5I2woial5986MOf +vXb9ubk5FHxBOlem2G6xtF8u71nWWOCKcPqsVMPIPIbbhjNkhaagjwi+DZhdqp/zy0eFyg6sOZCn +W1yVw4b8PZKrEWyNU3ql+sFs/5FZWIkmWDgeUeuzcrPU2oOzgGpL0H7Y6q1zLGotkCnHXwtaR63R +9cnOM+dvvtFfvYYzgajWw3BKK7mcC86CFdoEUwfshBDFaCfv9cBnpRADKBQWJI1a8BFWYVOxVxmp +yUuVMxeeUs0OK1QgT8EUQITzQrXePNg5/xwajtgrqXqfFxoAb8X6Rr48Q3HncWPnLka6qbQkKA3P +X14aHTreUiTKL0SFZMYk2Kqdn1KUw7GWYXeqne21nZvT3Tul1jaCmUApujV+3B2Cg7wAVJ5u3t89 +/6qa304jfjQmFworXmkti1sQouDlUxmbYtumt2WXdiFrcpg1Wr0CiIiFV4ODHO6BAtebR93h1Vrr +Yjbno3ixUD0A6Hp8VcFCMQvJhl3gTq6+uDy7RLOeYS83eucGK1e9ynaOKgIrAo8tj04azd0cbqtW +3y5uQyau7j4stc6l0UIioeTd5dHqRYotMmxDNpZ1d42TBoXi5mB81S9tEIS7u319MjriWA9BNZwu +WIXpdPfe+sEjkq4iqJPOGDRZoohiMqkiiJVMw3vCiVem3SsVlxnaj8clzZqUGidZxE7G+ViEQjOq +wHic1GXFDsHUQKK90qpujartC1I4yGalv3IH7JiRX00jOoLovFCBHTHzE1Ff0uxZB5hh/d5wdlMy +B9E4K0hNgiliTFG0hwRXzkKdFerF6latd5YVK6rR7o4u5StbdnHNKc+C1iYUMggtSe+Ci0lldF7s +gkVVwyc1+hhVBuCBaO/2D8GcopRPiy0ECwAIVQOM6ghOjRGbcISTrbtZzBHE6mB8sd49D5hh2JOg +vF3rHoNDl5SGqnVA2DG8IBtLqgtKWM2RLsnmSSbvuktOfphMM4kUHUtyixEWxUvguZzSNsuVBdpe +nxytb15BCQtSj1XalNgU1a6qLwlSO5WWVa0eVFat/NALxpozQslaIgWu3Gu2z9j+SiLNY7hBEH4q +bbJcC5aLCAcvKjxfPnfxGZz05uexdFrLEQXdWp5uPJhsPNScrblFPp7SYDviSfFxCxoVJ/ICXzX0 +oV/aVq1lWakXK1OW93DKhDQhmKpqLHvBuulOwU6iOaNa36x3j2E3ZWvMaUvxtIXhRVkewNswzJWE +2mDlYnflCkFXgYVIugK2LptW93euj5f3Bd5TtKpfmjR6e+PN60BoiZS+sMjEEwpH1wS2NneajMUk +TmqDlnZHl01njCBmNMrjhB9UdkxncnoOXVwIOwTCARvGwHTX6r3rTumcXdzjpApGGLxU5IQypKSg +9xkR1KOewUtwvrCk2awcVDaLtSO/dAh4AxUQpYJ0Lg+OlaK9HG5BdWsvX+2t3DTz67K2ZBdWBbUl +KtVO77A/voTR+Rzl5ug8uMWzV1+6/uD9K3tPgVvPogaYUNC0HBUkUmo2F4B2Od7auYvvHs9OHH8y +2bhOc/U0YkHAAIfwcs/Mw2FfGm48JJmqwAftzpbrLdEcwBtEtcNJHd2cmvaE4cqLUZqBYq30FHB5 +9giqfCKrYkS+0TyAUrKwkF1YSMeTHBhwlChhbA2lirCtNOn6+ZGmt2JJQdKXNWcNzEK+vJsjC4mk +AqHV6+0WqxMkJ0PRTCE2QdfzAUDdBmxrLClF45zjLrFcZTHCJdMGRtUFZVypn+v0r1Qah1A+SLLQ +7R/Z+aWwE3hGTWdNim8q5pQWOxRfT6X4yfhCs7WL5CwwXCjmQQzE4qIgNvLeJB42YMSIsBdQhYJT +ZopZLB9LhYN+/OKaX1zPIuZ4/eb5O+8tdY5hoRiuAVEajdI0aTlOF2I+k9EppiYqS15xW5Sb4TNx +GZHn/bXNS+XyMsfaolrLYgVO6nnFLVHqUWQ5EvYP4cqV9c7gCNQ4mZSjUW5+nsKxwC1s2Pk1FLVT +SQFymeOreM5NxEVIbcXocCGZ5KGs02wVyB/NublcXoFMtyeqHRIpLQ5JoK+cCRKEkwXANooqcUJH +d8HAntOcaRbXE2kGp8CztCS5Gk6OUwfgEN3iFpjBweptTuknM4ogVUHKmv0zO8cP9s8/DBrbjNzs +jM5Pdu/Y5c1IkmfYul86krWh4Uxls68Y7bw3Xl69jmJuIila3mq5c6UxuKyYE1bqYVQFxV0mnNNU +wTCVwB1ZW/aKu5P1u/3RVbAGkNrROM/yLTBfrNjoji8NZvehPKnmCMQthwfJlIpidjZnpDOqU9jo +TG60J1d609tB6yRH18HaQK0cTq7ahRlIhGiMOLmvmiuPZ5pA4jvl0vjGnZfg79GkQrINRmiDD8oH +u4XyWVkfAa7gRFE3JrzY46We4azBGyJxbm4uHNrV6h5xUhWFZEEdDPMkuU2xlQwESVJGUW22cbHS +WMugmmYtVdrn8sUtzVhhuG40Ls3N5RYjpCTWFhYwmvH9yuZgevP285/dOPNuy1sB3cCyYm9w5HgA +81C/wmYjcHZZxOCBZIhCNMaEDXnCfuNmNCbNzROxhAj/StMFWQoYSpHlgihXoPAlU2FP71OnMk88 +kYzHeJoM52GlM3wiSZN0IZkyMmkXzIisgnMsRBYZhnIZ2onH8Mg8Hl1kGQ5qaPi8Ko57sjqy89uc +PMxiXgaxObFNshUE90CyJHXJL+0XG2e1/CSZ1ecXKASxcRL8coniw04++dKGpPco1sukyWyKIAhN +VhvgK1vhdzTPLG3cRakK1E2S0gytZBig5MBmTTDdg8n1C3fe6q5fZ40BwIOqdyWlmsMMXu52lq5c +u/P25VsfHqw+ChuFZVXbWVLMZZIpQ+yJ6jKvjGvtS25hGyMK2Yyg6yBWQ0GuwytHBJGYlMzogj5s +Da84/gYv11uDo3xpDcHzoGwYWdKsaaV9sVA9hIXStOrumaeHazdxrswoXdGeMspA0PrLs2uNziHN +Bq47bC2dl/SRbm9IxpSV2qrRqzd3RyuXmPDJvnJQ2S3V9wvlDVgNnK4ACUeiLE2VNaWTSrHg13Kg +imTZ9tZZrq1qy4LUTaZNz1+XlW4iIaG5PMU19fyGXz+uts/TXBm0FA5sMLkkAnmGnQ+b8ZQNZ5TJ +6gThcawfWcRkqVrwl3Wz7QVrYH7DgRRxWpUqpt4FmMxmTZBuUe6xXD2HgQVwoO5HIpSm9zi+FYnw +kFyAHzQXzh3DCD+RYGJRxLbbfnGWTOv/Jez1x6RSoHh8NmOlIdLiwmIEr9bXVtauQrk/dRqHNwBr +UWSFxP10UoJffvp0JpWUM2mToIOFhdzjr01VKL4k26aFLiA6JXRlcwq+L56WeKnterP+8Opw9YFR +3EiiViylk3Q9nQ2bu1KM1+ycObz8en/1gagP4gmCwkSaMhgWYrKoWgMrWFdcqIzLnNhgWJumFJKQ +Gc6T9Y6sd4PKFhhGPViT8lPFnuj2kGJAMw0wy351fffwqZ3j58xgP5N1aKrA8WUUM4GB3cKmbq2q +5syrHEnaJIOA/5V1NZznFYvjCKryYiebdSm6Yvlrlhf2fOaFYqOzTXNF8MKQNZI6bA6uVHqXZWsF +9l1RKrX2nmr1UogmW5PB7Nbm8XMgX53RVUFugcdpNcDDbqeyFi8t1buXd4+fPnflpdn+U4XqDoro +hfxg9+BerbGdQdRwLF1KwYhAM4Y8W6OJfCJOOk6/v3yRlzsUC3IB62axfIeg6nAWsKcALc3mUXtw +Ihsj8HcEXYmHEygEjqu2e0c4BStZh3iTzBWcCYUaID/slh8hOSYvcHmWdcvVTc0e4VQAGsjxUAG1 ++QUinTER1I6BeOKeJHVptok/7kaoad0c5sfiEM/wq0yIojTiwIdSbInlA89fzRfWYUl/44l0PKHC +yi9G+FhcTaNuJgeuoQ5GybKXoapmUjqG+dmMDX/GwnEeTFgFcq5mLCGIE8sYT8yh0SgFQcLyFZDx +Uu3o+OLrx5c/sLLzgultJFIyzZUUQCa5KWjLvLEiW2ul5pX+5Klw3hCq6GZDszpucYOSlyJZbzGm +2vqo2z7rl9ZRTKMYh+arijFahipT3Ull+VgSh7qpmADk4YgiCGlJqjb7R73ZDdEe42w1m8vDaQIv +5QjTtju2N7aLO7DmUBOTKdg1gWFDwaHYeiar0WzFDfbzpTOCskIxxWgMn5tPITldkPrxRNjtlmGr +sMXhvBJ7YJpdgiogqAlBDrtD83VBXfLKh9X2RUmfhVKTFkDtd/efgjDj5CpGF9M5P4v5NFcLKoD3 +ATjfStjB70pv+ajZPRD1XhpzgSUsa6la2dD0djRGA6oBuWFEheYbAEhz8+RihDaNbquzl0XUsKdB +Vhfk7mj11mTtAQBPNCbQdHBw5ikQQJBTkqkxXNvKr9mFNTW8QuXGYqxhD/3KOkq6cxE6mbEwqgYE +KIg9ErdZ0taV6mzzqu6Mkll7bpHD6Wom5yN4yfG3QyhaxE2tXavuP26PI54+nZufxw== + + + kZxH0mUk5ywu0pBZtrdSbh5XWudZoUGQJQg2KPEgszTbSSQNlqnp3maheaRYo/A+oowejwkQSDxd +L/rTaBQPv7Y+lSPxMkkGWTB9qA4kBoUjFd7cYoHmc0KpVNvuDM90ls/2xiduaQbVn6RK0n8+iS+U +a+2z0+1nB9N7tf4VIBbghLChh+jnSFvWl60CgP2m7hw129d6g6uWu5LKivAGUQXz6OGhNavkiLxq +9Df3nj2+/BbUlFg4q1HkxSIJXlXuaN46zjbKzZP28k1G6IBV73a3PX+UydkpsL0ZC7w5wzQb7Yu1 +7lWKbQIJZBGFF1ogXKFHy+hZ1Abo9cvbK9tPITkfxzxeaADqk2wNPBTwA83WeCFsABhL0JBcYDd6 +yyfbZ5+j+M5ClIsleJotWPYSxMDj+zEGELTbZ15e33+WDWfr0ECSteZ2rbkF6OsW1jVnwy2fAdok +mQYk7MIiEc5PUbvRKLO4SGVRN0dWVGvdr5z8541GsRiVzUqiWAJiQXNqDncA4HmuzfNdSIHwThXU +5sEO55wc5kJ+QYTEUyZNe3l/WZCrAFcCVykU1ovVAyjxaM5DsiqR02WppCgBhskCX4QID0prxeqe +oAwwqjo3T8djFInpFOGAgKA5myCLqjbUzHEO86A+njqF8Fyp3tikaXdhkYQaF09ZjDLON641lq/o +Zj+dZHy31xkcg1v8jXdlFyJcNKljdEs0Nmx3O5UA9ssqcn06vTF3OveuJ1KLixzJNE1vDUEtyGKM +cCgmUPS2brTAgYqyj4ejMRQMs2177Je3FKNHMQVF7zj+iBFKcO6wkhgeprOgdgjWF5Wu4axK+opk +zIA2gRwgHiDLZGNoF7ZAgoCW7cJUkMNhtV5pjdf60bQWTYgE6dv5saS0vcJGvX+VkaEWtxAyiKdB +gW2Sr+FMOZqAotyXtBWgApwow+KA7QKUgtiGiAW6iMeZDKpnEEvVJoK0JCoDnK4lkhpFlxDMiyZV +nGlAoVfMVXBwEGPhlJkoBiHEckUQXoL2abHPygPJmDil7VhKmgtnIIpgalAcnH4gKH0IdUFqNrtn +/PKOpHUJ3AY7BgAPviyRNhdjQjpjgDzK2gr4/cVFIh6j40khnbUYvquaa9G4msroKOYQ4fWEYiJO +ZdI82CKgRF7qgCECuAVJQbECOA6wD8ClOFVV9Em1dRnWH9jj8RgvfnV8Ui5OcqiaSkogj1jOxB+/ +4tEcjQnL3fUPffC3ZKkYT4jxhJzM2LwMIeSjSNiGIpmkDKsvCNVEQoSjjcUAzCSAKJoOh2In4jRY +PJKqsWKPlQY5oh6J0GH/tDgt8j7LlZ44jUZjouHMFGfVK+/KxnQxqrzrCRSYjWPDKySJhOC4I82c +guqm0qHtgmyiGU8Qa05+woClJaF06v/ZOQHHLFlpG9bILUxBbUS5LqplFNfj4fg8jqYr4fgYuUlz +BSAuPhzR25KMUQ4Lwj48UtfMz5Y37q3sPGMH27D1nFiBTUQg5DA7g+azeInhO6YzdYNVReta9kg1 +xynUwpkqAlIsdC1/X3HWoWYBmdBsnRXCm/rCeyCTGlibLFJQwlu/yvNz2VgE5wUgZ4VmWihWjsbh +CA2MKEJAZnIB/AivLNNCn5OXElnz1AJxehGPJ3mWLedQncB0yE3JGGvOKqcuoVQplhJTWQ0DVOZr +UL8ggHVr6pWP8v726sYDL9gA3pO4ANIQpC+csgrFhWk63ubS5LaorqQzTiTCpNNKMiVHHt+WzApd +imtp1qpmwb+qCwtEMiniZB4jvVhSymJ5sLpgMGVtbOc3wIrOR8Ie8hgekHRR0cEsr0bDkaYST5WK +hRWGcmC7k3Eu7N6c4KMROhrhMinRkMsVf9RuzuKxsBFWOF+D8MEyw3ItLoI6JbNZxfU3YDcXFwiS +8EEZwMCSVDGTsebm0NOnkhRhs1wzlTHjcTkJOJFUkmAew5luJoTiwgLDMpVm+wCEKJmS4D/nF3gE +LVB0HfZiYYEN/OXnX/mY541PncqdPs3jVAlBjVSaD7vQ4OHTEATuQlQnkuAZbZLME6TLCUVFawpS +naJ9IxxYuQZIFl5yCTt4WDncziByOiNhmElQ4b0EGcQkyLyqD/zqbqW179c2BbVF0LD+hWRajicE +sMMUVcbJGs0DTg8gPHCqEM4sy4RXESutS3Zwxioca84uzcMP+hjmkLQPRRz+4np7ur0tysvwAi+f +zCgL8xiSVmQR8FiRlWXd2KDZHuibbq9q5loacXkugJxCcnkECygegq2C0w3TnpnWahqiETen03Os +UAH8oIUByYeT63V7wEv1LAoujxKlpu2uouH0cwiGYiIFPoiAuoYTZiLJEqQNxQ4n4XTKEMMLESEa +U3CiYphTyDugrERCzmEFWBacquRwKHDCYlQg6LpfOXT9dZLyLl1/cXP/SYJp5PASwdZTqBtJhN4W +J4NEqHsSZBzNdYEE0IwejTCnTiNzcyTH1kCLIITCW9TJqqmNDG1IUaVI2KmPiIcT94SFhWxkAQdV +QQk4vApoC8s3kyljbg7vdA4gT6FcgsVbWORSCZnCHV1twG941xPZJ06h2awFqhhZ5OfnyAi8IWVx +bEuRO1C15xewaJQGmgIqA9ZF0XwyqWcymu8N+/1DFHUXFyWGXwqNHuIkM2Yml08g5lyUXoDVSEoc +27DzK6ISmiNApkQ4C4YhSQuKl185Y3t7JFOnmSpBFWMJ6fR8bn6RSqWNHF4AmwyrgWJq2FmI9Ciu +TtBgb6sMX01kNfjlYHywnIsgkNQshltMOBG7abmTcDwNXYRDtbw11RoDIIX9z+WWbi+7hQ2CrUTC +IVwimKawSxLmQCqRBBifWj78Hm0IQR6LcXCCFLgkDAqlRzNlhqlCTTTNIc2UwnlkKcOvntWdLVFZ +NqwJQVWgPIlsUCiMEikRxfNWfkN31uGz4CxSWX0+SgCIElQVx33QGYCHRNJOpBxI1WhMXlikkinB +9ZZIJphbwGNxmZeXNRvgYWY4a2DHIo/bM2ZRBz56Mc4CEvNi3yisNfrhxRDgWEhny2jee/LN2cYl +8H050C6+TbANlPAlAAxrlE7rFOU6hUkkykeiLOQOgFCOrMvGhpnfXVggeSpY6p1DEQMCKZ4CwNDi +adsp7g0mN2S1PT+XIVAzh5iQzrDswN4AV6fnmQwSqNYayODCAp3NOHB2sKqwFCThhPeUIrbprgbV +w2iUT8QVeKFZWOchBHMmbQBuReMCeDrgqCeeyESjAoK6gtCC6sYwlXQYt8CZIsM2Myg4uB5ON+GF +0fV4xogn5fByNFMFLkLxAsO2VB0Mchn8BYY74E8luV+qHlv5zWyumMp4iVQ+iwSRmBxPaoATCOAE +VeSERnjDNlWA3w90Hd6ASniOv8lJXYDbDHxKHAKYwDAlLLu4xUpV1V6qto690h4efrlmg0KyTKFY +mjY7h25pJ0eV4P9LcosiPaAjgFKBDSjSYhkzHBmDGQCl4ZdNpIcgWizKQGU39L7AV0nSY/lajixl +sQCqMEYFcJCpjMKwRThO1VwCXGS4BgQAw1UUvZ/FwDKYwMD50r7hrUG0kEz78QhIkJECECZkEEgi +Jy7Bb8uRBVHrxVLKu96VAAE0rRWGq4EBjMRADSiQnfbgYmd4GYI2g2iuN4MjBCUk6EI0zgNUON5K +b3RxuvcQzDKcXbl2BigxjViJtAZxAuK2sMhSlK8a7fhjX/k4++ogv1kU6I5fXCQRiHyisLiAAd0l +sxZKAHK0NXuFeDxTG2wFC447Y4DCcDzQch/HawAMEOEME150iixS6aR+eg5JQkryDbe4Ywe7u+df +ufno037p4NQpHNQMXgvzFIAZ6FssBjBWKVX2K80jNryhmu8PTmSln05bkbgSSVlZvKDbS2tbt198 +48thh0PUyyAAq3XT2WL5LgQhJAsEUg734CxYFvB1GXIhlYHFr7FCjQrHqdTB7sWSBk41BXkqyiux +hB7edJHSMogOXCTKA9Ac0Aqar2VQO42EF9C80iYnw++HDYJiahIE5Av8RcnlNFYsK9agP7mh2SBQ +dUao47hDEybPugwLhSz87sYrblrONItYmYzCcxWW8VNpdnExCXSaSkuwKdXWWZCCZFqBdKPDh3H8 +VJIDGsHxvKj0bX9Hc2cgDrGEABsNoZVGVJItoUQQco4JgjNSjCG8Ibz7Qm7lS9tmfg0qFyQdoBQn +DMC7pdNQaBhB7BRKRxRXw+mAlTuLCeWJ09lMSub5SiLBxqJENILD53J8I6jsm87K43HMpl+e8iKQ +qkGDLuFlqPUADJOtOxtHT7sBRF19eXwFcgeCXNKXKK4J6YzjJbDzqbQIXpjjq6LUBoqDOAGKyyJ2 +Di9iRAAUdOpUamEBh8KxGOWjcTGDmmH6ZE0wAra3gWEe4LqijAmyjoabq8Xj3Nzp5NxcJpVQMDQA ++cWoolc5mB2+0J7cqnbPA1vGYuoTT0BZDB8NAOuXTqksV9XNcbl6BAYTqj84DqCy8fSGYY5icSWF +5Hlrozu9de2p9z/1/AcuXHomkdEQ1AGcA1/D8i0QGQiqx9NFu6zYwmmod8piTI6Gw+M8sMOQXHDM +YN9QwgPlRB5ft0+GpdCDmCSpEqBRGtHRnAs1ywhHbByQTCWR1gkqiKfERBoKZYkgmyTdgtzPEeUs +AgHm0eE32hYoG0bVSo0zpdYxZPrj89KA4tJZBXQmgxipDAhUhReHvNAF9QAfF4lgJOHmwom3sJIV +GnyBu+lXLhBEEIPiPp/DwrrpIDkdpwsEV6HFDi8PGb6VyiqxOBXOjTKWat3zxfZZkmsiuB9e6Miq +OOViZHhXG9hJ8BHl1uVK6zKC5ecXctEom8PySM5IJHkgh2zOZ0QIyIAgYZe106cz0QiRCh9YoMIH +2WiQkQr8ICNUJLWBYAYrlLzioW5vavZEUOrggFAyD1IpSg23sJJMS5msoZorgtoF0cukrWiEX1jE +EwmOJPLgCk8/kYSizwsNhm0kM+5CFMiNC4kuBViCnZ7LAejihEdSgFUdimlguPd4KivIjjQ/j8Vj +fCqlxRNhk0MwRwRekaQR7A4ntUW1TzJQhrTTC9TcgojkKixfNUyoy51IBJbR4rgKirlQUucjPEb5 +rNTkxK5mjEF/QL6A5TRzphlLYV963I7H2BTiYUSVIKvRMIR4eCVSqiC2wO+ANgpmeL0olgBG4hYi +gFs6xXY4ZcyIfYprw0akAPYQBwIynTVjCRleUO9IOuzxi6B6Ki1kUSn7OInC58VIH0IR/DhYOSDb +av3c+tGrjcltwFcAYIicHAY/W8DpPCs1guZ5w9/l1H6OKoLMxgEz4iIsCBQ+gOFcrswJE1HZ0KwN +FA/Ff34RJakgKB24hV1OGqayLoIXwQU71jLHlYDxwJYWKzuF6jGClxNpM5vLA2bn/U1F6wD4wb8K +UntpcmN99yEjNZOIlsjKnAS2tAO1Cc4OJ0uGu237h4IyhmydX0BjcRroC0QGcgQ+Dg== + + + VpLm+xhVB9gTuDLoDIa5hjXoLp/x6/sE28sgfiQmgK1j2NLjwdlCOiNIcrfavlDvXax3T7JYAcIg +HhdAdSGcQIiiESGZNHmpgeTMGBS4eSxs+Yi5aNimL7uwQEWiEse3g/p+ImvML5KLUQpEO5MFr8TB ++8PLVqfx9OPEh2SH8poKr58XaLb62I8Y0biSTDsoXjLdNTjTuXkSbGO+sO36+1I49kIFvl2I4NFw +ToeXjPGnTmUTCTXvr63t3woa6yhVTSP5VMZIZ2xFWwqn+qIOJw+C2pl2/1YGBfNSyRF1FC+G9T3G +LUZhTfJBsN1dujGcPQwaF6MJdX6RDQ8sbaZB1rA8SpY5aaxaM82eMnwTtDEEgwgXT4Jn9EVpAqj2 +uLt+SI+RGPt4pI4CigfOOkeWcwTkeEFRurYbDruHUiurk7y/I8k9MKQZRGK4ou6OcL5O8A2jsLm0 +8Ywd7IffykWocLh2Rha4pm6sgpVgpT4nDVi+LUodFAl7jMfifDQmgAJb+VVR7T3+wr2EYkVB7IJN +SGbtNFpguE6ldbHUOAdBCIITNhymANWqpt0r1nc4tefXD1vLV1rLNxihD0kNW+O4s6B6hNPtDFqi +mBrFwFnkM2g41ieLwO73Ku2T1f0XRGuaSIU4geaAB2o0F9C8Z+SHvDrGiPDCCKQVJNdiBHxceH0g +bIGuNiStLypLgEA006CpWjQqzi8QiYSUzdjhn4gBiQniz4ltim4kkhqo06knEiwV4GFBNCHBgTS8 +0lalfgiCFk+Q6Qxv2T3LHj9xKgvij+ScWFrP5sCiFsNLuwuPe2BSVUFaktURfC7FQBXIx2Iazw/A +ZcfBms2h8E5YqzQaQPmLJ4zFRW5uLoemNYb2wi818AItDWuDG6P1B3kQAajgmAt43xyc1+0RFP0I +SEE2z/BDURuD+MSSEkRCLue67igIVoPyDqztYlSNJQzQLtCW+QgZT8sIEcjGzCnuyPaY4BoYnG/G +eYzxxmOLkcdJEOQuitfS2fxCNJxzBKJEsWXdnWruupHfYLg6hueBEzJIuAusAGDcAzkCEWa5Mkl7 +yawMkgv5OJzdXD/3sqCPIHrnF8hYeAUvoCgvFV7H4KHWKMYUpFiU+ouLYLQJsOSptIIRFs2V0ogB +miaF11HBJDaSKQ1kk2RbFNuU1AGCB+C2WHGJEzvgGigGgD/QnVHQ2F3debCy86Rd3MnkSom0Bewq +ip3HV6JqnLTseBuysYxSRfC8kVC7DEXtGIBq5jJK17J4kWQaqg4f2sti4JKK9d4+I7QTST2e0GNJ +naCbYE5Doc7oi4s5BFVtd8mwxpIGxSVIJMHQ6dmsI///7L3Zj1xZmh/2bovFzNgj7r7vN+4a+77v +ua/MlUzuLBaLLLLIqu7qrt6nu2dGs2g00kj2yJItGTYwMAzYgAXID7YBPxj2g/8g+3eiLFkSbEAP +BpwQ8nZ0VmYw4sY95/u+33Luyfz8Ld/fzhNDXfXDXdvbkvQ+w9SSKTuZMlgmtLQeTXmk3Q88Xf24 +3b8KS/sQz3na8YNFr3/lFaf37uUgRL1oVWpeuOGpZo4oKtjcFHN5N4oPTGvMMAFNx1CSFiAX/Oju +2M4ScJfNmDxfgepIAzEKASejPLscWxLZWIB3UNu2t6p2rjuTZ1FpW9P6MqGScrm6PVveMLQHRIUZ +YYS6bI7zbDmdcwtsiWLLmtrlhVCQQjC1pi8kec6y7TxVzlFBKqsJSlNc79ajxZJkDKqdm+XJL+vj +l5A6yCtQD6oyjA57w9dOeLK+/1IBmqFwgOrrFvNjw91CuKHlCDLLjXzBzRVcpKWsdSsN8svXFBOh +uofTx73pmR10Jb0F0A7L5yAjUSppWj1P2bmCadtdvBdEnyULyz5ZzeYr1eqBpNcsp7k8+Nwrw3BV +RaVDftM86+Qp3/HnmgWVEtNcDAFv+VtB+ZhILxZ14WPUttv3wq7ttgWlDtKf73yKa1cI+rrVkWO6 +E0lr0nzECKWwtndw9vXW4buotDT0OtSI4866k6eSTgqqQFdgc0x32Z8+K9WAA04BAputIDl1ZyWb +kzyDCYdS0lStGUYL2B/NnAEVLXd3sfPRD/chgEWxkclCZXUMYyyIsNs1lqsr6kzRFrazRVHhxiaX +zZma3s/mi7BRvNxtjh5W+s+a/ReaMdlMyJubEmYe5kvRexRfwxlQVl546IAglA5MQSIl82ITrKqo +PYqObX/f9AEyTdAoS0fAzFzWXqvxbibjpFNmvgA9Q+77Q0hISo1mgkRSgn/U9bFlT8jtDwFI69eq +hzxkHuXk+TjHxDRfQxXL6jSMjmkmVNSWjkzQutl8mEg5uRwote6Fu2HtSNRarFQmvz5gTbvDZ1sn +35Tal9AbZB8LVyJRE8oCZBXf1O19q3hiOFuKDoERrddg21HpZOcYmHAJUQ0ZloHAY6DDYcmRYx6U +fLl+0xm89krbLNkGZrFcICot2ejRfJzJaRQbucGu4Uwlpb6REMiOoxzpoQbGBzXQGBpfQYF7pQPJ +HCTSBsfXUXe5fCiIDRhAEJykDUr1S1j1ZNYECPvRblh+AL3hhQun2OeEwLW7pdIWWZdwJplCkEjb +mbwHqFGNXoF1MwUrLG8t914cX31c79+201kIUd91prXGCSdU4GiCcK9UOY2rp26wjfy5fz9XKDiq +DgMbUXzF9A7KzefdyTvTXZD7VrSfSIoUXUTIZKKCvCS0dFIGzNruwnImFBMA4evNU/i7zaSezgUF +traZthAaKFvP3y6S3SnHMMg0XypwzVQ+TmZDUZ60+k+rjUP4C5YNwFM7Rx8un/5BvX0BL5ZI6YmU +yXJVoCsxa1lXM8dP3/3V9OAbxZom03YqaejGqNG8gsr9W/9h5rP7nCC2ty5+s336bdFf4jrBOJgH +zewgsbP5AFJBVFe1zquXH/6jsHSuO7M8h4upAFtoAVYFumsi63NUhx8uDbtVoA1EPJsLOaZlW9vD +6Uvdm2ZpNy6tDh58YqWmqHYEvZWDhuHbkG2oU0XvkK7QfAmatt3/cjD9Oqo+gNyFBOK52IaHjVZu +gJOUElko5LbrntTqL+ziQSoN8VnEAOvdJ1HtilfbGdrLrPeEkNlOS8mUzHGlsPSg0nqEK89RbiKl +EKPNRJCg0KWqPau0H+6e/mK887Ud7ufwEUlDltqZjJtIkLsnmFJWaHjR0eWzPx4uvizAJZm9auus +XL+yi1uwh+m8nc67mj7wSSPmEPaBrIYp3XLtQbmOiHTIOgxPcEDWWrxcZQT8WOOljiC1ZKVJrFDW +oln4qRFEPsWE+DGbszgu1vW+ZQ/JxmOz74YHte6TUv0MLJkkS+JQ70Uof5omfwoJcj2VVDi+4rqw +6iu4v3QW8smP4i2I82RS043F4uhbv3JimCtFGWJOguKo29nlOHtjkxGUkeEcxvUng8l7011l8tbm +phBHy5PLj6oJK2F9timksq5d3IFaBlbApENWBeT3qvYcb57OmahHRugq2mQwfr1z9B3L1+5/RlZH +4WVkcwBZsrEhwQIgbRQDs3cMg5aDvO8+wqyOV+/88mkqG/0f/54cV/9/X8D/V8fdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HXcDuW3H3UBu23E3kNt23A3kth13A7ltx91AbttxN5DbdtwN5LYddwO5bcfdQG7bcTeQ23bc +DeS2HVf/278nx4r/9+T4W4oyfH0zuP7q+t7x5J7SncaX+Hn3+t1Xj9/eW91TLovdt18Nnj/66vkX +r6/ffuJreMpzg4gv7j6+fsXrP7ySx4v4rbfPnz5/jSf3Hl2/emzwNl5ax//vebzPe+v/HX+651S8 +cuCG5XJQCnw/jip8xauEbhTGcbkcVoO4wn/+//iiqOwGXrVcLlXKlbDEvyIv+uG5qudV4pIX8P/y +XX5Y9iuRH/2/vOjf+rhX/y7X9Ores3tH917f27lX5XWDPz66d/CvfYd5q5B56719/+7Z9vVXmJLX +PzzZe4w5+Tee1g9ev77+/PENv36Wx9N8EJQMzFIX/z/+mnzz+N77f3PWPH6Gb17gqa953+OX/INz +j78hr98lV1+J+PWX9cyFsVsu/fDz4l//+Yf/Lv7V6//tn9evf/1/fzz+8+W/ugqfXMU6PUbPXz2u +/fDtenD/V65gKnA143vFweMPzx893h33+OPVvQd40lnnyw9f8dN6ruP4h0hE/DkfeD7GVCJvf/bv +9AZyPf/yTf/yvxU+xDX65fXlRjx5o3dPUdZXSLK7xpcQSP/e8fQ/4EXSjoXhAkmpy2pTJv1m6jTb +EOSBYowEqc1xpOuAINVsZ6oZA0XvMHwpz/h4FyuUOLFK+kOzvqrWDKvnhTPLI73HZLxX7WvWosAE +maycyYhUwSRNs6y+5S2N4kq1ZqLRY8RyjnKL/sh0uixfMayZW9wO4iNJH7JcQzYmvNSimThfKHJi +Q1R7stYrRtus3EhmjAITsWKVYrxc3mHZkmmNwvjAKM5ko1tgfFYss2Io69UcY4tazSvtBdXzcvuJ +Fezh7QUuyjOBH+5WOldB7cQvH8b1S8NdCVonz/qS2hZkTEKUzduZrM6wLicEslKV1Homp+OzOL6e +o4I8HRbYmCfN6nqC3FC0jiA1WKFZLp/54SErtnN0kM7ZmbxDMb7tTg1rmKecfMFWtZ5ujEiDwAJp +10Qzga51q9VjmotY0i6rk8laiaSMf6WokKLxiCVlIGlDXurxUidFGh0V8STDVli2IitdUWpRdMQL +jTwVkL+1zcY0UypQQYH2Na1vGiPSTIgupXPuZlLGI5XWMxkMJBCFsoQEKBRzOZNlvFRK2kxw6ayW +K7gFOsgXQo5vclwNZ8vmcOVFUWlRTJhKS/m8i4tMpTSajgWxw/FtSeqr+kg3+oPBRVxdFiiD4Sqa +MXbDlW4PcwUnlzVoKsIJRXXAis1sIcjmXFluFYsLxx6zTOR5c1lrU1yIlGC4kqKPVGMsSRXX6WZz +Oh5ITtvdVs2FoCC7xkhO0qpcrOTzFieUbG8RNx44IWksyqu9Ah9zQvXs/LtW/5wVYoaLTXtVaTz3 +SxeC3KfYUoG0YPcKdDFPuXmqiPGSrsZKj2IrFFvO5OxU2sBl4wWk65LapPkyJzVMZ1GqXXX6j7cO +33BKRHFF3R57lZP64HlQOxeNiagNEJGjw2+mW69pqZItuKa71R68LjdvRG0saCOaq+QLLqaRYWPS +YDJnJVJKruCR5uKFYjKF6KgUE/FIeKXFY8L5Ks3VKLbGCE1OrpMGpWIbc4gMxMvwxg== + + + POUhUdMZlfSOJZ1B/XzByWatQq5IFTwkGBKJZcq10lEp3k8m5WRCymSMZErZTAgIIgbLCm1JGbN8 +l2ZbmjrX9Vkma5OGH2xJEJsIGQCBZoEPQ6e4xfDxRpK/v8kgOYEppjk19AmKhZwtY+Xz5G+1b2wy +qaTA0oEodiS5y3PlRFLCZTBMlM5o2ZyBXMoXomTazeWDAkUaaEnGlABLzsAoUpiElMIwJc8/DMIT +3z9S1H65tP/h67/YPfn8s/tZw56R/pGdS9kYkD+SjiKiSUeQTN4if/U7j+mNreLEtIcCMlyo7u29 +tb1JlnKTWU0Q6qXqZVA+E8QqLwTZrL7u/DQBwtB8rcDVBGVgu1tR+Ug3hwxdtO1BuXFshzNRb4ha +FzOvmuNisD1fvioGC5aPkZauv+eEB6I2pOgKJzZpjuTb+i+nyxmMiC6iADkBtVMXxB6QTRA6LF/K +FSzSzUWtIecZsVoM9gezD5Pt993ZY0aORLVmeRPTn+n+XNCHXnzSGbyo1B+Mxk/KjUMgMMvGdnHh +lw90Z85KXV7BEDosVwW8kO6wGR1QkM7YLN9Y9y22EaB0xmA50gYgU3DTlF9AWLkuJwxs/4hTGumc +hnk2nFU276Uy5kZCBc7QTFSggGAeYIqiyddCvphJ66mkkk4hlE4h71nmUFW7yKhkUkkl1R9avCdT +Uq5QZIWGbi5ldS6rU9veM81VvoCsaFKkRVOFZhCCHit0DWsVlc54ubGR5FJpmWFJqzNBbLBsGVCA +y153wA02NlikVjarMbTP8x2GA4TGhUIkin1d60tSVVPrKIRE2kplfKA0S3qr12ihTwO0uQinTSQF +gnVsWVG6eAEvgPI6bnGr3X/iRPPP7uc0uxeUSPsEijSIagINGK6aWRMBygozwIs4YZkiIS7bxmCx +fC5rzTztcUJFJh1ZJoyAmbQAIDxfsayR481oNlaMDq80BaXDoq7lzrqnrx2Gq/bg2g3nfjy3gqmo +dTR7bHoLfBXkFifUK5VDyxunclo6ZzJMRdOnvNBCQIEhpBsEBfhC+duZnJsrlCR5iKlWNNK9CXMr +iHVRrqt6R7MGsk7aAxRLx1awzckNP973oi3VHtjeWLa7pcbFcudTe/gc848aAZjY5gCImkjJSCHT +WlQbjxEd015oep8XaoAd0lSg4AK7UhkDOUDTJRAQxwOmYrBeAZHl2yzfl5S5F12hZCg2CoI93Vmm +c04ybSbTFtgKJwHo0WwAFuPFJuo9n3OBTrmsjQfJsZRCg9f42roHkp5KW9msg0y4v8mte7NFstrP +FvxMFldSzOYAoSVZ7WG2QYikvRmAkfIYvi4qY8QRmCZJDZqxgT9I7DwFOAqBkBxolIk3N6VM2kqn +tY0NvlAoK+qIA97yrXw+ksRW4M+L7iiRknDx6Szhvlweud1SjO1ieGC7c4DbZkJMp1Vg12aCTSQE +ga80aie6NWXEVibvoiIoRl+3je8gRrq9YoQWzZH+2RADqtqgKINlfV5qyvrEdneKPkLZYrkQ5NgZ +PKPZMmIN1iCtPlTS/g3nQXFZ9jyq7kPtJDIaQA9gq2pD5LZdnJnupBzv/fInf3X88BMjxbQQSjok +2dwLD0qV01rzXNa7ZBQ4MxWyXEvRFqZ7aDoHurWNl7FcWZXrljvLUhHIOleIMJOGNdethWLOomj/ +8Ojr7uAqR5P+626wV209rHUeVzs3tr8I/NU3X/2pV1+k8hZFGs61MVeQB4YxhrxZqxQb5CKue8vh +zHjkCRFA/9QYvrqZZDKkL1pIkbJtpDJOLh9TdNU0J7rZ3UwBW8xcoaro26azZzrbsjZet6uBYENo +zExGIU2t0ko2b/FgFqmNCDJ0KZfzcjmQi5LJaCAgImDSRiKppTMOcBKpBQYBZKUAICnx/kYBGiyd +NrPZYqEQACgQAuQMaDGRllM5g2JDJK1uLiQFRdHEtKOieR6Z08XJgTOgvGRSSyb1XM5n6WoWo8jY +DB0mkwJAbGNTBG3h9TQdbBK0VGmIPQp8ZHMCpqXKCnVFH2PSRKkLDcbQwC4ebywU8K5SKqttprXN +lI7R9btP0lkZuhSagbR44SsM39TMVVy5jMsXjjPWlLhaXkWVfVHtIMEgmwWlZtujauW42rrMFXzD +6Kh6G3KRqA55IKljw9quNm/CCnRsGbLE8eaC3BQJKDUdbyuuHQ/Gj9++/5PZ3nNWKilmX3cXurOA +ZfihDZug9JDkADrUhaL1LXdpOitZHenmDFxpOcv59NV4+UWWinNUzIttTR8Y5hjv1cxJGO61W+eW +O6F50gpalNvQgX58XGleG+7cj3Zev/l9uX2IhM/TAbBONSdQ7EBU6GEgQIGO8T0og6ED0pvZGAGX +CJXwTV7sZHN2loRbxSOTAZ4DK3qAzXKFtFJOplXkCc1UCkyV9GXh6oLUk+QexzULhRL+dTPJpzMy +tGih4AKXdG2gyB1ZamvqsEDFwCgKrEoFyZSRyZKmgJmMiRxLpw1EluOr2bwDdkskuELBT6XMzU0w +pkbRICPULERyEcTBgra4GjJNEJrEf/ENpBkJDV+TpBY0M84J/YZz4vqRWhBdaeh54FJaJ+o9rSYS +CtKJ0HFK/QGpkD+C0AA9Wc4CUg3yHjmG0yKgLFfKZkxoNpyQNAJn/AQmga/yUkNWkYdhOqOQtrgA +Sb5KYqHPK/XHzf5L213Jct1Qa7PJo+7wihMrktqRtY7hDP1wWW+emsVJKmOZ1kA3+9B4YXRQ9I+K +3glq1vYPBAX55ilSo94+yVEO1LggturNm/7k5Xjr9Wj7leaPFKPbGz31Sgc5przu9dL2ooOoehHX +LjVzhkvSzQFpm0qFBQZg0vTCvaj8oD9+FVRPcnSdhdYSagIZCCC3Z7kL054RR8lVMbGq3oPsZ4Wq +Hx0MZ6+L8b4dbFXbJ4xQTpMarEHFwYmAecEjkPSy3McHgTiSKU0W60G4BfOLlEBEIO1Me1tWBoUs +qnuNPFkHEWdI36aOpE7xFcKYZ2uYh82kkkzroC1cG37M56HNqqk0aZKUTCNkUoEqwoMj1lCqhjYq +RUeqOsrm4aOdtSNrID2yGZgpL5uz8JZcHmYNHjnM5YnaJ62OM5DEbg6cmHWg/Nm1WgA8SkoPQYdf +QCYY5gRfIZDwIz7ItKagD5A4GDCbsSgqSqWMREIEjhFRl9KBhFSBtMwhqJiBHQMXmykkWMbABzF0 +GbkEUccxJU3ppbLIKAHZmNgU8wUPdAxRCtpNZjRMGs16ySTz2WdZKFgBkrvgSxLws0/K3xpxUi1P +SDk2tW67c+GGS5zWtOfQ3pxclrSq7bYVDZzlk7WC6ACKt1x5oBpTWGOKrabzIc3WoGM9b8twRpmC +yUvIzJbpTFSzr9ojVmkzUt2L90eLN15pjwI4aANeQd7OnWDfLO5o1hJ2G6/PQ5xwJWRCgQk0c2p7 +h6q1zSkjHl5J6kLJAGzXbWhrBTpE8WbzEDN129kjHRYLFvAEZI3xQnGxpANuU5DbjruKyyd5JsjT +Rch+ivQqhsAGpxiQFoigqnR9f0mhDBMCtDfOvzbdQRbiJ42g+3B2ABB85YW2bu6q2hLWm2cbaVLF +pFUtankzAYPGZnM+TTWgkEnQC6TTPPws0hWIhMRYz3mX5eqZnA/thCSR5R6UOc9Gutyk6eLGJoVs +RF7RdIWiwFMVEDRNxTrMdd66v5FPkT7BQDyPIwUFXYo0swxjapgzRAccCs1MdP66ZSOeSSYlXDY+ +ggyBcBmHBwCwkI8oqoR8w4VBYIP6CXWmNdItNWNBtqEiQLuNyv7J/lebKemz+xROxTEVC2rZbjGs +Qy4mDU53Eknm/mepVIIBrBVQIBkDMhIKE+HI5nU4fYhqQx9Z5sSwhggr7LNuTXi1kcmrrOBLclk3 +WsArv3RourMcXVStCcWXU6R/VRkJ5ocHQbyvGv1MwYZdYoQS+DHPeIxYhoNTzVml+aQYHWv2lBZK +XriDNEOsSQ9sbRRVrxuDl4a/wymkOS7yihErWdrFu+zg1PROdWSO3M4zyCUvjPbdYAu+g/i4nIXC +BCvh4vEjIoVqBTnCXar6IKicWv6uQPrHk+56cHaGNdLdeZb2N9MKnpGVDqoPcyWSrtJVJBvPVvAR +myQEBQQRiogqFHk2Rj0i4ihtIHOuYGNKkS2IO8OgJEvImc2ERIQ3UIsqgmETRLfo4BeimtIGkA2s +Cgbk+EqeeMaQMC9pkYt8gxWF0FKRV/mClU5JmgJz1F8zNcZobSbUXLaImMKdbWxkWcYXhWqe9D8r +JkGgBGQsWepZzjYwmbBwVv+hrzDpeEqH8LaAKaTK/Y1cIski8WB4ORbUpqOOYEgBXwRtxIoDs8zX +16sf/H3SO1zFWDihDKNE+j4yvqJUszklkaQSiXwyQeVztiK3bWvEsi6VU127A4UJyM3nHaL3xEoG +acC6klxBsMDvZHJgrrMGWXwzhqLWzhdM0+nxcgXPkIUaCNQCgY5S7Vq3Z1AFfmkrzziY8Oy6P24O +qlUo+dG2669MexDV90W9w8stWR/Ck+aQCXylUr+qth8yAhi5WWlde+UTxZrCduVI59F2EB+H9ROA +HnSaVpxmaY/0NM2QfnJgQz/YBdJiCIbVRxpAqxD1mytSVOgVd8qVU0lrUwWn1jwygkE6r6RyZhpD +owlX9gZPe7MvRXPEcLEfbbEieAdqRIXiRShBW3Gwr+uDZFrM5VSOCxNJDpWOcCMBSMdWLi4woFSR +Zn24yHwhgLQGW6VSVjKFeDVg0HJ5M0seZFksS9QLycPNhIwXK8oIIgGOg2L9HGUjiBsbRPBks6An +heejfM4U+SiOpgUGQAfX4K9hrV3IB7kskNNMJnlRqDBUEcAFzioUQoo06C2R7ptkRRfzU8KnpzJK +OquRpvJpXJgGhoJ8SqUxCoWi3bXEEjY2GOAwMGrtEWzHnnzx9s/I4tgmnU5LkHl4EnkLKkzj5AW/ +2TxqtXeRVLkMJ/GuxIewn+tsKQKpeK7U6jyAF4MbRd6uEc9Lk/bGrm3110sraibtUIWAJu2iY1lp +kaUnsTqYPJSN5kZCTMF7EknsSWq31rxS9IFtjU+uf5TKyWSNi4GPLgtCVdXaSC3THjVr+4eXnzR3 +mFonBiBaEFpFb3+6+lTvPWHFhqJ2iqXdAh/laB/MJUHGF7eqrUd+9TgOlo+ffh/UVvcT7BqfSddz +FKNhLgW5Bzvf6l5DPyeTBjQDfsS/WvYMNpk0queqk8VzySxvbOaAFUgqQKistcaLl+PtL1V77JiD +5fazLG1ubOY3NxleqJA2olKr6C5BWCgTXowZ1l/Tk5AlkEJ8MbKdEyKKttwAuO39sNC9mYDXg8Nt +aNBgHIRQaNkDUa7f32A2Nmj4dPDImnTKqjYTiH4IC6yXykhrPFGBOXBbQEhUOuSWY/XC0iyV09bL +YjAaEHgBIamUmc/aIl9xrBGNFOJjRWnD1gFISTduEBmImwlbrVNBqgC7UBFIRYau5g== + + + 1kUHcY6MkoTQNJBjSC0RgJxOQXSRN4LW4Sh3Dr7MFPR0UuBpHwYE2LW5SS4+kwW5VOLynuuNU0mG +ZyxJKNIFOAv4FFMQa4Y5BNzJWh8yKQ0yzRjJJPyLRSMQYkXT24B0UHA24zLIECEihUmysRJ4253h +taQ2APIMWf1DgftrwVyiyHrp8OjymyxtCUJZ07qiWAeO8WKN5UssH7bqe9fPf+GE8wyRozFqR9dG +TnFVbj6QjX52zeay1U0VTFGplSp7rFinYYT5qqT1xqPr73/5Hw9nV/hcSWhwwLSCixQVpYnlHhj2 +Kqie01IXdszUodCAtOD3CJ8LHavKXddf5mgbM6wR4dQo0A7FusBeTq5yYrnfOPrlr/4BxbmbmzTH +ekG0ANIiRokkaseCVCv6U1geYA7DejTtMGwIUsCZMXDfnT1/+3uKh1uX1vekfHxlmBLoD1AThPPL +6x8PJjfglM1NKp0WkAkgl0RKBfYiRpLSAjhA14FPgTbQxqmkkEjwUHSmNiy6U1lrJLM6GBM4uZEQ +wCAgZVWqq1LD1HvF4pTn4tCf5Qs2YGdjg8ph4EQnl1CnUWlHVqs/wGAmo6ztoUp8Iuib8S2zYVud +dZdxSESSOUgwCEI8ECBM4GaCgaOxjTHg8bN76cQmTg4z2AbYwjXAQiaTQo5IKQUfje9pKgJ2rW8i +GDQLrWtvJHhgFJiR40osnDgTw60kkiSBUwS4VJYLWDbU1E65dKi7M4h80j2U9grkjpjF8BGSSlbb +hj2ChVT0LsOXi/7Sr+wJMsx7XVZbvFSVlLrnTyWtlcyBzmwiuXM2aZ8Mhsrp4GJFbWGecX5aqAhy +A2CYyuLkFae4rHcuS51rK9xl5Wa24AJ4iRnP6amcIchNuFFe7Mj6nObbRe+w6O9CXGULJuKFK8S8 +ZbJwWyGRyvliJo+EYTcTFL5yuM5gL64exuVFtb4FkQOFoyOUaSaRpPEjpsI057I6EhX4zQBSmWa8 +TE4l1QT/q7WQqGF4VO1epcgtJw0FlUxiklHdfCol5HKGanQtbyZrPbL6RNnZjJxOiwgEok+TFbNq +Nh9C5IviwPVOWaFOLGEOigvhMCDsszmydicqw7B8DjdBmJpG7LQEICKl0Hkrn7U4JoqCJZIhl/OA +yQwNfjTyORd+JFcg98U0rY/XbEBmJyR8bqFAuj4niHSUiNsFTpK7NiKQR1fbxIOQh4RHLu/wQgtJ +AshiaLhRG6UHj5xIKsSi5snFaMoARJ9J6abS29jk792D7iKNw4k4yYD6BQKhZEFDBR1TGKnQAWwC +PMmiRwqpFZHW1AUkkgeqJVxjTVS1S0GxsIFudnipnKcDiqsUmDrDd4PovNZ+FtTOYFhEqQ4aBYwg +hwHRIMEcFRXoElgbH8oxsa51crSjqHVNa6v6KCidusE+K9Vg4aHVBThooczwJdN74FefWOEhA7dI +xwzf4Mg6QylL6QWIQ6ldaz423S2Ga+aoEKXNCVVgC8of46JpqLiRSHrY1zJkgUgjHjxrAGklvclK +MSdXWB6OrEp0dYEUI8MGrBDlKeRnAGcBx8oKTbAwuavIlUHWkJoY0drat2VtzHINnqsj9ODTXBbT +KG5u5sGeOcqHnqTYCk90lwNIQUBBEKmkRGgIPrGAEzZ5EblXyVEVXugqco+iHZIe68VSxIjmqhw+ +HcqTr1vmIgfBkxQZymMgGtNqLgNK6tFMlabjfB5qEwkDwVxC3rI8BHzXsReWMQJE5LNuJk1aQd+7 +l4KIShHNI21sotDIUmqGmN8IdiNPvIZ2f5MHiqbTdjqNy3YDf44AIas5KqAL5EYqwBADwbtAbTzT +iotHMJubmxBsCqzxZ/dpAHgu55AFOrAtzGMeWFpTlD4gBdSfTpl4oyDUs2QpQ8oQnAklses4S8ww +LkCRG6XyDiOEZOGdrcra3PFOyrUbw13BiGE2wmhXXfdjRrhluWEYQ8OcS3IHZJFK64rQLMf7WQoQ +rYGLbW+7PXwZlE+RP7mCbxV3ZH1C6jHveqVLOzxmpRaCxQkN29stxieqBiVcNpwBLzYMe0axEWl+ +zMDp1xWtz7CYKBl6D8Imm4+zhVImH2RyYLSqLEP/tJEnKApWKkkqlNWYgr+jvFRKzqZNjSBhlEhx +IEHNGipmP0cBr8iCoWmvnOJuniCnRZG7gaDdOtw9w1TSGQc6mUUF5Y3NBA3/RRrDY6RgDUxd3ucY +kEIpk3E27jMof8hvqJEkWfUCB/mKNisWT2xnl6wUKT2OxwXwxOXlTKA6TwRVw7RmhbzFULYiVpMJ +dhPeLaHIwghvAWOS2of6zRchNig6hHYCNxXyEc/W8ZWlqii0zz7LgN1SSXJ38v59+t69QpK4TkCH +BzBJAVvoEvj6/obAsnWaxuzVGKbheUtVhaYtOcaYpoIfpGMmpSHrGCqGZ+GY8uamkCFOUwR8ZTOW +4+5hltbLFzoKGWmWJjcawMt2hoQpoigo1TiBi0yqYCJEOZMhNyMgxrLQe8rQKq7I5pOcKUgtQWpT +XAxLspkSgYeoHT/aAc3lyMaSiGLAoUhO8ILJ8xVF7hr6WLeg6gWadRBl2WgLGrlVpELA2zPNnlNk +sQjaBgBi4bSpjApChKAVtRGnDApUddV/urX3KgPiy1rIZFCYQfYCgU/9FBmRWS3vZsiNvCLLd1V9 +zJMbqS1B7BWYEub//Ozb04tP8GiQVYkUnLgjcLEk1OLikudCihj5Gvh6I8Um0oood5ziVhCfmPYS +KktWqrJaT6TEDUIBEcENpkQelE+24tCBJOFfFXKXv+DC40PyKVKfZRrZrI+aZaggk5ZhzWDKcFXr +XQFkdSuRhh+MqvGxrlUyGeBnMZPDhampNKgWL9ZY2tPEsqW1QU8ZCH54IqRoGlQLzSMQDcxiAgcA +FlhOKu+LbFMCtMp9gW3lstb9+/n7JLFlZAK+SScNmAKIqALsPOaQihR1AlrJZF18zQIG085mCjbT +Xt+AaDv2ErQFv4kR4UH24QCsNlhyJZBwGDu5HiR/gNJLEsK1edK0HlRiYjbgH0UJkoOs+QNbcFqY +ZYw9R2IEIhZSUPhZe71kgXJzkkkFZFdgwk2yVYMly87IgTzeVQS4MXCgQkNS+9A5qRTPMLgAkHhM +4+PWN+KhOcNwRzHbGykBLKAZA03vIU+yeR/lnMsHeQLUEks7khjjgjP5IhBG0Samvai3b4rVA4gu +5I9mjKAcyDoMyjkp4AJYrswLjUy2yLA1miknkfCITsYoFAKWL/vR7mj+tDO8hCNgGbLsA9JHRjF0 +CPkqciWZr+haGxMC2CFLspBqWZLYhjkwjZ6itZHDaxmsr5f3I2Q+SAFSClOEhAFSQRM69gh+CpNZ +wHDIQrqXIH3iEZdiPu+uyULHPN//jLr/WSGVlAv5AMQhg+6pYj5rqgoCIRILAHrNYrosKOdcxkRY +17SuJRLM/c+yyFI8mc86AlNW1c5akpmKVId0BDvD28Kc4iOQTpubIj6C3DUgJIjPzWzex8klkQsE +NqSoOE9VcxTGON5MKRvg7iy8fIzkl+WO7cwMe1qgyR0Nssic4D/7LA2qpfJOIWclEkhvDA2WEPPA +rFdHywwXU1SRQGIBwqAsiFWyP4ohvg85Bs9LkbXcgKyAkQIE+TqplI5Kx/UjURk2pvk4nbcxgcg3 +vAXBwvdQlUVvEVcOisEORZYfHcg22M88pVMM/FGE/NehUX0I/mamgLfrpfKhrJLlILKPBRBK7gIj +ZB4soWWBtirr9XlIFwi8DsvXyPqnWCc77nIuy1eBVIgv4BFKniQSAQ0XBauoAzAX4gi1g4CiEGAe +BaXlBCvLnbFcS5IHeC8USBLJD8ARGxQVID0wJ0CSHFWGJEYcaQoTFapqi9zFZuuS1Bf5Rp7cBcDF +y6Cb9b1mFfYHqjVb8DCT1crOYPLwPpAtC91bXu+VUsBTyRSUv7O+u+QhKMkEyl/CV3JHb1Pc2BDS +4LKcizwBxwEcKGjdrAYth0IGhSF8ebIBDKkFGoJ0ETc38psbSE4JXj5JRlosR0eiFH72WfL+Z+lc +muQSLgywAMZMr+8nQjvhn2A68A1Ogk9hyYaTsaINIdUA4/cTMjwysT9r7wCyw9XmKdB6lWPr0CpA +P54pUXl74z4ssEgkIrIo70M4ySrZhSIqTUgdhitxYmt9p5jcvFPNnunNdHeSJlYUkjUgSlKs40HC +lEHe+gzeRYxYMUcXiZJnic7RyBbKJsuVFKVl2z3bHejmiBPbktKRyEpUnxMCL5j64TYMMseVEaZU +zkrlTOjz6exzzWjBoTNckMwaG2RoThZqgdzQ75GdnHKbI9s2/I2kvpnUaZYoJXgroDeYlBObqjHk +pOpGgoF3TqVVYCZomhfbUMsc30EyZ3NwEAoYnBMb3cGL3uClpi8EkdxDROGQLShZcutkvdVTW++1 +qzBcA0YJhh3Qh8rKEvQoFqiKqowNHfQRI/HIssN6sw1Zwd4UU0my2xNDs+yR4U4Qo/VKpkt8ekLK +wxjmy7k8HArZapIlq6BuMqlvbPBgsbUeRmrpGSgfiiyBcmysya1CXkunAGsh+BQODlxToMiGUkGo +ZFLiZ/eQQtlkQgACI/+h/QShB/9FDEWCljiyvQHklU5p653DXo7cB8cYBQx5fXNKglYpEBMaU0yZ +DCpPtn9kyDq/cu9e7v69ArkqQmExy9V4snutim8kpAQXIC0TpHysH1KLoqu6NQ3K+26wcvypX96W +NLj4gWpNdXvqxXth9bTUvGTEDk02lsAAwgh3EVxy75VF1TdYHmjmEjgSyshP3YJP7yDWiK9ugbCm +ita0naHrLWVtqGgDkdw0b5vWZDR63mpfWc4YRp6sPtFwZDVoIYhkuCFZacO2Z2kIDx21j8xh+Jpq +jnRnrtkzmDWo8fU9X3u907XLS80cFDJfd/zdUv1M0MgqN6gzu8a9RNqAndTtpWZtg2E3yaIlkM03 +nLFuj3C1qQyMWESzZP+qZg7BqnCXQHJkF0CYItt7YEAWGDvNV5FsUDu63pbkLse3kLRweQUWSQIX +EGfIYjXBBEKIIG42FqQmgwsuRHkmzBbIBgboTBpOOY9SrWbyISe1DWsK1ZrN+WSNMWet9x7IUE2Q +tTCeLFuRxKYsNpBXuJ4cuYdOeIfcWuIQ3xqceJrYXnAuYARyRc7l4M58oKLAA17A7xXH7meyCoBX +URt+tI1CAH4iLSW1C7lbIOaobJptsrc55yDQiKAg9zmpUyAbaOMEQTwkD7ntCEIhMMKEAAo32A2i +3TDeQbjhoAt5kq7kViwVIY6KgRmeNAdnfnUHbsiLt1V7IiElvFm5cdqePI8aZ6o5Jjd5WT8s7yjG +EPggkpWBBqJjFSeK2XXDhaQ0TWccVPc0m2zP06yJX96vdy4qzSM32ha1Piis6G35kFVaT1b769cM +TXfU7F1o9oDiSxiIbMx0Z9v0dlR7wSF2ctOwx1FtH0AUlI/D2oVsjBmxLusjCYmqdg== + + + AQjr+5Jliot4uYqH4Qwdf+mXDovhnmqMZbkniG1QZ54sWTRZsnHRha6moC0FRBa8DHURkdsoQh0n +xEPW8BayN77AAGdsRW0igRm+rOhD+FBZ7frhlgszbg4kpS3rPVqopsFryECh7gTblrfgpDqJUcEj +90DFmoDTaqCAuRtuSXpPVNu4TkGpQEWwYsVwRra3QOnhMni5iQ8CvSKBCwWXoYscCxvlKXJbUboK +Jk3CtAOEmxgR0jUHRVrw8Bb8iH8tuguQBaA+k/fIBpt8AAaHW9G0rhfMSo1dv7woRuPh6saLd8n+ +H7osqQNZmwhyVzO6UTCJwoWgNAtcjMjmyTYwE+fHcAipsdBLBkXbrj9g+UBRK7rZhYSGj4Nht+xd +snHOxOzVoEnAfQxXkUiAplFjXy9Oi6XdqHZgehPLA3a1nHDcGl20Jg/tYI4ccL3BbPuFWZzy0IfW +CCXvxTtOuNTdkVEkXq/ZPh0uHitGlwYEmeOgvIe8KjePSs0HijVXjAWoVpRjXkKUS8CHoLTtlbbs +YIFsybOxUZwrZk82upo9Mb1tr3IaVE/j+pkb7dnOaLb1RVA9zjGRpPXDymlYxfOHbrgraW1OqiBV +RLI3PgDbqlqj3j7tjB5WWyf19gPX3wKq5KhQs8ay1qXIDsZwvTWiCPsGsb2++WuRX+7gy5Lc1PRh +GB+axZlq9Ux36Je2VKvDCJFmDzFkPOxgCxNVa5+X6kdeZVs0OgmYd7ak6j3DmdrBNr6SAdqjoLQ7 +Wb2o9s6MYBE3jkvN05hs4V7VemdxfQfZpZmNRvegO76M63vrO/s/bLZvSnrbcce8CDY0QXzr3wjo +WsUl2IQQSmmXZKnaFlTgOSYTb2y6/mowedKbPlHMEaBGUNpw6OSWPVMUxIobzJrjy87sZn7w+uzZ +T1uTJ7I5VG1ooV46ByHUU42RH2wNx08avSsMULfH+fWCAMdFstaCOpLJDt5+qbZf7z6I6/tFf0R+ +YUdAJswkpceQLWqdYrQd1vaMIvhlSn4lR25IWssKZqa/csKdsHrQGl33FzduNHLCQdzYCeu7QX23 +1D5y40W5dWhHS7041pwBkEQx2prds7wp3tVoX+6ffNw/+1Dvnnqlbc2dIhZetPBLq3rvKm496s2+ +xJwIEtwH0COW1EYxnIOOg9qx6swVe9oYPPaiLcef6A4Se+BXjp1o3/J3zOJWrX6wd/qhWNrJUB4C +V66fBZVjs7g0iwskOV6smH033GaEME9byF4vmgSVeaVFxlJqnkAxilrb9ucFNuQI5BLKBgIgx4Ba +qtEvkN+IqQlSneHwTFhpnLVHN43hVb13jgemC8NEBQlqS7H7TrRyoq3W4GGtc45gOeE8R7m8UFJV +gElVMyd+tI8KrXXOhouXDx7/ojN7jOkttx4ElUOEfn78dn7ytjW58kqrcm21c/xi98Gb8fYTpAqQ +0PIXenGCj/DjpWH3O50TQChSy/bmeBgOoZLJ9qve7ElU3RsvrsvNHYoLebleDFf1zllrctNGdtkj +mq+E5S1BrWZyiqRWoyoga9UaXm8/+Pjg+S8ao0ftwdn1sx/70U6BbjjhUTE+9OKDZudqvv8+bpwj +V1MZjWVDSSw73qjaOQnrR5X2+fzgXW/+HHGsNHbny4eqOaQZaDNo7JZuLsLqg8bw2XD5ZTHa7fQv +UCAwdLLWCaon9d7j6fa765e/f/P137t4+M3Vs2/i5l4xXrQnV+3pw7h50B5f7Z99Onv+y1L7WDba +kl7XzFZY2QZADVcvpruvKq3jhy9/NT98Jbt92ewEpUW5sduePoraV5XBjVs7cMs77ckjXo7ytKGZ +7WrrdLj95XDvXX/nTX/7TbV9sXvytt7d80rj+uAirB0DqaL6SWd0PT/8Am90fOTqVoHzBbWmIcr+ +3I+34/pRd/p8tPpCtbq63fGjCS8HmlVzg3G9d9FfPusvns13Xu+ffA0JZ/sLy1sCbzH8Uv2k3jkf +zl9Otr9s9B4DacGVnFix3Em5cdwYXoa1g2Jp26/u1boP7GghWX0rXDnxll89aA4eYobnB1/a3lQQ +I0Wp8iyMgCerg7h8vHXybrr/crT1cnH8oTt5+PjVTzAzYE/Lmw22np08+e769c9vvvjF6eX7Um3l +hdPO6Eo1B7ozUaxxsbS3c/rtbO+L/vzJwdknFD7NhbrbB4pG9aPB/NnOg/dbD76a77189eG328ef +++WlqNYN8lstJ9Xe5eTgTWf6tNY+m+9/yat1XihWakvL6ebymmF3BvMnD1788sGz71++/+2f/yf/ +bVje86Ljvcuft8fPZH2smrNi6UCz5xzZthQAqWjWAxWWG1vVzlFzCHx4FjdORK0zGF/+s//qf6x0 +TjN5My5v7R1/iKuIF4Dxi0rnGsD79MXPZauXo4oOlFXzdLR8Pdl6u3XycbLz8ot3v33/s79nh4tm +9+Lw8tsHj787vfl26+TLk6ffX77+g6PTr//yr/+bwQrw26639obLF7O9L5eHb/cvP50++/ny8NXl +o/fPPvwBiHX35NXFi+/7q8+Dxsn2g6+vvvij8eGnqLpsDneL5bGoVi1/GdaPa8OHtcHlaPvlZO/z +Umt3efS4s7j2y1tRbU8vDuL6bqV1WGkeHpx/3508k826FQzq3WPLh7KaEhyuHsb1k0b/0XT7y9ne +m3JjWWlsFaN5qXnYmTxsDa9Gyyer/Rcv3/368ul3QEvbG/fmj1cHXxxeflzufzFevepMnxfDnePj +D6cPf8RLJd1uIyWmu2+Gy+ftyc3x9XcXNz/7/jf/cPvoDac0kfOl5jnSvta5DOtXlc7LxcG3bnEm +ilXV6Ol2rz18EDX2msPzUvOg3j2ZbD0vRltgsVLj2A0mrf7pZOtpZ3QZxFPdbIENt47eB+Xd1uAc +V2v7s/bwYrh6Uu09UOxZ1DiY7z3rTS8cf9BfPIprW53hyfbJm/78pto+nO48+f2f/2c4lRtMDy++ +Pn/+i62zj4PVs2b/3Pa2IGin8+ev3v7t3vhCkL2wNJlvPz5++PXpk097l9+ePf+1X9qLK6emO8nk +NMiDcvv64PoXu2fftScv2vOXLSIqjsazy/nWNSv4NBdBabvl/ZCQ+0mje0HQNRgud562+g9gz73y +UW34uNS57M4f13unBc4r0A7Ul6pXvHBeqh23hg8Hq+fTvXej3bfwfeXqYb13Uu1sDRbn3elVY3hW +be+dHD7/Z3/z38/2nvFyqdrcO7n61cnVr4+uvj998n19eLFc3fzVX/6nf/+/+OdQKQcXH85f/Hr/ +6ifzow/HN9+fPP5ZXD/+7kd/+y/+0d9U+7uZgu34W9XW+WD5/PD609O3v1seffHg7M0/+Wf/9Xjn +KXJgsftyuHyClLv5/Dff/Pwfvv72rxvdx8eHLy+uPyI9iuEsqiGpjjvjxztn39y8/ZPPf/QPVsdf +P3327cX1l6Y3KDX2Ku0Tv7wTVnbbw/PHX/7Rkw9/Bl6o1A+QeLrdxRmcYA77ySt9Tu41uw+3T94p +etlwWlF1CyGGtAiqkKC723uf/9Gf/dOj87eq3ds6/W66/6E/f3by+KeTw09B42FQe6Cb/XrjTDE6 +olKpN/c7o4uLZ989ev3LvcuPFtSLNdrZ+fx3f/Kf216v1TvYOX67c/LRq+zh2trD6/boIURpvX1c +bR3QvCdrFYAzBtUcPDq/+fE3v/grgPmzp98+e/kj1x82uweDxaPR6sXR1Tfvf/Knv/s7/wQY8uTm +qz/5y39y9PBreCJJ78AswC/3p++Wxz9ZHX9bru0/e/bh0ze/bLYWCgJd2vIqJ3Hrstl/dP7s97Xu +tSDXSvU98ClKwI/B+KtK9zIo7/TGl7/6479++e5nnBRDdCn6YLj1RXfxIqwdKfqo6C0/fvzDP/nz +f1qu7NjFCTKqNXvaW3x+9PBnujPkxFjR6pwYCWIQRMtKEyX2AmEa7b6v9R+raudg/8u4OmUly/bb +3fHVfOfl9uGL1d7N8fkXTjjM0WYQjyeLl+Pl697kKVjMr66my4cff/S3H7/9haTVRqsng60XzfHD +rQefelsvS61TRPmbT7//+e//ftxYpPO2FwGRTqL6HpJ2+/QdJu3y6qt//i/+5/0HX/rh5OGT7778 +8V+evfrN9ee//uLTnz549hsv3Pnxx9/97Jd/pZrdqLKHDx0vX/SnTybbL/YuPi2O3nrlrQ9f/+bR +04+G2+vPH412Xta6F43e5Wzn9eMv/3jv6vtK88HZ5Te6O0hmVGC+F8HWrTRnAa/hhvv9yXWvv7dY +XStG3Qeht47BiW60anTOd07fR41d3eltPfjGr2wbLlTESitO00wpx9csb6s9eMoIMfRks30YV7d2 +Tl4fXn1ojq81iEltMJ0+/vUf/eOwOu1Pz05vfrQ6elfunBWjmRfPFauvOiOMotY6EdVSMRpG1e0S +qqa2X27sDCZXEE4X52+uHr6H8lnuvTh++Ong8tPBxfujyy93Dp5Wq1t/+Xf/0f/0v/zvT7/4GcXF +it4xnQnSpjt93Zlizh9oevs3v/6L//Jv/rvx5BgSbr7/FUpjfvhx/+qXxze/gQjUTWivb4aLmzz5 +neLAcMejrc+7k5u90/d/+Pf/5vGbX9Rau5PlQ5aPNGfklnZ0Zwy6Gc2fvfryD568+L7ojRfbj/rz +C83pSlrXdBbl+kl/9mIwfSrK1Wp5VW8eyHoDUxc3iTtzo33THlVru4IcFhjdchutwdH+6Zsnb349 +2HoKf5EtODnKlPWSapSjyrI9eNibv1wcvX5w893zD39UAWG5/cnqkV+eFEvj5+//7OL5L8fbL0eL +J/Pdl8ATToapD4PqvmK2VKPR6J8hDbZPvjy4/Gr37HVQXyp6XG2uOuOz4fazxdG78d4XXuVQ0VvN +1k6jfQAv4IWLSm3fsXuSVCqVVsvDLyZ7r8rtg9ne5/3FE7PYa/aOkQx2MHHChRMtFLNB86Eglr/+ +8Dvy2z0pWZIbKDeic2wojaGkdRSj1WjvzrZuQAHj+aPrV7/dOv5xpXVz9OC7+dE7v7YzWz357rd/ +bfrDH36zQ9b6trdd6T6ZHf+s3nuYZzzNbI5mD+Gh+rObnbMPh1c/efLydzfPfjVevuqMHgXB8N2H +P9g+eEbzvmR2ZL1tuMDei1LrAoBQbp2YTvP1Fz8ZjR4o8In+sjO8qrTOwVzl5tlw+arR2D+7+tib +XiF1AbmG3QVIhuF8tni42n1sul1JqStaA+kdV/fLrTOvtNcdP2p2H7Q7p83GnuP09o/ejHde+bUD +J1ytl5Vqgtx2/e3zm5+F1W1WLIMf/fLu1uFXq6O3q8Mvd47eFcOtwfDBtz/9M9OsO8Gyv3qFolgc +fvXw7R+eP/2uB6God77/1d85u/qCJoa0Ua5fWsWBbFRpwYe38sOlUxxDkVreqFje70wej7Y/R8GS +jZpyzXEHtfoyT+ks75Hfp/ZWXulQM5eWC0mzylOWrASl6qTa2a609zrTh7BFfmW3Mw== + + + vKw0DoJwuJhdPHz5k+b4zPLHljcpRsu4chiUj6qd697ipVEcgI6Hk+v53qvZ3svZwRdWvBT0+jpd +TwU17HZ333z801cf/850761f2hYVzEYN3pz81g8TptMyTVmW3QU1V9oHUXOv2juRzAZQ5eDsa0TT +dAet/vnq6ANQcbK6iSozw2nQnJfLWzTjZfNyrmBUantbB2+mO2+Wxz+qDK7ghXk5DOL5eP68XD9V +jDFEu1Hsy0Z9uft0dfiKlSNcQLV2ouotSamY/kzzV8BAsl4RL8PSFitEk+XL8ye/7AxvRtOr3aPX +9e45AleJZ+/f/0Grs8qzTq1/OVi+3nnw3cnVz8uNM92dy0YnCCdfv/9tr3coStXB5Prs4Y9We687 +w0ed4RPDmbRaR4fH72SlXm8c3Lz83f7Zd432RRTvxuU9051ipP3Jpev3ECndaNY7J5Xm0e7R27PH +P7WLM6pgxX73z//iH5fLK04o6/agGMyLwbLZvd47/XT+6KdQ7IP+wfmTH9nBlBN9QfQUtcLzZZYt +SWJDlsja5vWjH3XGDxkBnjrgpDIrlGmuZjpLN9zN5Oz7Gyy8dhgfptIi2dvGeVCebriw3JHnDJ4/ +/WlzcsoqgahXJa2BrA7LB2FpVzfquayqqc24dlgs7zV6KJxzSe2Dghk20PWG63VNq9rpHUb1Xa+y +U+1dzPdfVxt7rebu569+en7zwXDrqlHrDE4PTr86vvhmQOzGcTHekvQm5nMwugSh20XwxauLJ786 +OPv44s0fPnn9WzfsT0f7b97/ejC/AN0w5NYhWVirt87bPXj2Ps3GptUX5JimTdvtTHZePHjy/d7p +O9irV+/+/OTyu07n6OmTH++fvneCieH2MSE4Dy9Xo/DAMkc0uaHpGFYjKE2hqOP2mWgMVXsEw44S +sP2JqFZMp7/YftPqERy2i0RFFChblEqeN8llxFSKIShRPxzOnk63XrQgv/WWrDUW26/2T79GIahm +EzKgP3veGlyRP59itzgRc96qd49sf6Tb/bX4H1dbZ7Otl4enn2x3wvGhotSqtR3UMurdLo6hVWCW +49qJZY0Fvqyb7WK4UK2hao2j6uHW4bvzm5+fPvzZaPEcXJAr6CznMJwlSJFu9UrNo+7oCvMQBuO4 +NMtkDTyJ8gGqu/5U07u60bOsocD6x3s33/7kzwQlTCQouqBpcjmCTKruimIlnzOLTvdf/A//69Xl +59msJIlBtYkzXNWa173hs97oCfljEVmtXt+HjspkVUwsD6GFunO7bjgqlWdPnn4cbD9gFVdzauXW +dtRYuTEi0sMABS5oNg5LtV1wmazXMOesEMpqTTM6xWBmk0lrvnr9/Xh1HdVXhj9U7KZqVIN4OIDd +K00lyY+C4Wz1aDK/DMszQYmzlAX4hblrDx/X2yeoFL+0GixeHF99hFAZzi+i2lxQ/f2DqzeffuXF +/WRG0a2ZGx9ElSM/nGN+aL4EydobP3GjHsvqftCd7T7bP39/9ewnR1efVgcvK43tZnP1zTe/evfN +7zIFU9G7brDthbu15qljjwWhxCOIakXVqogCctst79jhXrF02J+9Hq/eKma3wFhRadjsHDpeB+OF +LrXsgWUNLKMvcHE2xVM5UZZC0+5E5W04NagLlo+L/jwq73rRnGLd7visM3tU6Z4axS5MkyDGcWm+ +2H4Je5jNabmcbtpDFG+rezZdPK83T9a/AqOrWmMwvs5kFcvtVBq7s92XxfKOZvcZzqcZFzwoaVVe +rkT1o+2TT4cX3+4ef9Ub3+jWhOGrmBlcD8OavFA0rHatc3L27Oc7J59qrXOrOMLJRbVsej3L6zre +MIp32t3zbu/Kg4IyGq7bTWfldEpgCprA2rpaoymHbCbMm4E3+vj+V73GMpMSDa0RVfcsd+w4E8Po +KGojl7MEvtTvXZjmwHIHBVrnBNRsrdYmln/n/Mlw53Swfbx1cvXw86+evv909OR12J5aYa/W2o/j +Va22b5jtPG3wgqvrJT/olWuLamsVVEZhbdyb7v/0V39+9epjb3Goe00z6Na7y+XRw9rsiJWKeP1o +eFhrLPIF2bKBPFA+3mDyaLb/rtQ5l62mF7Z688NSZ1nqzMyozRux4dfLvcHO9fXg4Fz166pdI8vj +dpvhi6k0TbMWErs9ON86fONGLU0vOn4tbs6MYtUrdaLGxI66tc7y6Pzm4sUX5f5CNEpRdadcP1r/ +noKXTLKpJMcybm9w1upC5KB8YhRyZ/oobp7AJSl2V9BqilVt9BfFUpuRHU71raA33XmuGb183kon +OYkr2nrNMpqyXGI5j2KLglzyo3mpfaI6AxCHopVff/XTm9ffVLqLLCNTQjGs7lWax6rRTqWEdFrM +5XVJLitqPV8gfwmBon2nCErdb/YuKvUjLxh/8f77x68+DJbHmlPPMToUQthY2vGIlT3TrQ0WV7Y/ +NosjpDQ4WjVG2/sfTy5+Wqru5CkNqWU57Ub30IuHbjjxwlkQTcPKdLLzcLL3qNpetvsHncFlf3zT +aJ3mMvr9z3Kbm6xhdqqVbZY2E5uFVJKnC57vzWbzJ4PhI9MaZbNGJi3LSuwEg80Ul0hzqYxkOrPe +/0nSe3jJcZV5w//At5Y0M93TOVRXzlVdXd3V1Tnn3NPTk3PUBGWNJCtZ2bJkS05Yjhhsgg3GgMEG +2+Al52zAYGMwyy6Zhd332/d7z3u+p8Q5dXQ0sqe7qu7z/ELVvb+b2xtPzDNU1mEXFbUsyYl8vjm/ +sLG+9/CJM5duPvLoY88++7HPfvIr3/zaO+/8+q//+Y/3/v1P3/jej+++77Hm6Dqc2/DtOWAkHsmC +1s22auV+szPbH5tdXts6dueZ+x959J6Hbp27ef+R8xdPX7l294OPXr/3kc+/8oXPvP76ysbB9Y1j +xeo4KAGMCPmDxYBWYYRoIJAsV7qT0wvLq3uPnDh24frVBx9/9Knnnzt3/0Mnr9y49vCTH/nkJ177 +8htf+tZ3v/DVb37guU8ubhyRAikUV1xuhsD8ulaOJ2qyEo6nCr2x2YW1A1NLG62xyfH55enV7c3D +J558+pkfv/mTX/3m169+5Svn7r5vdHw1kWy6XILLLnlcCoGFE/GRcnmeJMM2GyXwsW5/udGbz1XH +k8WRXH1849BdF649ePORxz/z6qs3bj1x9wOPXrv1pBqpgJQCuHPaWYFNi0JR9tdEKU+Qmh6rJLP1 +YqXV6ExPz+87fOLSY+9/9smnn/7qt77987ff+cJXv3bm8rXpuf3lyiQvZjxe1e2RAYIYNg5qFj7Q +4RAwTI8l+tX2SiLXTeRaR0+d/8DHPvbERz58z4MP3P/oU1fve+jS9ZsPPP7+L3z9Wx9+4YXrN+4/ +cuYKJ2XcbsHlZGk6rKjVSHRUlkqJZDcYLMTjzUZzdu++4xNTk0eO3XnnXRcv3H3PZz/3+d/94c// +/sc//+GPf3r73Xef/tDzxeLokAkzmShoOl0fz2aXbFbBaiEQjyAKaYpOe5EQgigUrTNsNJ1ubm8f +O3PxnqOnL129+fATH3z24JGzvanD9e6GKGWNuaz/4uJprVsfX13cPH74+KVzd33gqUdfe/WVn7/1 +i1//9jc//cXP3n777f/6+99/87t/+8K/funZjz6/vv/OUnPNg4QRTzACrlxOJPV0ByzE1s7JO89e +uHT5iSeeeP2NL33xq19/8XOvfOiFj33pa19785e/euW1L37r69/4+9///uqXvvGBj37qyKkrifRI +vjjV6a/mq+Oqls1mynMz02dP7zz8wPWPfOQDL37641/91lffee+9b7354y984xvf/tFP/vSnP/+f +//t///yfcCa/+9YPf/jAE0+3x1bD0SYAJklIUS1VK7eXl1fg2NzavnT33R/88LMvvfKp5z79iWdf +/MRLr77ygzd/9Itf/vz3//Hb//nf//POb9770Ec/dubcPbn8qMQVGCKjh3u54pIP1VCvpCkpAO7t +rf1X77n2yONPPPL0Bx9+6ulX3/jK93/y5g9/+uaf//bnv/znP375q9/85re/ffULX97afy6Tm+L5 +YlDtcHw+HB/RIvVWc3phYe/BQzv3P3jz8aff/5EXXvzsa6/94Kc/+/mv3nnz7bd/+et3//SXP/6v +//d/oFu//+NffOblL2WLEzYHC5zodPJ2Y4akQlJxJVDMZTvre/fffPihm489/NynX/jhWz/76du/ +/PJ3vvnaV95457133/3tr3/y1pt/+NMf/r//879/896vX/zsS6fvupzKtBgG9DZmtxMIIglcrFyc +mBhbOXTgxPV7H3jk8cc//8VXf/Tzn33zB9/90je/9ts//P5v//Vf77737jvvvvX3//77T3758wdv +PdbpLefLC0qw6XQak5+HzThH6QIb0bVSpTIJmqQ7MrXv8LGb73v4Uy996s23fv7r3/3uja9/9Wdv +//J//c///Olvf/vUKy/feuKxu++5oWkNjiuzRKDfmlhb2HvnoaNXzp+6cf38U4/d+MobL//Hv/8G +Kvqdd3/xs5997+XPfezy5TPLy8uZfCMca6No2OuRGTIo0AHNH6rlSvs3tu69du9DDz/4yK2HP/bc +h77/g+999/vfe/2N177xja/96S9/+dHPf/rZVz7z8udfPn/l3vnlw83Ogt+fienVfHEkk60nk6WZ +icX15dV960v3XTz9r6+//KUvvfr1b37pnXd/+Ye//u3NX7795i9+/t57v/rPf/z1vf947yvf/vL9 +t+6bX9mIJOqSPyPKCb8YrhTqM1OLx3ZOHjl85PD+ffdevfTqq595660fv/3rX33vzTe/8s0v//zt +H//b795999dv/ebX0Cw//dyrr1y6cq3anCZwjcC0oFqNJcYpMsbRWkRN1wu1rbWlJ9/3wBuvf/4b +3/7mS5//zI/e/OEf//ynv/3j72+98+M//uG3P33rR5/97Mde+uyLB3ZOq+EyyCEAK3+gFI42ItFq +f3RmemLmyKHDH3j68U+8+PynP/vJlz//0o9+8oP//O//+rc//uHNX7z57e+88ac//u43v3vv1S++ +/uQTTzXbi4gvCMbNbqVdDgHxBgQ+XS1PF/OdfZvbT77/iY9/+uOf/Nxnf/jTH//xr3/649/++oOf +/vDtd9/645/+499//9s3f/b9X/3qzZ+8+Z2nP/D4xctXUumGIEZdbgJKK6DmtFA+ppeX5tYeeuCh +L3zxiz9880ff+u7X3/u3d//4lz+++96vf/Grt//6tz/D53z3e1/5wY++8ZOffu/pp586dvry8r67 +BH/BZMLdTtnt5DCEd9owCpNHOlN3njj54EMPfObzL7/8Gozmp3/ww2//47//8dvf/+6H0HY/+QEM +1IsvPX/u3Nm1le2w3iyVV0NSvFnu1Er1Yjo7Nj6ysDQ3NdnbWJu6dvXYI49cvHr3sbtOHyoVk8GA +SJMMgtAoItithN2KO+046ROj/ngpXupU2qOd9tbe1c2N5fmZkRPHVu+/ceLWQ+cvXw== + + + Onvl6pXjZ071J6fCekqSs+EoaO+ix8UibpZAeQpjQbgc2X9y79592USylUvtX50+f/rgAzcvPPnk +ta9/+XM/A7h5+6fv/uZnL3zq2VNnj45NjYe0uBrMUWBdfRKKyhIfPrTvxMmTl+rNsXK5MdntrM+O +nzq694WPvO+b33j97Xfeeu/f3vnmt1//4msvfv4zH37+mZuPP3Du4ObeVms8pJddLo4gQh7EP2wF +X4PZbKTbSSmsUoxH9y3N3brn/OuffeG1L37m1Vee/fEP/vXPf/7dpz/1wStn9h/aO9ttNIvFKo5z +DjtGUyE4UEyBgyIVlhSioUSj1Fqdnr90/MDTj9/4+Ecf+9fXXnjrre//++9//Ze//v6nP37j+Q89 +fPHC4Xq1gKEs6guQRMRuA0ljTFEeNvkIxB9V83E1PTk6vjg3s7Nz6Pxdp65euuvmPRde+dSHvv61 +1z732Y+/9MIHP/GRxz7/0nOP3Xf5+PZmNlWh6IDby3q9Ao6pDBtJp0eCaobwcXEtubWyce891194 +7sPPPPXovVcuf+ipx7/3nW984+uvPXrj9Icfvvqhx26cPXl4c2Wh1xzJZDrt3pYWbpnNmGWYwlDd +4xacNhz1MNlYcXt59d7L5z73youvvvaZDz3z2NNP3P/SC89+7zvf/cRzz9136eL64nKlVOVoBUP9 +LrfssNEOK+J1U6iXITFeVbPJZLPdmpqeWaF5CfGBtmTdHtblYnyIRBBBh4Ma2GOxDftQj0xgAZ9H +oFA/bRwCS0vRcFYLJn0eDPH4fF6cpUWG8fP+jAtRLDbc6WAwY52CanPiQyZwtSjuExE3gyGCrIBJ +CXOcEhAVyoeKFJ2JRoq59PjoyP6DhxeWl+LxOIyjzY5ZbCiYDpDKTqdgszN2By2KiVCowLJhHJd5 +Vo2oOtjRiBrMxKOpeKJQrPTHp8OhcFKPjNTrtWwmxMmYhwXXjGFBholp0Q7FJnfvsYPaCchFmUtr +UqyRLZXiqVRQTajB9fmFXj1XTkdGW/VErMCxCsdqFJX0IarNQliHfRazZ9jkMpu8/0yyYuiEX8iV +s/10pFiK565dOr+zb6OaivVrlXquMN1pzrQr+UTB5yEGB4ZNgy7rMDa4xz444LQMY4BdiMdP42FF +yuhgs6KZZDwncgGf2yexSkIrhOR4PlkabU6Mt8YVXkiFEyExQqGiw04PDRNDw6TTrUhS0e8vMEwY +8XI+D3SuHtGr0NQin6431maXzoxNHPZLUdTlDkv+dDihCkHcB4CJQxWJcrHRPRwIdi0W6o7/xwRC +FMd0l5OjUIUj/BElktaTiXA0E8uDfOd8hIBzASGpyjlNLYa1htMJnSKHIy3RX9l9hw1KxWTy2G0E +4uZIMsbzmWJ+bPvwFRciO12gLZMsl+OFAvhKgoi4PX64AyhiPCsbGLDBMWTyDJsx1CvTZFQNVEUx +zzMJio4aQVJ20mrHvGjQi+hwz1kqifmCwxbE6aJcHgGEDYHKHjfjcNAEHWekrBQo+P1Zj4f0ekiK +kDBUoChVlNMIpoD3x4kYtNJuY3GfG7Su1xvAsBBOqBStOZyM3U57PKLVijmdpMNBEJgKHlkSczQd +Z7k0igYCckwQtcEh69CAy+vy01QMaJ1icmp4nCDTZjMOGtjr4YfNyPCQ22nx2ofd9mGXz00H/VmB +DZGYSGJBp1MG922x0v9cWm63CRga9rhEqxlzGCuVBKtddHlDdqcMHEeSWj7X3d48mo4XbGa7gPtF +UhdIjYLLAYwacJpNPtynm03IrjtMpiEPjoZsNgYOaHm3V4HzYaHy9Y7PF4CzCqjldHZGVWvhQIHy +KV4X63XSY51VltIA7uCjUDJLcBVWqMr+CkZEnB7ZDR19O/zWH2gFwmOJ7GqmuNwc3VH1UYsFOE4o +pLs+r7x7l2XYSLSQVaXRHzvaaB8gyNTAHvfwkCefGsXQ0J4BN4ym3c6iSNAvV1Lp6Vh0zGGlTQNO +3AukKdislMclez1BFIuBa4avU0Mjg4PIkMllMjvNw65hs9sLvpWMs8aD6zGSjCeioIXGOSHDsBmf +T0OxCGlMaw8gqO7yBnbvtgwM2OFLrRaaQMMcneK4DJRfMTdbrq0NDnmHhlww6BSbkgMd0V+Hj0W8 +foEJN+ozDJ8ymbxms8diQbxeOZ6aC0bHpECNYeKJRCUUzrk9HPyuzQaAGfQgEUFqZPJbPhgIs8/j +AiPdhI+y2SmLFYOq8/qCglQQhbLFCEYjAcpQVAWE9PmCcMecTpHAY2qwTrIxk9njdit+f0MJ1Egq +6UbCBJ23OWTzMAHlZ7eTu42VC3ar2Wsxe+1WjMBC0G4+JAAg6XBIu27Hfbhcfo8n7HIZmQMkmfQi +ms0KUkH1IEEjSc9Mma083CtNb8fTPR+mwpUOm7wUqkEFDuy2Dxhr1XEw7x53QA/2vW7NbEbhsFjw +wQGXxUrBHTYmGOCxoNYPRaZcboVhdFWrEUwCats+TA0Z89sRHAlWC0ssHTEPeWhSp7mi0x20OxWH +kRaVUUKjUqDl8QZxPAQmpdLaH03NYngSJ1N2h2wyIYqY6Y0cRJHQnt0OnIxRVEpgM6q/6EOCoN73 +7LI5rfjMxH6CiJqHKYKMI1iEoNJ+pZPKLgtC1WKmrMOkD1GgNUxDbq9boMg4J9Y4seFXRzi+aERQ +In5RijJSzDSMWG2skQIqlKRgPRwdrXe3krkJmotzUp7hckqo5Q91STbvQnT77fWt0Owu9+01/gM+ +AotiWBTxhUQhLwdqg0OIUQaIhFFRv9Yh+JzNJcKPiWh5YemwoJTNcA89MopBqYfAE8HQOJ0c8OO+ +zZ2p+S0oLQRgjUjQdI6isrxQEeUWVDvHREPBksfDDQ66YCx8PoWk47xcC8enFLWPY7FUciyo1eBa +DAp28SgaAmDh+QJ0oter0lioUpyhmCSMoNmEDptptyfsdGtOl6pFeiC69gw4waGQQP020umgEK88 +DINuREQGKSoNIOB0wVnFUV/U7QkOmRGrnUXwVCDUTWUnWSFrd4hGvplHc3mCIO8pOg7dYTKTHFug +yeTuOywDu0F/qIoywvMVjztkZC+bSHATHBuH8/G6ZbuDd9yeiOL2BIxIExTujD4xdajamvfhIThz +hs5SRIIikiSRdLtV+C1gVa+bdzgANo3J2B5fLJ5enlu9r9TYdnpUuAmckEYxIzAN8caNBVZqLRQs +y2JJFEoEHnHYjTmoVqOw7UODHvOQb3DAYCK3S1DVsg8NQ61yfMYK8sMOFCMYS892w/+Jer1BxBu8 +419McAK4z49jmnmYMw0LQ2Zu94BvzyAGMnJz/dTUyokhK2Fx8BRflcOT0fxKurIWjI9xYn60tXz0 +zA0fHbG6OKtTcCNRH5bk+EZAm7E6FcAEr1u5bSj8NJ1i6BSOww2J+vAYIAlOqbQQJbgUSsdpsSCq +ZZyOU3zOr/WiqUVBrgJ0s3wCwY2FYH6QOkoBI0NeTAXmJQgDowYGnQODbpudhfJjmJQk5CkK2BYH +TgGIBh4HbHd6gl4sRTJVTqyKUlnyV+Eydb3qcnMWCwofBRiCEwmSSmnB6sb6KY5PDpmQ4WHUh4RJ +MsMwBYYt4lQSbh3Y3sOHLiTTXaN0h1GvSwRNxQslaEO3SwZQlZQyQemDJo/J7LPaSJdHwqmEP9hA +sBDDpaaXjsuh2q49zl27HE6HhGI6jscCaj0aG3U6xOEhhERVmk3sGfDePhA4vN6IqrYieocXMqJU +cHlk0zBuc7BOt4QTSfjqYm3v+OJphocak1qd1VJtDUFCwxbaZCIsw7THLVFECBhzaNBNkNF4aiaa +mvHhcWP5lTvAKbVcfbszuSP6SwBWJF2Ae06zaYeDcTlZm4W6vdBPBX4fAtVnpYwFJk4R9YUQj+K0 +88NG7gTj9gYXFk8rcnbXLqvJhAGKKnKLwNI4lnS5gC69DjsHHziwx2qz4qBVoClcHpXz10CiJJMj +Ab1iBn/kU31UHOcywcQEJRYwOq6o1bXVs8cuPuKjdJQIy2o9rI9H9PFEYlrWRgaHSYaMTvT2S3Jp +zx6AEQoqGccSwVC3P3WqVF+PxWqHjl5i5AIlZGLZiXRlOVtbLTQ38+0DYrCD07FEpP7E4x/uzx2A +lvR6JY/X7/VpDFeMxGYEqe4w0uBVAA2vEZ6TwoiMD8+QVEENjqjhrtMtmkxu1JgRZKzO8Pg0DI/D +wTBZUSrmCvOimA1rlZDeQVCNF0t+rcsrNR+VdHpVpzsAZwuq6fYi3ADD5TV9hKGSIBTVUB5B/T7E +T5E61JXdxiE+jSBjIJ8wMkqyaVbMAQVDF1utJKh3yzBOUwmGTQW0Vm18B2XTJouRkgEg6UNV0GZQ +fk63HxiHBrWJQmtju3a7BgYRKA+3SyXJgiDUQJ8IUpUXyxSbQckYzWdB3LqN4Cmd5XOCUnE6eIGJ +XLzwgCSnATRMJp/HowAd01ScIMKgtRwOjmNTLJsgSR1OJp4eT5UXxHArlBxnxQJORoOhBobppiHU +Msx4PRqOp3iuLgptl0sbtnA4Go5EuqB8QEvDdQ0NegcHvHB6BJELhnvJ9AxYDAvYFmM1GY94gsai +MKvo9mqCXNHjfdC0kpAMqHGrzWu143YHZwTI+IwXr0BbDo/EygWcS7qxUCgxLodHIonJ1sjh1tjx +eGGW45LJZC+cGCEp6ETVhymA20MWAj6zVl0RZCMnx4eEKOPuxSSpUKgsRZKj2ezYzsl7GX+OVbLF +9lq9f7AxfjDXWEuVVyg+T7GxXnvh1c995cjZ6y6viKGqIBREqRZPLmYLGyxfUZSa0aSobiwExtKc +1FbCU/HsZq17Zzg54wG/iSqhUA1BwzanaAUHSkQEuQSajWKzgXC3Upm7dPnWxPydDhd4n4KWmFBj +k7zaDYQnwtFZUCYuj5/isrdTdMLGGgdX0GE1ogM8bn8y3pOkPNS2xcJQREQNlBk+x8tVOdgs1dfS +xUUfHna6ABVxq4UEXScHKrHcbKaxTUkVzl+V1Q7oN5uNMN4Vak34RT02EU9MQakMGHHuPvgWQACb +DaxKnuNLLF+kOSPQhhHLQqDFylVoZOvtMHyMSMAV+QPlsFYbG13FMD/UM4CVKIBUSEGBmczo4KBb +4LM8l4RvtFpQhgonUt1IaoQSsqreY4QSw+aCoRbNpIwkKyM1N4H49NtpAKrNCJGL+6VyOjUBvOBx +ywgSsAOPD6EUmcKJFMVkAPYB04BWXG7pjjvMg0bSDoirFM/nJX8Jrh0IN6K3wJcPDlqtVmAKCQbF +AZiPRcErhWOTlc6hYGQknOwLwbocbvsj3UhmSgq2QV30q4v3X396dO4Q6HMwLwiYFG9AlMuBUEtR +W1Y77bLTOB51OCWzmXR7BBDqeqKfKiwk8rMkE1bUbHVkzZhsLOeMtQbRXqa40OxsjU/vbB66xoox +LyqEQg0jN1Usw1khUDaErkV70dy0w+M3mXE9Ot0YPd6c2IlkZymu4MXjLgSwqJAtzA== + + + SmqV5NI0n+ZEkK81JdwAHg9EG9FMp95djGb7OK40Wivji3dVekdZucH7m3DYnHKvs3b52vsz+f6w +lQL9iWIlDCsmEgvZwr5YctZQcXxGCVZBxgyDELXTWnx8cvbkzulbpeYmSkSWl3cmpw5Cj/NCKltd +KHa3SyMHx+bPLW49lK8eABVK0WFRyeNMFFQc8CZO52xG8IVkszPG8nAz5vEA9YdcbmMJp49McYFW +rLweSi/6yLQPVxW1zMtFwDGaywhywa81MuUFVW+BhgFsAWtmtTIuY4YD4/X6Pd6AeRi3WsEdKzaL +zwWemtSB5UPRvp6cpvgSyRb8wV65dTCdX7PZxcFBrw+NMVwJJ9OCWEINqRyjGCiVMiAhRcWsFuNt +ppHY4wFzl2bZfEhrg4G94w6TxYwOm3zmIQSgDJwFy4ETTzNsniRiDhtwtGgz8BwFmUexaV4qpQpz +yfz8+Nihu699MBxrM0ImV9sbTcPAtdojB0f6RzKVVZtHNpsxik5QwJtoWBSKFJM2ymkYSjqTKUzh +VBSuVxAygXBLi/cTxQU1MqoopbHRjUs3nnF5ZbhFyfxiwWj8+UJjPV9f15OTCKrKMlBSy2oDa0/h +RBQKLJaam9u43Jo86sXCdhtNUBEXolodvNlKAsgISjNV3Du3ekWPjYSj3VRxGqPDZiuKEloo2p5e +vfPijadOXLzVnT7C+XPpWGVz3zlFb5isNErFE7mpZGGWV9qp/EJvYkMJ5p2uQKa0qUWnSDonyQ3B +X3N5FSDcYnm+1lqDswIDDhJdVmv+YJ2TCzaX5PYqI5P7s5UZNyZr0WZ36uDY8vHm+GapvTeameb8 +BZaNfvRjr56+cAMlVRCHWnSm2Dmaax6QAyMWKwdj1G0trW9e3LUbTGtQVLup+kZj9mR77oyeX3Jh +kWCo/OxzL29snR62UOBqQ5F+pXt48+hDrdHjRnDcoEPkojSdGDJjw1YaKpbhq7zcAncGNsHloEki +RNExD6JCFxda2/Xxndmt64sH7m+PH2O5/J49SHdkOxTu2oyoVQy+Au4A0ER74mQ8Pecy0j9E0Ks8 +B95HAWcBeszm0kDQIpiRwg3qfQD0jwnDfRriDZBEHGS2D4kAV3o9oOdDAJ4EEYChtENxemSMCoPH +iSTHi40ljNY5qVBsbWeqG5H0fHPkUDg+acThWmkcVSQ54/XBnZcdRoCnZLHwbrceAMspFgAwRS6j +6VUEkz0+6fY0sHS+utKbvbO/dIZjE93uWqmx5KM0UF/RzFQoPsaIlXxltT5yIBwfBZXC8YVkZkaP +jUbi/VC8x8o1LxrlOOjc+MCQd88Q4vGqqcxMIrsQzy+HE5MEFQOwypZnRbXk8amivwIEVG0uHti5 +cuKuB2ZX76TFVKsxe+Xa48mskeydK68fOP6+qw+/OL5+XQqPo1QMhoah0pncvNXIecN9Rk6g5nDJ +GBFTwz0jH8BI5OZ8Pt3pEr1oGKWScqgZjk+ky4uBcL3Rnjtw9FIgVCfoiA/3E1wa57OcP5+vzu8/ +cTOVHzMej6Chem8HaNQfatkcss3BI4iSSY52uptAiyiq00KeEXO0UFTCY0p0NFma6c0cOXPt/d2p +Q4Mm0odHg5G+rLZJJg0eamiIBkjxSwVRzOzabbc5BTnUjyRX/KG+EhoFOQRem6INqPRhobUDF09d +fWzl4OX+/GktMQVQP2QG78NcvOfD2eIcSE2fL6pqXcQXo5l8KjcH3hb6yOPmc7m+JKTANu4CD2im +KKGmZ1djudVEdhnH0l5PSFEaPq82uMdhGsJvh6CS4CVBFDkcxgqgbn8N1Cycm3GxWBBqIxCdlDRj +YjCUlqTVCWOKWloMdDk/4FiZwHSOjlBkGEoIBwhFUxRZgsOHZnxYCmDWbucqxflUvm+k6g2j4IV5 +qVpsbNT7h7K1OU3NnTn9wMzijhv1x7NTs2uXJhYvlFsH+tMnR+dOyVrLbCEDwSZYXR8Qrk+GW0rQ +RcnfhXrg/cVBAGFj7xs9qDUpLoPRSZovYFRa8BurI2khywg5LTLCcElRSNQ7K63xA43x/fn63OzS +ibGZI0qwpkXatc5WvbvRHt9U46MuNGbEPjvFiNbO5uZMw+SQCeeEkqKN+tUO6CVerAEgu5wSSca8 +RgQlzvCFSHKqO32i0jkYz0wpSn5r+8T73v888CbcQxTTpEC31Njad/TGqbufbk8fg9J1uPloqhOM +9dyIenuzIWLYxvlQHYwJ4gu7XAInZBEjl5hwulVOasSzc5tHr16/9fGT9zwbKy5ZHBIr5OBWuJEg +jBSwGI6lRLHGCzUwOAODHoCmUHSKMpLhZTBBMHZA1n4Q7YQOCDA6sdXtrycyY+HEFCO1SL5EC2Wg +ks7kGZRMWW2iqo9Jas1IV7ByLrdq5NsPoohPzRfnEa+8Z5dp9x1mJ9wBYxH0OCfXESwyMMQ43Bq4 +KrPJeAJmt4kOh9/h9IOHQtGIEaONR9LlBRrXM+lRnAhbbBRcQiy3osZm5VAvXlyBPgK2lYznVA2C +ycLVgeYHqHTYeYddcDtlsC1w210OEXQplPrtWEI+FGo6jLgqDwyExc7BmTBCXjK2zKhEovV6azUY +qnNcamxmZ2LpZHVkbyBSo7koRuleVPN4AopSIbCQ08GCMpQDY+n8vkpzZ2z2gs8If2YYOhEMt0Aa +2Z0c2HMvWIZAV9V6oH45MdceWWs0lykyhPvkXGFyfu/5/ScfOHTy5qWbH652t0WxfNexazceeL/g +zyJYCCHiDFiGzGJ7dGdq7i4US+8e8A4ChhBJVR9VoJHRKHS3dZgGsQ1ezGXseST5g62A1vaDuqOT +OBEThWyuON1fOUkJBZcrUCytNVpH09m5ydmd6eWTrFRwOIWgWrj3kQ8FIiNDQ5Tbo3EiaPIexRad +bgWkPtCHFumCg7M5GF4oRJNTidxsd+LA0bM3FzfPsf5KKNQ6dvwq+D6XRwmE2vHUVDo7n8wsckLT +2A/LRtFUBIQW8NrgEOjnYKqwWO1tJwvzoNBQTI3F2w4nZ3OwUFrQBKuHb/aXLtTGjpJcfvceH+6L +HLnzIUpIASNAwTs9ugdJyIHRbHEzV9oeNJ5x2Z0OkqQig0PI7c3dRDe4daao6pO81IBvtFkwn08G +m2yzsggaIRnws/XplVM7Fx9zwRWxSQQJIogxe03RWoreCyXntPQizmYIPFLIzzAcWG8/DzjP50Sp +JAiAVCm3SwbvPzBgGxx0DQy4zEbaOXk7skx0OwMEFsXRoNNBC0LOH6rHMuOx3FSpvRmKjYIXjsRG +tGiFYAIUq1KMJghpXswG1Iauj3lA1jp5hgyjWNDuoEGgcmyapIyIP69XY+ksOGvwRNDsbo8M4AmE +NWxhgZo5vphMTwVCNQwLkHggGM4H9Fys2GtMbI7OHi1WFvL5mZXVU/nKJMlE9VgvW1kX1FYkNZ0u +rSnapNebQJCILJd4IQPiyg7e0MreFg9BmkyBv6DpAoaGQV0Pmhy7B6wejxzSupHYTKGyNbd5N2iw +gFJY27hLS/QBvhxO3nN7cQdNZ/TISKmxMjRMm00kz5YAFa12dmDIA4fdyXNCPhjuolDqXgFaj6Ki +TqcAQs7lUzzGLNBsq7N/cvYoeC5RyjY6WzSTdrskm4Wx3A73tlkpmo44HDRGhNzeIEVnQ3pPgpMJ +t1mpxPnLrd4WL+ZYLt7srNRG9sK/oHTG5Qu6kYDkr4Zj4LhXjKAhMIBqMxyb0SIzidyCpDSttgDU +ns3KtBvzkxN7jZg4M+byBHilligtl9v7/cHOwKBPC1az2Y7Z5Nmz2w5oAMJAj3Ylfx4awW5l3G4V +Dl7IcVKeZhPgy1Kl1UR+pdk/kSquqpGOB5XVYKXR3varNR8WcTiDYFodxmZ5lMVCDA/j5mHsn/sy +/DMNj8CSqFcnfXo0WJ6ZPUiwUVZMNSf2Hzrz6OHzT7RnTyrRMYpNhJTMwvTm7OxxWam4PKLDJSDG +28YwhgZ1rYqhitNJBvwZv5QBw4LhCa8vabMHbhcwbjfe2ZFDQ4CNGKAouBtBrPN8FXyEFw1wfKLW +mZ+Y3VjYe2LlwIXV7XNbR+6emD+erq1idLRcmty7fooT4m6vIMh5WWnSbFVWRlA04XYHgIvBXHvd +CuLVUDSOIhE3SCyPDDeZY9KCXGS4qF/J+rAATkYIOoXTKV6pqFqtVl84evy6FCiJUg6cBcNl5UA5 +GpsIBNo0kwUxHNHr5eKszcjBdlttvMeriVKVE4ocnydwPRSqAOrCfwUdBZY8kZlv9Q93p46sbV+F +v0Pvt9tLy+un/xku50MCmDEVh0Y8EsvGcDRQrEwJUgZADAoP2k0M1GKFhcb0yeXNe2Lx3srS4S9+ +9ft6tGexyjRbA0+RLy+fvvj4ifNPSsGRPQModI0gFOBboK1MRsYgY7OpfmUkGO77lQri9YNwcjo4 +p5O3OTirkzdZBbOxkYeihlqCnLU7aTDRNhtpsWAWY+4ZhxrTOYD3YwSdFRRwRhUwXNnyfCQ7FstN +55sb4fSMqLVBIbfam6sb9wS0htWI4DbCT1g6g2FRjzsAhAgsaSSTG5uj0ca1u1SP048jqq4V273F +UKRebczPbpzO1maytflofo5VWhiVDAfL68snFpYuorc30XC6OJJM8EKZZtOSVCSpuCRmcrkxggiB +1/YAejAVlqtRTM52O/zZGAUrBT0OtHL7bbjo8YZoLiEoeRjfWn3+mQ9/5qXXvzU+dwj+BWAzmp5s +9w+U6yuj3a3Z6QOqmlUDBSVQkf0VRW0RZM5mlQcHjC2WTEMIlJbDzg0b77A8gwPOYTNqHcZxVAsG +m92RrdnFY1YHA6oGMTbm00S1ksovZoorSrCBE1q3u1qqzLmNlH4ex0GRGq/AwJhn071iftw06DUP +oTgWAX/nQ9ThYcrhgJ5SWDYVCjegMIzHg2RS8hejqb6iNXixwAllgO5uZ6U/tmW1snAaNBUFJnU5 +eJ9XpoiwD/FHY00WPPKQG0VA84R5qeDXmioAiFzEsUA2VTt58m6AR5av5Qrb+dJWKNRJJvvR+AhB +Z0CEy3y2kB2HthoYdN3esyApiKOzC9dnVq5KSsNkIsAyALO7neyu3dbdxiYavN0RIogsGC6MjiC4 +6nILe/bY/wluDJ+J52fB9IHXjuUW9eQszeWTmQkt3vSQfiVSL3U22mOH1/dfO3HuibuuPrN15CYr +pDk+BTIDQcB1BoctxOCg22xCXE5AVIaikw4jJ4cFKnE7eRILYLgiqqlmd+nIyWv9+f0e+BHIMbdQ +ahwA1FXUajjSFpWawy2TbBKnIl4kAJBOswVBrFbqm40OWPW2xcpjwCwMoHqZpHIud9BiVywO5fYG +fxJO6NCqTicL/eL28OFoY37l+MrmmVJjfn75yNaR8wG9xPLxcHxE1ZsLqyc6/f0YEUF8UiCQWlo6 +msmMwG+Bg3a7g8azRCTG0CnEE/C6ZbPJN2wE5Rlhj3CNw2YfSIJItJdITcSTfVFKrQ== + + + rd/V7GygtM4Hq6Xuoeb4iUR+QQ01ZxeOV2oLAFNwQ2KJ8VhsXBQKQI42O20yeXfdYXXaWBQxMHlg +0GYyoV5PAEECoJdsxhsTgcRjdsOrer0+4NMU6IR8aTEYNN5ewflQRDTgLxgZboMegFO3U8DREIEZ +77gtwz6HDadwzW4HYMdMwzjICYlPiJwuiQmWTURinfNXHt/cf8ntCeB4QhDKwOnp/AIoWAKVWDp0 +O/kZJ4iY8TiULfJsQQuDDk/YLKQkRPVQCRTOHbusbq9Bc6B8zMZOWJjFSjrdIvCOachjteIgVADl +wNG4PQptuK04TsUYoQCtl6ssqVp+69C5meU7K7Xlbn97euXO3uxOPDfD8ulMtq8EC7dn5ihwBwYH +jBlHBGokg6kq2JZstb6OYGGzGfG4BZpNpkuzG0euHjn3SHt0+8KFhy7d+3Q40cOpBElnCColyFU9 +PlVpH+vOXtCSExyfrDf25morwUhbVusgpK02I984EOiB+9g94Ny9xzloJkiuyikjOJ2/HdMnsUwm +nZ+jmAjoyWR65MChc4+9/7nDJ6+mKnPBeJ8TiysbFxf23iWHij4iENK73f6+UmVe0+qZTFeS4jAc +4HwpOgV6xmY39hg1ds9xq0Z6AwbGMDCwx0Atp52RpYIa7NJsCSdSul5ZXD6cSLUoTtdTvYmV06sH +7+5MHyt1D0uhjtMl55Jjx8/cj9GhYSvmMiYng803AvRsw6zPrfr57NT41ur6mT17nHt2W+HzgQSD +kT7cEJyIA3aVS9PLa6fBCyO+EMVAO8doOob71GAQUD0GMM5RYVHKOOy03W7MnLGYcfgWj1tCPLJp +yOFDBI6LgRuCSssXx+ZWj04t7MSys9XmXkAqjk/PLp+i6bTDIRn5/1bWbuW9SFjw12kmCT1lNnkB +CaFuvW6JxMMECvoHhy81DyEggzk2tnuXZfcu8647zAN7bFDVwNF+IcOSWrUyHQfjYCMUOeP2+lkh +KwYbWgyU9kKzv1Nr753rr3zxS9/dOnwBPKMcqCbzU5HkOFy4Gh4nubTbK3F0dHHhTh8WHhq0D5sd +Djtmt1GAhKAqQc2KUlKQ0hge4YRCMNapdZa745ul8uSVy/edv/qQFm9QfC6RWYon56vN/Qsb1ybm +To9OHg2GO4loZ9+Bc1Iw4ULBWuoImgKeUtSu6G+7vSGbQwBTBg5l2C4PGxuB4WCRwGdF4jNadALM +2v7tu0ZG12S1oMVHMuXVWvfw5MK57cM3Tl59ptrbqrcWj9x5dzg5EdKbilpj2DT4YlDFgIeKv+X2 +ylab0XFeRJOljqqOgsH3+XSb1chk5pisxQIg4wWRiSAJIz/TGzBeDwm5oN5gpRTNxeBeedGorDZm +F0/2x/dBbZSr4yQbFqSEFqo6jUH0u1xBh112O1QKi9ZK893O3oHbD5FQ1A96ACVijFRmpBK0Xm90 +Y3xiWxCzPA9EWVZDFUnOM0xMCRrJSCQRKefHYBxtNtxqwaCiCBQaQfO4JKuZAEzTtVIyYazH4Wm9 +O7a2ffTi9rF7teQMyRYRNL60dPzzX/haPt0DAWmz0gydlISqJLUEqe5yyyAzFH9+ZOKQHmnYbQSU +k9WEO220zyNhXr8qpykqBMDOMZlhs5GyOzAAboJDvarLJvo8QaD+WLRz9d7HHU6GoHRGzEihRjg9 +kSotZAoT89Objz318W5/HYi+3t4EWoymJqG0GBHICyQEF1FLDz70gqRVdu0aGhywDA26huGKbCww +C89ER2oTO3deUbSyF1SBlOf82XC8lcz3m2OrxdYcxcej6dFCfV1S6pre06J9VswFgjVRKuvhkUp9 +QQ4m49m6pNadbhVIASU0m1MG50vTWUlugMPFyOSwXdwziIDo8qC6EuowfE7gM+urp7q9VSVUjqTG +y+3t7tSxhfXzh0/cO7a4E82MTc3sf+6lNwKRDqgjgDJBLuvxnqqNSfKIP9BFcc2vFGvNvaJcNJ7S +OJR/JoLCQZIZliuZjdfZ5JDJCzXmcvvhNHi5Fs/MNUYO+oMwLqn+6EahNM9w6U5vbXRiUwCX5PXj +ZBQckCTmbVYe1CB8rNsd8riCHrsALA9wYRoiVLXqV3I2YDELIwfbnekTufq6qncQPOL1herNJT1W +wwidoJJ6dDSdnw1H+pII/BiGinLYGZoKOx2Mw3jRFvZ6FKsxHcJP3165BlwpSzn4cD3RmVo+tbx9 +aW378tbBq1uHrvR7swwJtjRIU3Fjbqfb2LOJIJLGbA0iGtZa+cJcOFRxWEnU4yd8mtNK40iA8Klu +B20xozSV1fVJD1AeHTQ2kNqDuOyi3Qb6JAXCVRSL0Ugdw1WKjuBkSJCysez42NzRjUMXNw5dHVs5 +hdEG5I7NHBPUKgGdwmRwMkmzWY5LgT7vj6+Bc9y9a9hhobwu1WmHy2RdTg7xcOVcfePgKcafcKPB +aHYmoLfgk+sT+9PNvay/JEnp4zuXVjdOgbJCUcCNfCQ2MTF1dH7hzlhiQvSXG+XRD3zw+ebovl13 +2CxWwgVI4otEoqP15rYaHvV4lfWNc+F4e8+QZ9hKeYBlcCOzTgpUY6l+qTS5snJ4auGIFw+IKtzS +dihSk4L5cmPhwM49xy8+zkhA+rO52irJ5RE0jJFxNxJ2eY332uncbKYw60GkwSGEppNhzfCMKBJz +uUJDJsZkpjxeedDscrhoDNdCkX4sv5ivbxQaG+Cas8nerUefP3LqptMlqeFaNNPXkn1V7wJuIz7V +45H8crndPchyRbOZMp5XG88GuYEBL4bGg8HO2Oj65au3WL4ASlIJNUW16cVToDMzpdWl7XtC0eb0 +zL4LVx5tjWw4XYoxPdKrG8H7WIQkjfd9XjdPExoIaYfTiMgeMpE2h+zxRYL6RKm6Hk+0+2N7l/dd +OHjmgYNn7t84eiUU67qQACekS7WlVn8fFICiFsHtEmQCww2gtlk4h01wWBmAqUJ6UlUqu++wmIa8 +bhfvMt4Xcy4XKEOZZbNrW+ecLv+//IvdZCJBJ8tKO6T3Ybx27/Y4XTyCKj5codiorJVLnb1T6+da +kyeEUE8IVqKZiWJrHSdjmtaNp2ej6elEdkHR2ygVHrYZgahOu+BxijYLBag4MOiGSvChKoKFnF6/ +3c37QyUlWiF4PZ4fG186VWisFmpLjZGtShPMVB70s89YwJLnwX2TMZKKsXxSlDPt1tzps9e1SHNg +j4MgdDXUEOUSguq3U/tiOBVNZsYYMQUAYrWBgARi0iWlBNULIrCYa6+vH+yOLfswJVdZnF2/tHXk +/r377x6fO9ybOhBJ9RLR5jPPv3zt0Y8Zm4thkVp7e275crF8oFjeHwz33F5l2IIm4g1RysIY7Rkw +Qp6HLbLTreNULpEaP3vx5uV7HwPTanXwTiTgI+NioFprrTbaB8rtIziXg6pLlWYAqzEqStJpnEx4 +fYC9oXb/iBysW+wsiuvgx2+rOBVqGAAQJCtJhjL5UZBVTqcsBiqF+mpr9NDK5rmpheOgOf1y8tL5 +e19+/cut7rzVJrBsEVCU5ysoFoVhdThFgc+SZGQYXLZbEG7fK04qF5tbi9v35Iqzq4sHPvLRTy6s +7MztPbNy5Hp77nRr+sT81tW1fec39p8r1pfKlZkvfOX7Dz36ERwLBuSi318HBGOpRDjUVOWq1x3c +swcFxwpCaGjQ8Mu777AO7vEYRtKX8Ae7klLL5Wf8gRIr5uVQS1AbstZVo+NOtyQquVR+vNXb8IfK ++fryyOyxmb3nZjYuja2czza3lEgvEesf37lv6+AVRsyxQilfW0uXVqTgFC+Oejy6xUKBjbLboV8Y +8+1pbB4YNTIKji+Zn0wUxsqN6fWDF/Yeurhz9r75vacKzTXWX8XIGAgVXsj7fAGnk/F4g7xQaXT2 +98aPJTIzjAASXUCAdxAFjBU0IwloKTWD4dlEelEKVGBk7U6OpCMOJ2d30AwXV0L1VG6iWJ2BP1Wt +xjB6sbbQ7G01umvx9GSmNJ8tzwVC1Xi0fvDw2fm1QygejCXHc9W5WGY0EG5zUtXh8kNrYIh8+ND5 +YnEK+MtqFT2eGIKkEF/K7Q1nsuPnLtzfH987PIzTbFpLTiaKS93JY2cuP3n9kRdn917FqUyrNnNk +56IgJaHGsoWlkcmzkwtXys3joUjP61N8iHLqzmuV2ooxh9lCg5v2YTFw6In8fKV7AKxKu7kwPrEB +eE5SCU4uCUo1V5gZnzte7WzHkz2AzVyur6hls7F7L2axMCST86udkNZzuwM2GyMHyqXmXkEughqn +uSQrZXyYqqqlYnlaVrKj04cPnX6o1ttOF6dFpQBnyNCxsN44fOL6ox/41NzSCTBWarDHsnm3S/a4 +GKsZNQ8ZgfamIUbTR2Eg7rhjeGgQsQxTDitYBo3mSnD+CBIKBqpAxzgVr4xsr+/cPHzuidH502A9 +Ks3V1a1Lpy8+Njl98OzlR6ZXjycrk6MLx0AxxUoregIo5typu25NzB+T1JoWHSs2VrOlRUWfQInU +P3dbGBr0EriO4yGXMZOWwckIJ+UFfzGaGY9n+1sHzp++8r5YvpdvzLYnobs30+WVWudIf/quXHkV +wYMoropKhRZyAa0djI7LobFgbIb3twgi5THeu7EkHSe5nMuno2TWiKJl0g5ja4NYMFRFjSer1O2F +56PtsaPj83fm6+uMUJTkbHdsI13ok4wez01Pr549dtetjaP3JYqzaqRGMCrPR+YWdpRQFqNUXinS +QsGATS5JE5FifiwSaYBudBmp+MbmLACYHq8WS/RLlTmON1YlEAQo9pqslv1qsdSYn1k9mS4voIS+ +sXjwofd9QNeLJKm3Ro40e0eLlbVwdNJuPJ8hwOKdO3Nfq71iMjaZNTJUlVA3lV+q9w6XWlssE7t8 +8caps5etNgJ6LVtenVw+f+rK00fOPxXLL3sQjcDV557/1MbGCbtL/ucOI6o2Hk0uMmzRZEIRr9zp +rhdqK8MWyuMJ+FBjvoHgL0cSk1qsL4rp85cfuvfBD0ajHcQXlPwVPT6WLy+ubJ49e/XJ3uQxVqjQ +dEb2N5zG5tHuXbsscJlWCwvoSlJ5pzO0Z7cT8Ujp5BjYyWET2AcO8UWBFh3OAEtnQNfB3VO0Rrm5 +Xu8eoIWKEii0evs6E4eAMo7uXLrxyDPN/lo41ds58/Clm8+vH35gbvniA7c+Pbt6IRBqFbPT2wfv +iaQ6Nifv8qig1gQuhngFh7EbkZLQa72RvYKQcrl4HxYUlVK2tlLubU+vnB5bPBaM1hbXj43MHMo2 +VjL1VS01JQbrjFyQwo1sdUlL9b2kRvApH1yd1ktWNlC+4vDoGJ3l1Xo0M01yGV4tc2qD5Mq8VKG5 +As0a9tbllqD1KCZCMCEo+PmNu+e37u7N3FntbmfKizD0sXhz7dDFSLYfz03Mbl7JNjeV6Ig/VAXH +urS8gxGKw8mm8wtqeITjssFQw+cLO50CTUe0cIPjC7t3u4eMd3MyL6YKlRVVa3k8QQ== + + + h42L6E0Mg9/F3W6m2ly4cPXRi3ffml87mclOBEMVj4fDUb8oZMBtmY29gFmaiZeqC6XSbCLRs9vp +gQEXuB6fz8gwIakwL6RJWqfJYKXUD2kZs9kD2n569dTenWtj80cTuRmSKXi9Gs/FHn70yZnZ/XaX +f9jCGMEyxvYQxhMYkHMEHqpUZ9RgedcddvChFJnyB+qy2pKDHeOtul677+YjV+65JQjAnsnx6bPN +0aPZ0jyAoR4bRdGY1VgCwLfaWxQZNZkwHI3yfJVlMhQR8SHanj0ep50a7Sx++KOfs5ixQag6KwuK +QlHb0dhUPNrl6dDYxKrszwBn0VxNCPZIQi7X55uj253x7cbIWjI3HtSqtcbS8v7zi1vHO+Nr6cJ0 +LA1I0gLPq4frvf6molaMqSx8lmNTDBWG0jKSAbwS/J3nEnY76bBToAzD0c700umj5x5f3X+lN7V/ +YXbja1/51uXrj6ixdjg1UWrvTxaWCvWNhb2XTpx/dHbtTLO7fu2hZwLRnssXjmSmS519td7xzZ1H +N0+8b2LlrnZ7/TOf/9YzH3/di0dsTuX2HnkKSqX84dFEZr5WX7hw8fragbva04fGlo53pg+mKjOj +s4emF48fPXXjwo0nM6XZWmvl3NWnrr/vI/tP3DsyfSyanuCkIieUJaXt9AA2MtDmXh/4o5QoVYNa +k+VznFx1eTRBLPlQv92JoYaoa/hDLUmu4HgM6EkJ5MenDwa0cjLdqDcms8WZYGSCEao0naepFDiv +f+4iDSWBIAGciDmdkskEVpqjyATq04DuaTpGMzGGjcuBYiDYAFU2bCXcHoEA++YD8y77A5lIrNWb +ODCzdEoN1Ug6jGDGmo7bM+4IjzGxKsyy6aDe8aGayyk4bDwgrcMu2G2MF3yfL1hurc4sn+iM748k +JwkmbXfwqr8QjbRxXIcyw/E42L2gWmfohBvqk4r9c5WW16UM7kEGdrsG9jjhRxxVScx4g0ZR0T27 +7E47a7WQxvaIQ97br2BYh40ShCRJhaBTEtmpZH5B5LVsfqxUn2/1t4rNjXCsJ8s5cI6Z0oTg1zkx +ENBykpJP5Rdy1XXwek5jgmtI8Vdlf/H2GlvCWAPoFkki6nLwcLFmkxeMMEmGSUqXAoVYdrLaXJuc +Pby8vP/shXtmlw40e3u3j91Y2rrnyKn3bRy4XGnMh/SyHmlUK9PH7rxbi4NfmBybO7G0cW5keidf +m4+kuopeymW6V66+78yVB3yEHo5NKFovnpnfPPrQ3qMPFCrzU6Orr772pQv3PhROdPLV+fbk1tj8 +gXPXH/3IS298+o3vfODFV0+cvP7iC688/OTzsdx0LDsdik/mKuvTi+eP3fX+pa2brFiWhEx/4gA0 +kcsTcLllgo6CeQzGpnpTp6OpCRB1I6MLspxXQy09NaroDRCTUqDe6h04eOJBwZ/S9Hw4WueVamv0 +8OjMWT25iGI5gsoFI31/qA3eLaCkoR6AW92uoN3hN94pWDmGzZSqK4KU9yAB0AOTC2ebY/sCkbYM +JjFQ8GEixYVRQvEiHM2EeCkpyHlRyQe0Ci9lXW5O8GeWN0+XqjOg/UR/xYeoQB9ejypJVcSrWK0k +gACUlsenMEJKjfYLtW0p0GK5jMjFRd6wlgG14nRIw2aKYeJBrc6LJcA3kJEesBgDiN3Gg85BoWJd +fgwN2aw06GpjZqBDpMko/Gi1UNA7Zgvj9ICqiTBChuISWrRRrC+geDQVLaYyHUFORuItLTqqaj1N +H0lnppLZcV4M+/26Gs5TjB4Mt7XEpF9rAw2xbC6q9xOJUZuVcjt5zBfwekGT8KYhz+1MIQ+KhMD3 +YViIF9OclGt21jf3Xzywc7nSWRD8iUi8Nr24k8r1CqVeKjvCiWkowkCgqqo1PdKCFs4WJyvNRb9a +YMQ8RuoEEwkEc3q4lCuMRZMtIwSyAvU2Bl0wMXOkPbKaipX6zf69996cWtwb0goTU9unLj9w6f7H +rt/64NX3vf/Sg7cOnb48u7hx9dp9x07fOzl9+M5zj0wsnZtavri8cWlq/hiYVoqJxSP1G498dHrl +2JAZt1gplk/LwWa6stUa2+HElCwmHn7kaU2rgEDy4noEjHNzY2XftX0nbk2sXBCl1LGj5x557MPt +/gbBpqVgixTKtNgYGT9+8ORj9f4hjNAuXLjR7K7YHIKxJbrD78PiFFtodUGHHFeDtbH+xtzK6fbo +gUpnVQyWUSLGy0UlXC931jh/we3l4bpYIS5IGYoNgwGh2GQw0hybP3H3rU/0pg4qSkmLjiDGIhHG +eKXrNJ53gWWoNVcFMSfLqWR6RA62aiNHgrEJigXrBPBbkeQa0JnLFaCohB5rJzJ90V/CiKixTd4w +IJIXBhonooCxxgIiszGZzWxMIzR2uAMxPzCAoKhu7D81hLl9mhrp6KmJULynhlv+YNPpUoP+JM3q +dieNU0FeyiQy05nSaqoIBrAi+1PJVEPVKx6vGI50Ku39hfpmtb3vdiilkb9ns+DhQDECN9zJmExu +05AbQAy8ME0CQac4Ot1orZBsRJLTYajk1rIa6wiBfFBvVkCy8lGXy5gIxArldG4pXVxTwz0M01Ff +IKQ3WTFnttJeRGPZFHRTNNmTlRKG604Xb7USDK2DKnA4jZkkFKGqop6JFHLpliTFQ4FUoz4xMr7Q +GJnI5LuqXg4lm6nSRLU9M7m0v1CbHx9fP333ram1U3AnVbXA0jqGypiXyUTLm1uni/VZ0M9aqJuM +T+qREX+ggRLA+ERACmxvHyZIneWremKm0txa3nf3xpGrs+tno6kxvxC779r93/rhzzYOnafFYrqy +VugcHl+/98KN57YOXa42Z3Q9+8T7P7R9+KLL4wdzF9DHM9XNzvjxnbNPZQozyWjz/vv/f5Les0mS +7LoS/AMDdFWq0OHhWmvt4eGhtcyMiIzUujKzRJbWVV2iZTVaogWARqPRaDR0QxBakBAzJAgQA0kA +QxAguRxyqdaWO2u2NrO23/Z60SysrKoyIsPfe+eee477e/d+/IkX344lFbAnCGbLamf/zIM773vn +9gufylW3B/2dD7/z1e78PoJoGUzTrE5veOnMtfc/+dJnVrfvgbG6/8SHGq3tqbA7DxaLiQSRB1TU +6ttbJ+5oSvWJx577yrf+i6LWOLlnB5vw7W5h59yN128++GRn4RKBue977s1n3v/RfGkcibGzEQr+ +RBCdIvOSPJgJe62yVy7ce/Lxl4BAjh2LHXsk9t73xI8dw5BMzvW3CdzZ3Lk0XjoFtlS3gffqJB3g +VDGBwNqVwWQxtO26TRzXMPg7n7f8cbl5YrR8/sTZx73SEkWZtdq6X1gOe55mDNCN0ZgQbo/ksoZa +xDNCOkGInJ5OkskkS7J5ii+DnWHYMsUW0xnZspog4Qarl85cf2H33NOj7bv5+mEiJRCYYlltDA9v +/T10+lImrUtitdLY5qUaREQhvwiXlMFUmO1oQga3GJbvwx1DqSfD/SRKpb4JctdQ6wKbRxGdISwg +n1JpxItuMklwnAeEY3qtycaFUxce39q/4fnzxeKCnx/RjCdLgWFURD5HE4bI2DwLHxHmIhR4K4Er +Q8jTlEngVjqlaFJRZLMc7YIlhwCXxAoIZppxeTEnCIFu1Iq53mh+uzfYgYwAF7+0cb07Ol0oD3Wz +rGmBYwVZKzC0UvjsPspJQkmDCxbyFGVjqIIhIqSnoLCoWAvJlJEvb5Yau443XNm4vHP6Tnt4yDBu +qzK4cPFurb7KUEGxvJYvrzj+vGbWLKcBrhycrKrVaSY397A5BWhFL7sSFLYMsy8KgaX63fZksnwY +nlJsHeQbB73lG73JlXJjI1de5YUCS8iHB1dOnr2rajWQgrazwLCgvgJdbSRibCJKe0bj5Zc++oHX +3wYvE/ZXjcqJjM9IrXLzsFTbcc3KZ7/w5Vc++FYixk0dzyTisqx0q53zk4OnUiklneBkAdaxT1M2 +kAakJJh80H6j5SMQQhzMnpTb3b7Q6W4iGR1DbRCxvFiGycFRIRUn4pEMjpCaqGIZFM9QopRvLpyz +c6u6vcjLDZF315cOz51/LF9Z0u12rgRmeYdkqgii8LSlyXkkxWdSIk16LJWT+LLnjcCX4UTA0QVT +qRtyZaG7tbVzI0PYkFZIys0gehJoP8EqvFurLSXiQmSWDFswR1gCt2FORLEgiDkARi4YqHqJoNRs +MGj1D/PlLdtbXBhfDAorBGEN5/c6nU0kHVYmwXCw6kEy5RNEXVV6cEmpBO7oeddux8E3pbX/eAKY +yTjhSXzUTiQkywkjlOXKbnac9QYc66fTCshgng9IwkolWZ4JdyQylAWgJQkTyRiRKAsRwVJGIoqH +p7MTPJLkRcYVuIKkNCmmkE4LlfpyoTbBMLCorm7WJLlgaJWsXdXkHJJkVSkol+dxDMKKoSkD4G0Y +cMEVGE4iwaeSEsPk0IxJEjZFujBLREbRJU/iPDAUGKp3Rqd0q8NxeY4vkIQLekkWi5ZRYUkzlaDn +ZjIQmwzlTE8hs9NoMkbylKjwRsFrt2rrEKfT0+jcLINheUZo0GyBojyO0wUwLZ2Rn21OT2PhuTB/ +ZbRybePwiZXdW2AxaIAT7ZCEQhNKmB0IHcalaGU/18/mBoB8Uw1so8CzNiwEz4AnLVK0TVNWIkbR +uEpmBBrjdEljSVoWNJ6zcqWBqFcJysVx3dEKZ/Yv3rj5lGWDSMsXSuuDhStBcYemPQIVM0kmFadx +RKEIE0cVAlVZ2uW4oqr1Jb5Cooarla8d3XrulY/hlIWgMklaGBAXZrEkvIxkgo5HSASEZQLckIZi +1sMiD3Imo0lCIev3Od5jaKPRWq+1tvLltWx+2fEWJaBE3Mq63Wy2D2+GVQjyS6XyAc30CbyWTmmx +ORRJEobiqXLueFhGBgEA03SZYxsklc9kbBx3g8JElCogVHDChzwe/ifpgzAGYgwLgMygaIonwDtH +iLAqwhxNUkBxJYZ0aFKLRVDXaJTziyRuERmNQC2WBiVgoRmx3pjk8t1EguJZR1HyAp+VeJ+ldBxh +MklSZK1KqYUk0ngaY0jINVmOy8HXJeLc7Awai1AgfaeOJ6NzBIEa6YSAwXoRBokAewDM1PHSaVOv +oGmB53IU6dOUCxEB6xidzURmUskoyRJmJKxQgYM9pHHHdxueDdFdpjDn+PEUpMKpqVBLPzwGSyfi +tCq7iuTQlBqL4uAWRbFimF3P6wfFkWG2E3EGSUM+xaaOR9AUSZGwQLIkOJ3WUrk8tO0GRRoZhInH +0XSSZ+kKTbo0qVcKw97i6dkocEUmOpeOzaVZQpBZzbOLYSWiXFXW8+mQ6nPD7lodVJCcI3G5lO+7 +TgMyEUE5kQiNpAQUkXUwL3qdInUInHSSQdMcjqrAafEoR6JW1qr1Wkut1oRnddcu8ZwHGhU+SGIq +jqjHjyNAWRgSDm1mOhFPKijmi1LLNBdcb2w7HQKTgHw2Ns9rJpiRAFScpneCYLHZ3A== + + + 8rLhncNUkud5TxSzAPXwuVjYgJImwPvjCpJmYhEkFUMZXCYycKliIgEyJmsYHUUOiSKTUR+arAFw +jiD2/NxueMiFsFPhgzbgVSYym8qkBbA5PF+wzKokBg9LKySTUXx77fSlS0+wtJOIkUiCxVOSJgYw +KAJV0kk2MoNQhCrywDZqOslRmMQRkkArLKUSGJGKJWiUgH9CJMpSWRSK4XPqOJNJi7BGxx+JJuao +RJSMAAyOJeaOp+MRGs9oIuMZShF0SyVfv3LpLohMSHZIQgRWQdMKlpZ50gH4xeZw3x3ksotExmAg +R6Tl6Cxx7L3xWATWRYdvnDoW5WhTFoNUgkvFYYoosG/RWZRGNYXLM7iNpkSRzWlKd2YWOX48duxY +BIbMUIZlgPw2fNO/evWWl23EEyySlknK5viiIDUYtpCI4Y6avXHh3ttf/F4a0977npnpqQSW5jXR +t4y8ny3rkn39yu3Do+soLkfm0IcP5cPn8ixjSaKlK3Y+CwpzTZFqHJsFjYdlRPh/GmclVjGVAoGJ +eIbG0wxH6blsR+AdLAMzkNQE3s8CJsVUhkkjBGQEXa4Y6kImbUImmp1Dp45HcUyT5YIg+HhoWi0c +d2jCNJQ8RxlYhjPNSqW1jZPwjUomHe7PfPjTomPV4glqZiYNbjqTUnk6h2fURJwkcLEYlEteTuXU +dAJPxAmC0Dy/X29vA6LSKRGuqDfYC/LjsCv0LApwwlGZDjNgoCtNhswCkEq5frUwwBAaKF3hTZZQ +WVLjSQVNk+lEBn7/9Rs3GFKKTKdjs+j0sfjs8VQ6zoVlHnn34YNgFc84WIpGk2hsLhGZSWSSqK8b +7aLfreYd3Wp1Rqqei0bAQ6XmwiXGyYyWSUqzU6njj0SOvzeSivGKWJWFIpYSJcYKnErBq1lGNRmj +cESmMMg1SgyI5Vh05ngiNptB4rTMBRSmJiIoIDweBeQLDJGl8Fw6Ic9MpWaOx3W5CICcnU4BDiHt +8ozr6lWesNMxMTJNoEmILHZuGolFSDQF5CklY7jEiTLHGDLTKrijUV+QZBwMklNoNfpBriSIGoZi +NIb5YBqbC/lid2oqOTeDoCnBVoKcEWgc7yrCoJrf29sKStUUQsXiJJqBHGoqspn33WrJrxW9k9uT +F559sLCwHokgkbnU3GxCZBQd5JGpW7JCZrCsrlQDVxMBUVEslZAZrJxTO1X3+tmNK5dPbBxOWj34 +ZaplgtjQQMA8NMUUXImpmJ6tW4bq2b7IuqZa45ksyJ7EHCoxSqPS6g4WTTNfLQ8EwaEIicblTIqd +nUaOHYuH97LosFwMTF06ToD6HbTHG+sblqoTCJ2IERRhgCrws3VJzrGc22ot2XbVNKuynE8mGAwR +ADMcreiiKXEOicmQsiWhLPFZXdAMjq3lLN+0dUlxNU2mSRlAxuGTQWF3a6iIwIoskZHwFE+jKoOb +kMgAHsAhHCjMjIgmk3gqgSWTjqwslL2tTu7cav3+xeGd80uvv3rv/On1omNzjIajEuQ+kXQAYI+8 +Z3b6eDIFLjslpiIYg7Ayxec0w1N1W9YoCN4UrouyzHMc8CMnirSi8b5r1FBEmJ1OHH9kdupYDOAB +yXEWXOcse/wYeuxYenoqk4gwAH4kjuNpohRUGVxgUM5RckQaND/LUzlFCJJxYnoqlogSLGiYNIUl +EjKdzul4vyyuz2d315v9rl+v6OOOd/Og9+DW9tHhwkLLnW/4hWzO0rMUKU8fm4vPJck07ghSTmJM +Olkx8P1xvt/2XFtwLNlzHU3ii57cq+t7I+e1p0699vz55+5tPf/EiU6zGJlLRmYREgXBmrMkxZNZ +XyJyMr7ctPYn+aWWVnXwSV09u1p87emD1x4cfueTN3/zo4/8/Jfvfu5zT53aqZV8XldEjgsIPEeg +nso5tZwzbDmr8/nlXjHQxarvqYKCJDNYCvEUZb5VmUw6hye2Xnv99d7CGCfIVJKAC5iZAr4SDHOB +48rhrbljUwJBlF23X6s2SlkKQ0gEx9K4KmoLzeqdG1cWxyPP9Q4PNyuVIkmwmQyjqjlRzIFy44GX +MCACAV5VL9cu1SAR1j25YZHntmrXzyyv9QsLJe1oufjiYyc+9OyZz3z42hvPn3tw59T2cqecdZkM +jqeoTILhCEeTKyKtigRt8lQnEJea5qRpbS2417ayz56rfezpjS++cfRHr5/9wy++/Juffemt548u +n1wed+u2pNIoQyBsJs0LnC+zHoPgYKobljqft1quuNZ2TiwWNxfKR1sLTz968s6V9efu77354qUP +PXfnzsUL41a7kstaCk8iCKivTJKPzZEAp9gcDYw6fSwWnU1hCQJPIBbH1Fx93C4HuuwITK8cdCql +op0rOSUGE6aOxyBgMwkKxJZJIVkmPvDQyyvmi1e6T17sPndz9O5Hrnz9U3c/88GDz74w/t33nvyH +X7/zp1979p0PXDm3O67lcmAfUrFUJhYRM/GqjK0WiLVSaq+F3dqy7p2t3ThVuXmy8vjF/nPXB68/ +ufyRZyafe2ntr//stb/79Se+/enLD84VGw6JxBOJGCowusioLEroRHrsYpeG/M1V+ZXL5Xdf3v74 ++yZvPT3/uVdWf/6dJ/7hN5/4+Tfv/PJbN//7T1/9n//jZ3/29QdvPrP96FG3nvcZDKJV9FW75mnz +JWlvYF5acTaqxFaLHpeYvaF3MAlOTvx7R+1PvXL697/91i9/9bUvfPZ9rzw4efHUkqkwyVg8k6Rw +TJ2dTU0dm8Fi0UBCywpWN/BAjAdSclJVt/ru7si5uOq89cKpt1659NqD03/09q0f/+CdD796r9/0 +ttYmm1vnTpx5YNpNKpXweLwgE0OPurxkvHSt9+zFxpUl5bVb7Z9/76Wf/eC1Tz+//fkXln/7w5f/ +9e++9M+//8yPv3jln3758l98/fa1HT/LZ4hkWJOQw1UWoxQ8WRBTWzX6mdP573760s++/8K3Pn39 +E8+OvvahtR9+8crv/+KVv/jKzR+9e+6ffv3q3/zw3meebT17qXp+o1LzzXoAubLgmmWNE4sKNs7h ++03hif3gzcdXXr3WfOV69Y8/e/3XP3rjn//+27/7+Tu//O5T//43b/1//+9f/+FXn33lRuebb535 +xQ+ef+elUxVXT0VxSLJgYyXWINNpBlJ+JmYzSZeObNbYO7uFR09ULq7YN7e9l28P/+SPnnn3g+fe +fePRN99/r+rncFQEBtYppmXya0XqqMc+vWt89qn577596TtvX/zJl5/4+x+/8T//7c9+97OP/eiL +V/76Pz/zz7/95Nc+fvPsWqUCDpJXfStQGcbl8HmH2q3h1yfsE1vGBy/mv/3hvZ987Ynvf+bq1988 +/PPPX/n7P3//v//Vp/7lN2/9+vtP/PZ7d379x/dfv7/e8cMkCCIknUAphAxUq23pO0XutTPm27fz +n36s9p0Pb/zmG9f+z99/5G9/9uqffv7ir7998x9++tzf/vCpH3329E/ePfnLb1z6z58+89iZyqCS +Q5MEgXA8Su8vNk+Ocvs97bE9+0svTX70+Qvf/PDm19/Y+d2PX/vl9973J588/4OPn/wff/vZ//U/ +fvgPf/nG7757///4w5vfe/fK0RJgIRGZnUOSOHC7J4jrVXnsIiMrfmeJe+GM974z3gdu1d99Zf37 +nz7zjTd3fvL1u//2d1/67Z++/Psfvfqvf/P5v/jGk1d2WxvLk1p9RBJGxct1s9okzx61qUeXuM89 +GPziqzd+8+27333n5Lc/dviTr975l9++/Ytv3//eOyf/61eu/e+/ev3XX7v1jRdan3uifGVRBlbR +OCk2m5p+ZI6MxQtCai2fuTYSH9tzX7ne+NSzaz/91lP/+Jcf/t9+8tIffvjCH3704s++cuNnXzj/ +px9b++RjtUfX9cU8U9SosJyoaAuMEzj1SXewPy6uVfitEnF7mfv0M/N/8s6ZH37hyp9+/tzPv3P7 +9z958W9++sovvnXnF184/Tc/ePSffvn8735w95sfGn/8dvDylWa/aOGIoEhVkfct2ZivOH2fWQyo +q8vGM4fGy+ecj96uwGz81X956pffuf2zr934v/7xy//3v/zxtz968jufuPbKk4cSxVOomFe1osxU +ZHTsk3t1+uaS9trl5jdeP/j+Jy79+HPX/u3XH/9f//7jv/3RSz/67IXPvrB7drNWNHmJYhhCsfWS +q5d8LchJQl3Dt2vyjbXSgzO191/I/+BjB//tu8/8/kdvf/HVE194Yfy9j+785EvXvvbmqeeuti9v +NeZrTQdiSimzlANeTGTMqlvqZP2aSi/lmMtL3rVV796294n7vR9+5uKvvvPM9z999dsfPf35F0+8 +cWv4+qX204fFw5ExKMuuyqMIrwo13+5qrNL0zLrJtQx6u6E8d7bx9Q9u//lnz/7ld+785vsPfv9n +7//HX77106/e/tkXz//TT1/811+89qsvnf72K7WXLxW3moqAp5Ek4ZnNajCyJc/j6YHDDE1s2089 +vi596EblzTutL7+y/W+/e/uffvvm7374vv/+yw/86x8+/ZNvPPa1N/Y/9eLm3mLeM2yR82A43eq8 +I0lFlT057y/nia1C5tI89+zJwhuPjl6+2n/mVOUzT45/9c37P/nKY998/eCLz6989NHx7fX8dgNy +KqEyMkeaoGQi0xkB51U8HbCpxSx9at67tFo9v1i8u1t7/+X2m3cX33p8483HN66O7Wsj88rY3W5m +87JqsKLCSKD5NSmvCAVLrdhKrlMotly9aYr7Hf/aSvnGkvfmo/1vvL75l9+4/I8/f/kvvnjjyy+t +fvm50QePvBd2zFdOVw5bqkenBYzUlZLrjFjaBxvIoKyEIjk207eow5Z0dcQ9f9L54KXiF54b//7P +n/9//u0r//CrD/zme8995YOXb2+3Vuo5UzZRzCQxkUojfLivi66ZYt8TVkrKfte6sVm6s1d5/nzr +j14+8dWPXHjrwdpTR+21ti3zeCaZSESRDCIXg1Gvc6LgjwzBthh2PnCu7kzund9YLtE3V8xXr81/ +6cOPPnVh8e6J+pOnm+eW/UnVLFkiGByB8cJyhZjHsEUw8uCgS0EvZ2Q1gvQ4tmHrTVfpZqUT/eyN +jfr9g8Gje62Lq5X1Rn6tnIdlLJmyxFA4yqTTfDIp8UyRJQw0kcETKSGDehy/VCmdGtdvrOeePsi9 ++/zy9z959iuvbv/w3Vs//MyN737k8Dsf2P3K8xufute/s2kHMgqmXRXMsPQxnWMpLw2GKMO1s/lR +wS8L6UkWuzDUb606j+9433nj8F/+6lP/+NuP/9evP/bdd669fn/t3unm7tAHb2xoJc9b4Fif51wS +k3TBHlY6FU1oWmw/KzV1rmfLqxVvuWBuFoVb64UHR4vX12pjT+iYaknRLFbicCGVEKNz3MwUKEDK +lPMywYiZjIYTZdNsBX43CPq+V9OFsszVdanrKTkOAy1YkNRBbagKPrgSEpQ8rlbKIw== + + + hnKQJIhthkRYg9Nbufru0v72/PLA1fbq5uN79TMd9dHN6uXl0smmfqpl7FTNrYrTNaUMyIK5DJ4x +RL5BYGADEXCasZkknQontqrJA09tqPhqUdhvyHfWvY/eX/r4k5svXRpdnrRKgqDgnGtUg/LG/PJN +gQ1MtSAyukDBhJi2YhqC6ijGoFZr551GVmlk5UDnXU2yNUPgVZJWwapHIgSGGapW5gQ/nuTQjKrw +WUf1Krlqo9jiMpm8xPcDr10ATnN1VtZYCQwFlubASWXSQjzGRKMMQeYL5Z1SbSfcQqZXRM7mCclR +AwaDNM3ZorvU3Vgfbo/by3kza/KyLee80MIw0zOxRJLDyDwvdlW1Y+ltgbEjM/HYbAJ8va34WT3w +dbfmWoOyszMf3NipHY29axuVmzuDg35ppWxNil7Hc/EUNj0dTafCs+2RKDk1nQK/yXLVcmmz09hp +FIc6x/sy1XWFhkbVVfzssPTa3aMPPHX51uH6brdV0lWVoRmCEUSfIDyccBMpxfLGvdGVbv9SNb+i +887uys7dm0/whAzrJVF6Ti/Vc61OqVtxKzpr4HGWSOsxsKVTKIAqg2ZTKTuVNAg8q0pFNI7Tacj1 +dCxChLe/UhyKyCRm8nRWYHwGl9MxhExzaFJE05IUPrFyeCavh4dZFtNpDWxvKsEzuC3Qrmu1Da0P +gcNhosFpC9U2mUACNVf2Wp7sCSjP4xpHGomw0niawD2OKcaj3Hv/09yx986B32Rw3dOyvpHncJ5F +aZNVcooRnsWlMJcjXZ73JTsrFVMRKh4WhBk2Buf9YMlxF4eTs9l8h6QUlstadq/W3C/WtjjepSnV +UnOLo41YkpiZRWIJUdL6tr9iuUtSWFmrpMqVyfJZzenG0gbJhIcyKKaAZCwKd3jKSsXJmelkKi4y +ZE6R2xxXBZrCcDeTsRSpDLIknpDjybDVEUUHlt3xsn3LbOSDvhxu+QgftJGkBz+SlJaqtXWz7WQX +bK+nKnlNrxN0HsFsDHcyqEPSAUn66bRKEibPe4ZRVdWiYbTy+UU/N3CsBk/KCq/asLBKMRpF0kmK +wG1dH3rFfZIrxxPczAw6NY0AMEi6qlvD8EBinI3FWIryBSZHozydoS3RalSAl2yc0Ck6Kz6slYcT +YcFz+GwEIoWwNa1ZbeyLSjuNeAiiY7jl5yZBYSUW4dJJmF5f1eqGPcCIXCptoqijyB1ZbiUTSjQi +sGy93jplexPNmCfoQiQKyBF1ITCUPHg0QW5mSxuF5m4r7Ei7+rDbuMax2fnhGSmsXm673iRf3C7X +DnLlvWjSnJplpmcpBLHjUf6R90bmZgnNWCg0T5Wbh7a3DOidPp7JpNRETH7kkfTsLEmzJdNZCooH +truczrjxpDE7Fz6WEjkfwDwT3iWLzk5nUnGOJh1La+pSPjaXScVwBlMZwqBhudNqeGQpraNkDsGy +j7wn6hY2GakiKYWTBzeHK0ckn+fVOs2XFKOhWx3XGw5XLqYJDcE0Xio7+SEllFEywKiCao36Cxdv +PPaRev/ETJRLocATm375tGItM3wNxaxkWqJoT1ZbgDec9Am6pJqLtr8GjKgbXUWppRAzg7kY6XJi +w/TGudKKZvUoJp/1x/XWCUWtm1aXl+uKPSx3z+abJ/3ylu2PZbU2Xrul6D0UNzWrzss1MzsW9S7J +12ih5viThcmlE2cep7j8XIxNITovNcINflyJlcIjPJ7dGY2PDGded/qCPiC5JiP0FH05hQDt5BA0 +3BOYSHEYpmlaQzUmLNdMJ2UkJetaW3p4okE1B6XmiXLrJCf3ObmHUfkM7gpyneXLGGbJUhVB7WTS +oNgCrzQpvhFNWTOzHMsFSEaKRsNCsjiZk5QuLzZEqUkxJU6oS0rbcsfxhIpiPk6Vaa6BU0VObFJs +aXaOnpulTXMgKfVkWkxnNFZuMHKLEZuGO1L0cFsmQWVJthJLmUnUxdlqtrKvZ9e80q6b35meYaNR +URDritbIYA5OQOznkUwA5EzRxUzGiUQ4hq94/rKXXcLwbNh7NG3xSk/WR7bVxVENYHnsWDo6R6fi +PJJWCTJIh+d/nUwGEOXF5yigNZb2nOyi5a/o3pLqLtF8fXqKErR5Qe3ki8tXrr3QHe1nKJvkCwQb +ePklr7AWVgyz58Vws82KX1xME3o0LSUzDi/3uqPr3eVHa4PzrFJDCUvSumZ2zfQ3aLGDsxWYfyc7 +yZc3LX8R6CWdsTRrFFSO3PwJSR/SXBknA7gAxZjHKTeDGpLWBlSUmweN7plq6zAobRZL66fOPy1b +XU5r1xYuruw/uX30zPrhk/X5c73Fq4bRLxcW947uI6RDcnmAlpnbLLXO9CY3OuPrpdYByQaiWtes +gah0GaEG+JSdkWL2V1evnLr4gmp2Z6J0Gndz5d3G4Gq5eYWTFlCylCFyOJN/uBdOQzEtEnZhNsLa +v1SO4aooEbj+sl9cp/gszmRhEQV9pHlhh2UnvwYYQxBzcXLe8UYw3mhCBEpkpTYnD1R7WVBbOGGh +GcW2OqazAFSMYkCAvm4v5kq7heqJYmU3ntBUfV4zJ7I2hO9CiFwccWaiUgbP+YUtVqiF9e3pnKC2 +VWes2BNB7aYyJgDbzC4RkDXCSmg9Sqg7+U3JWDD9VcEYInhOsxeD8k4sCbA0AFoM21S0oZ1dghFh +eA7DfdNdhEQMCIxE+QxqauagUN3j5X5YsyXKwVWlEBeYbepY7NixxPEZJo0XNHNkZ5dFpZOIiamk +oihNEUKY8OEVFs+k8oY1krRho32m3jmw/REt5EWt6RaWCT6QtIZizgMIFXOQL691R2fM7HwS1RW7 +T3EVgi6yUi1NlTC2izON/9jDn8YcjAo0d9HJb/QmN3fPvjLavI8xRYLIVoPJ7u4NhPITaDaNBhTb +MtzVcvdceXBecwdhY7XqmqC3NWcgG13Z6KnOMF/bzZXXOKXi5kdnb7584vLTveXzpfZJM7cBmISB +zA8OTxw9DjOmGO1G/1xreGOw9mhzdFHLLuFczS+ubh48Ue+eTKXtfHFz99QTKzu3R2u3Di++YAVr +QGKAH1nvCEoVp12aL6/vPb26877e8uP55hFFl0kmp1kNxenPRMVEUgPuMu0N29/OlffLzX2CsTS7 +E9T23cIu8ENv6cbSzv1y69D2V0Fo6c4QJT3FaKn2yM4tQ15QndUkGh5287Lj9a2bHF9MIbDKWdtb +rHRhBlZlZ4URu8m03Wwd5oLlaFLDqDKC5kim6gS7udpp1VlD8EKpvHrp6jNIWNmPn4spQFwSUGj7 +9InLH5SU3u1HX/riV3/QaO/ORuUE4ij2uLtxe+X0+wbrd+1gPZWxy40dCI1YXJuZZQi2hFLAq/1a +50K2sJeIGxnEVNQmxFQ0RgF3zUTlWNoUAUL5vdrgyiPH0bk5AidsBPOQTBYwiZOFFJLNEAU7t1Go +H0CCjicVJNQnBYqtBNVDki7R4LDEOpCJ7i53h9dXDp4S9JpfWKx0TrQGJ7uj08X6pukNYDJVu9ud +XIRVC9vmal0vv90cXG0uXHWDDRhmAjUILgCaggzLyS3ZgshaY6WBlV0drlwfLJ0lwr3Hy5Y/0Zyx +oPb17IpTXNed3tbOtdOXnrFzIzKsKl8BJdxfurJ88oFT2s4Gw42Ncx95+4/6yycROstr8/X+xfmV +O5Ote43BIcX60YTAihVGqOBsllGqCJ2TrfnJ1v2d0y+0h5dkawFSZ3/xqqj3SL6iuSvt8dVseVez +J8BXfml1NoqnUDZXHhbqEycYo3SZ4juGvVys7Z48++TpC0/PRrlESpXk/mhyd/PUi17lLKcMBLH2 +3Ps/1+zsI6gLrLix/9hzH/jsc6+/u3vxOSO3CmrBshfe/OhX3NziXEzGyLKZ3Sp3Lo82Hj8493Jn +eIUXy5PV87XmRjTJI4THa8Ogfn7r5Evj9VtLGzfVsFBevdY5GS4i6mr2yPBXZWuRk+cb3QsrW7dw +Mg9SGShacyaqsxBuauUaoNkOj+7fe/ZNSW+RTMkvbPtFMMDLvNpnhSaoEVHp9Rav5Eo7M3NSMmXb +uaVcdavcPmwNzwEvJaLg0teWNm6AAJ6ZYyHX28G+6kx0b5mRuhTXno1Ixfz4scdec5zue98TicxR +FFv08nvD9fvnb3+42T+TTBl3H3/Dzy+lUTsN6l4bYyCciDyMJVvc7y/eO3/jrYOLL1l298LR3YXJ +SVBcljvwC6udhVODyYX5lcvFzp6iN5qd3fboPM1XJLMt2z1abENila2Rk1+v9484uQZqTTbmq51L +3aX7C1v3G5MrktkJ/NHJc+/L11cBBk6wWm6f2jp4/PrtV68//uZk82Yuv7Q4ORotnbPchXLzxPzq +9XL7TGtwZvvgsXM3Xyq1lofjUxvb9+zcCq+0GaVB8QVQYoIycPPbkt437c5k86Lq9FAq5+RWISlo +3orsTBbWHt08/Sxg0g3WgsbB1unHTlx+sT6+Bj4phfsZ3LOy842FkylcNLIdTu1KxrjSPlVsHuje +GEYxF2UZrqTb86rdkpwF2dmw8jt+eS9f2SLosJtVvbVtej1JK/vl5f761VJnr9zaq3VOVZsnCNoH +evRL234JVnmSrWyCkDaDXdtfb/TPuvnlVEbrLpwart2wcqtusKpYfd1d4KRmobQBqBaVOidUtk7c +uv/8O0e3Xlk5eKwzvurmJqJYvHDhiQcvfCaFugSTzxVXh2s3F9ZuDlav9ldvgEi7d/+1ra2rJJnl +hGJv5erawYPlnSf6S4+Otx6I2jASU3mxjuJutrieLW87xQ3JngfxU2qdLDWOZmZFDA8K1V1e6sxG +iLkoPTPH4UQJ5hmMgG2NUin1+FQa5KukdrkQdQ1WaCURB6js9PkXi+V10KsEHQASIDkyXA3SNCiu +bHGz1j0JsSzLlZ31c9XWCkm7ptVrAOWefnBw7tn+5JJXnKhGfXH5aLh+PQmijs0a2YVa5+zC8r36 +/MVq76jQ2NXNXr29a3kLTrBc7h4Vuqf03BKvtuvNkxuHz3jlFZLLdUcXqq39pfVLl288u3XqMb+0 +YhjtzfXLyxuXZK1RbWxdvf3KxZsf2Dv77ObpB+3xBcup3Lz+9JXrz+M0kDDQV0d3R4CBUuvICrY5 +qVOprN173xtBdZlggnJj3ylse5WDztL1C3c+vHXq6SC/ce7Sc6v7d0SrnWvsGcGOYE6cwl6pdb67 +eEOxFjS9eu/JDwEnIESWYIqM1GGVnmj0eaneaJ3szR+dPH1jdecaK/clYwiEjJABzubt3Hhl715I +m3yuVN+oDU4Wm7vt4bmgtofTVZItV3unCo09lPQlo11sH9bnL9cXri2sPdGYv2xll2W1efv+Kxdv +PK+YXRBXrNAAg9AZXijU9rxgERSsIJU3d29t798qVJbtYARozxVWGp3ti1efPzj1GPgF015Y3ryx +deZpv74nu4uyswjy9dqN5xqNFTSjaUarPTzT6B8GxRUIN9FcTGT8SEzT9A5OeuON6w== + + + Z25/aO3sc+X589XBUbl7RjKWIzEDdOzSymVJbmIYmHcXyXgMaB5zUZR7KOrPzFAZ1FbUPpDSzJyQ +SnuSMpTUkZvb80t74MviKQUCiqAK4Bp4oRoWkEc0mAFaqBruOChvhdGhh8pTUSqq3s2VViEYNasP +8lhW28X6vu5PZiD5Ui5Aqze+3Btf17OLtFhJZAxJrCyMzhtWR5RKQHSrB4/D/O+eeXbnzIvzG7cV +d0Aw/mj1CiuApPHDkDd6hj1fqW1Wm7uy0WLYrO/388Veo7NWqK87+WURZJhRqdRW3dwCJBFRbj7s +W+FhrGv442xpJwhpZDNXWcQp27SaN++9fvr6K9nqblDdCQ9NewNdb+7sXNs6cRuYFnR+c+FmoXlU +G94EDmFBi6a1Un586dozjd7O1CxBcVWgl0r/nF/ZgdAuFFfm+yfe/ui7L3/gUynMz5B5Tuq7hb2V +/QdHj35svPdA1noXLtz/xOe+2eqdAI8mGMu8DhJ6pb/86O7lD8CqYYSbBVuUX2JFwFuJ4is0V5HV +XvEhO506f79YXV3fuOL5E0nvgtdAyXwiY6XBb2q9dv+86cyb7oKVm/Bqc7x0eW3nTr6yy/Bh46R6 +cydfXOJg1YKtEmjX3lFQP1CtISwx2IRibZtmyw9NnwpkqHkbhdaFfOMUJzVoNt8fH26dvq3YnVl4 +A2JwcrvaPQcfyRfXLKsf1gdjrGJ5jaSKsZg6MydCTownLJIqVWqn271ritavN7er9RM45qVTOkj9 +SFwDpKnGKFc6QVJlzVlQrC7EHYQAJ9VAootaX3UWCa6WIXMUF6hGM40ast4stfaCynY2v9lZuN5e +vMmbvTRu5qrrdmE5hVk0XwWbJoKb65yynEV4m6i2CNLpzJ/ujM8WGtumPxGtLiEUKLFaqO1U2odA +DuDQVbOnGf1SZa3W2soWlxKIJoh5vzCieFuWA8Pu2dlJvQfWch2cESvVM5inWWPZHKRQWbWq+cZm +b/H86t7j4807yYyaCbfiN0arFxi5BtYpLAwudzvDM/3J6d74SJRqglDTLfBfubkYC1EQlDdOnH4K +NIYXrOBhcUI2EufBR7NCIZZggTec3LDeWO33t4/O3i1XlzK4b3nrjr9tecuKNQ+WAfjNy60sr1/d +3n8Up3MoWciWT9ZHt4PGGctfsoM1RgoL/u8d3Gt1d8AsZ4iAERqN7tmdU+9bXLvWGUDq3Oj2dj76 +0S9Mli+jdDVXP6gMzpd7ZxrD8zDhJJ1fWzr66h//5MkX3waxCt5TtZeCymFjcLHU3Hf8Rcvunzn9 +2KUbr3ByA4iUFOqiNrCzK7Ixovk2QZXy+fHSxkVWquJMDaOrScRNJA1JqTe6e2t7N0kmK4pVTe9m +g5XlzVurG1dZoR5P6pGoYBq9jc1bvFCbnmYiEUlS+oPF65XGKVkf4mTVz44//JHPXLr85NQUCr4g +hZVorlMo7pZKO7Y9EvkCDJ+TqziVxQnHdAec2BCNISm0QGYXa6eC0n6uvAVzDsrTKywpYUH+LsVX +Sa7Kq91ibW95976VW4zEObgeSe9xSqPY3IFRQLYlmSAs9dY+kPQm0JQbrOSb+83h5fHW46evvtxb +ukSweUmrhXBKqRjmgbPgxBbJ1kB2AkRxxs36XfBZyYwJKhQmJIXa8BV2bl11lli5IcjlwzN3NavN +iWWIUzAFgHBBrNQae1unn0TDFntFzegJYh3EW6G2li0to4T7sLBzB6e8ZEoW1bofLMwPT7j+/FxE +mImIibRFchUnO6Fpl+ds02lX2psrW1cn2zeKzc0MboFKMezRw+oQPMQFSOXJ+u3t0y9o2c1UJohE +lVxu0S+uIIQNEAUvn0w7NNey/A2nuA1Rg+H2cOkCSEQ8vBucxwgfGLjW2O8MLlabZxEsQIlCrrIH +ouvhXQUbxe0MElaBO7r4zMLyOYbzTWeh3j3VX7zolzcxugBaEfTYwvCo3tjGCEeze05hEyJxafte +sXkqhebicTXrLQyXztJcgeXqirlgeCu83M8V1vuji0FxjSS97c3L4+E+z/kZVCeYnJ2bTLZvre7d +p5hKBnVTaZOhijRZSCS0TMZOpOA9Yccry+kWCwssE8Rism6Pi/UjJOMkYkJ0jkbTmsj6vNzhpDbJ +VoGi/eKSYQ8rrTNy2Mhmsbd4A+yYmV1KZYxMxhDEMqyIlR1LxrzuLLdBM6zeGixfla1+JMaJcoNk +CzhbkJwByZcQyLNirVDZqHZPclJZM1ud4blsecMprLil5XxzHRIZQEs2OuBikmlDkDpgUbXwpEYP +p0sgeADtnd4JMKcoHTBSM4PnQRBqJhjVIQyNlRpwheONmwjuilKlPzpb65wGmWE643xps9o5AIcu +q3VNbwOx40ROMec1D5iwglEexWUpNut58252kEix8SQTTfCzcxxKFMFzucVNji+JjLM63l9dv4CS +NoQep7ZoqSFpHc2YF+VWMqVoei1fXrKzAz8/0t0hSlXjSXDlfqN16ASL8ZSAEyZJBsmUxfFNmC4y +bLyoCkLp1NnHCcqfnsZTKR0jc4a9MFm7M167p7sbU7NCLKnDcsQS0sMSNBpBZkWhYhqDoLip2QuK +WiuUJ5zgE7QFYUKyFc1c8POrljcBO4liZqW2XuscwGoq9ojX52MpGycKitKHt+G4J4vV/uLZzuIF +kqmAFqKYMtg6JKXtbl0eLeyKgq/qlaA4rnd3RuuXQaHFk8bMLBuLqzxTFbnq1HEqGpV5uQVc2hme +t9xRJmNFIgJBBvnyluWOj0+hszNhhUC4YNPsW95KrXvZLZ5yCju8XMZJU5ALvFiCkBSNHisBe9TS +RBHGC1OKIEq+vF6o7gfFEyBvIAOidD6FZcGx0oyPETZkt9bCxe7iVSu7qujzTm5J1JqSWml3T/RG +53Ami9EexmTBLZ68+OzlOx9c3LkLbh1BTTChwGkYnY8nNQTLA3e5/sqps0+Nlo/cYDxeu8zwtVTG +BsCADhGUrpWFyz43WLtHsRVRyLfaG54/z/Ag3gDVLi+3DWtiOWOWL81GGBaStdpVweU5Q8jycUTD +yWy9sQepZGYGmZlJxRI8GHCULOJcFaULsKwM5QXZoW40owlRNhZ0dwXMQra0jVG5eEIFaHW724XK +OIMpkDSTGYdkatk8iLo1WNZoQo7EeNeb5/jy7ByfSJk4XRPVUbl2qt27UK6fgPRBUblOb9/JzoeV +wNNaCrFooaFaE0Zq00ItmRTGozON5nYGs8FwobgPGIjGJFGqZ/1xLCzAiJNhLaAyDUNmCwiejSbD +Rj9BYSUorCIZa7R69fSNV4vtA5golq8DSiMRhqFs1+0A5tNpg2arkjrvFzYlpRGeiUtLghCsrJ8r +lRZ4zpG0KoLneLnrFzYkuUtTpbmwfghfKq+2+/vAxomEEonw09M0gee93JqTXUFRJ5kQIZZ5oUJg +XjwmQWirZpsPlUkW0jrDVUD5o5iHYVkVIt0Za06oSBlpQIH6wiygIILKgWyj6SIvtg0PDOwp3Z0g +hBFPsQQNnqUpK5Wwc5zWB4foFTbADPaXrvNqL5FWRbkCVNboHW4d3Nk9fS9f32SVRnt4erx9wymt +zyUElqsFxX1FH5juRLF6qtnK+qOFpcso7sUTku0vldoX6v3zqjXm5C5Ol1HCY8M+TWUc10jCVfQF +v7A9Xr3ZG14EawChHYkJnNAE88VJ9c7oXH/5NqQnzRoCuWFEPpHUUNxBMDOV1tzcWnt8pTW+0J1c +zzePMKYG1gZy5WB80cktA0VI5pBXepq1+LCnCQS+WyqOrtx4Fv4eSagUV2fFFvigbH47VzqpGEOQ +KwRZMMyxIHUFuWu6K/CGuRg/NRU27Wp29nm5gkKwoC6O+7LSorlyGkCSUFBUX147W66vpFFdt+fL +rVPZwoZuLrJ8JxKTp6aw2TlKlqozMzjDBkF5vT+5ev3pz6wdPmX7i8AbOCJ1+/uuD2Ie8ldYbARG +h2RMAZQMmYtE2bAgT1hv3IpE5alpMhqX4KcMk1PkPEuripKTlDIkvkQyrOl97Fj6kUcSsajAUGE/ +rFRaiCcYisklkmY65YEZUTRwjrm5WZalPZZxY1FibpqIzHIsDzk0PK9KEL6iDZ3sJq8MENxPZxxe +alFcOUP4QFmyNh8Udwv1k3p2nECM6Rk6k3EICvxykRbCSj7Z4ppsdGnOT6coJEmSpK5odfCVzfAZ +zePzazdRugx5k6J1Uy+aJjA5aLMGmO7++PKZG691Vi9zZh/Eg2Z0ZLWC4aagdNrzFy7deOP8tY/0 +l+6HhcIQzXHnVWuBYkuAPUlbENRRtXXOy23iZA5Ji4YBZDUQlRq8MDI/F5UTaUM0Bs3BBTdYE5Ra +s7+fLa5kiCwwG04VdXtSbp3NVU7AROl6ZfvwscHKVYIvsWpHcias2hf13sLypXr7BMPlPW/QnD8t +G0PDWZPNCSe3NLNba2wPF8+x4cm+Ur68Xazt5kprMBsEUwYlPBfhGLqkq+1kkgO/hgErUiXHX+X4 +lqYviHInkbL8YFVRO/G4jGJZmm8Y2bWgdlBpnWb4EnApXFh/fE4C5RlWPmzEkg6MKI0YJOnzXDA3 +iytyJRcsGFbLz6+A+Q0bUsQYTS5bRgfEJIJYQN2S0uX4GoaDBXAh78/N0brR5YXm3JwAwQXyg+HD +vmM4GcTjbDSScZxWUFhOpIz/FNb6Y5NJYDwBSdspQFpMnJ0jKrWVxZWLkO6PHSfgDaC1aKpMEUEq +IcMvP348nUwo6ZRFMvmZGezhY1MNki/FtRixAxKdFjuKNQHfF0vJgtzy/OXe4OJg6Y5ZWEugdjRp +UEwthYTFXWnWb7QPT5x/qbd0RzL6sThJ4xJDmywHmCxodt/Or6oeZMYFXqqznMPQKkUqLO8rRlsx +OvnyBhhGI78iZyeqMzacAc0CZ5pgloPK6vaJu1sHT1r53TTiMnSOF0ooboEG9nLrhr2kWct+eV/W +x+kM+F/F0MJ+XtEYkUE1QWojiEczZTtYsf2w5rMgFurtTYYvgBeGqJG1QaN/odw9r9iLsO6qWq62 +djS7m8zoij3uL19bP3gS6Ks9vCgqTfA4zTp42M0kYgvyfK1zfvvgsVMXnl3evZurbKEZI5ftb+/d +qtY30xktbEuXVHEyr5sDgasyZDYeo1y311s4KyhtmgO6gHmzOaFN0jUYBawpiJZGY7/VP1LMIfg7 +kinHwg4UIs9XWt19goaZrAHeZGuRYEOiBpEfVsufo3g2K/JZjvNKlXXdGRJ0HjiQFyAD6tMzZCpt +ZVAnCuRJ+LLcYbgG8bAaoa53MDyIxgDP8KssQFEq48KX0lyRE/J+sJTNrcKUvueRVCyuwczPzgnR +mJZCvTQGrqEGRsl2FiCrppMGjgdI2oE/o2E7DzbMApinm/OZjBtNm49MoZEIDSDhhDLQeLG6f3D2 +pYPzH1rcemD5a/GkwvBFFSST0hD1BcFcVOyVYuNCb3w37DeEqoZV1+22V1ijlfk5xA== + + + n41qjjHstE4GxVUU12nWZYSKag4XIMtUtpKIEE0QkDdVCwR52KIIIC3LlUZvv7t8RXJGBFdBsCwM +E/QSRlqO03b8kVPYgjmHnJhIwqqJLBcSDs3V0ojOcGUvv5stHorqIs0WIlFiajqZwQxR7sXiYbVb +lqvAEof9Spy+ZXVIOpdBLQA5rA4j1ERt3i+dqLTOysZySDUpEdh+e/cuwIxXKjhTSGEBggcMX82X +Qd7nwfmWwwp+F7oL+43OnmR0U7gHWsK25yvlNd1oRaIMSDVQbjhZZoQ6CKSpaWp2jrHMTrO9g2S0 +sKYBYohKZ7h0bbxyBwRPJCoyTH7v8C4QINApxVZZvmVnV5zcihbeofKiUc50BkF5FaW8qTkmkbZx +ugoKUJS6FOFwlGOoleX1i4Y7TCDO1CxPMJU0FmSIohtshqJolrD0VrWy+7A8jnT8ODY9TWQwn2JK +GcydnWUgshx/sdQ4KDdPc2KdpIoANkjxQLMM144nTI6tGv56rrGv2sNwH1HaiEVFAJLA1ArBJBIh +wsfWxzCKKFFUHgHThxqgxCBxJMPNLTZwPi8Wi9XN9uCwvXCyOzryisuQ/Sm6KP/HSXyxVG2dnGw+ +0Z/cqvYugGIBnRAW9JACjHIUY8HOgbBfN9z9RutSt3/R9haTiARvkDQwjz4RWrMyRmY1s7e+88TB ++dcgp0TDXo2SIBUo8KpKW/dXCa5eahy1Fq6yYhuseqez6QfDNOYkwfambfDmLNuot85WOxdprgFK +AMmogtgE4go9WtpAUAdEb1DaXNy8m8ECAvcFsQ5Sn+Kq4KFAPzBcVRDDAoDROAPBBXaju3C0efJJ +WmjPRPhoXGC4nO3MAwYe7sfoA2g3D59b3X2CC3vrMKAkq43NamMDpK+XW9XdNa90CGqTYusQsDOz +ZNg/RetEIuzsLI2gHkaVNXs1KB/9x0ajaJRGEFmSiqBYUEzDCBcEvMC3BKEDIRDuVEEdAeww5mK4 +B/EFCIklLYbxs8GCqFRAXIl8OZdbLVT2IMWjmJ9BNBIzFLmoqnkcV0ShAAjPF1cKlR1R7eN0ZWqa +iUVpCjdo0gUCQTGHpAqaPtCtEYb7kB+PHcsIfLFWX2cYb2aWghwXS9qsOsrWL9UXLhhWL5VgA6/b +7h+AW3zPe5GZOT6SMHCmKZlrjreZjIP2Q1SlNplcmTqOvfeR5OwsT7ENy1/JoDZEMU66NJtXjZZh +NsGBSkpAhK0xVBx3HGcUlDZUs0uzOdVou8GQFYswdphJnAjDWdTaJBdIasd0l2RjUTaXQW2CcgA8 +QJQp5sDJbQAFgVp2chNRCZvV+sUVQe9FUnokLpFU4GRHstryc2u13kVWgVzczFD5WAoY2KGEKsGW +InFIyj1ZXwRVQJAlmBywXSClANuAWFAXsRibRo10xtb0sSjPS2qfYKrxhE4zxQzuRxIawdYh0avW +Ejg4wFjYZSaCA4Q4vgDESzIBI/U4pS+bY7e4GU3KU2EPRAlMDUqA08+Lag+gLsqNRucwKG3Jeock +HLBjIODBl8VT1mxUTKVNoEdFXwS/PztLxqJMLCGmEJsVOpq1EolpybSB4i4Z3k8oxGN0OiWALQKV +KMhtMEQgboFSUDwHjgPsA+hSgq6oxrjSPA/zD9rjYRsvYWl0VCqMMVRLJmSgRxyziIevWARjcHGh +s/rh1z+pyIVYXIrFlUTaERSAUIBmwjIUiQRt2j1RrMTjElxtNArCTAYRxTBhU+x4jAGLR9FVTupy +ch8ja3NzTFg/LcZIQsDxxUeOo5GoZLrLqrvkl7YVczIbUd/7CAqajefCOyTxuOh6Q92aAOsmU6Ht +gmhiWF+Uqm52zIKlpSB1Gv9ROYHAbUVtmfbQy02AbSSlJmkllDBiYfs8nmHKYfsYpcHwOVBcQtii +tymbQwzPh3V45I6VXV5Yu7W49biT34Sl56UyLGIGIIc7aTSLEEVWaFvuxMsvqXrHdoaaNUqiNsFW +MkDFYscOdlV3FXIWKBOGq3FiuKkv3AOZ0MHaIJmcGm79Kk1PIdE5QhBBOasM20TxUiQGV2jiZAEA +mcby8BFBXWDEHq/MxxHr2Ax5fJaIJQSOK2GoQeIGxKZsjnR3idfmUboYTUpJRMdBKgtVyF8AYMOe ++KX9bLC5tHbHz6+B3pP5PIQhUF/YZRWSC9tw/fX58XVJW0yl3bk5NpVSE0ll7uG2ZE7s0HxTt5d0 +G36qzcyQiYREUFmc8qMJGcGzYHXBYCr6yMmugRWdngtryONEnmIKqgFmeSkStjSVBbpYyC2ytAvL +nYjxYfXmuBCZYyJzfDopmUqpHAxbjeVYNCyEFfbXIAOwzDBds7PATgkEUb3/n733+pEsS/PD3iVW +VYa/3nvvw3ufkd5nVlZVlq/qat/T3dMzu7M7OzNryOWK5BIUqSWllSBRBASIEARID3rQi971J0m/ +EyNKgCABfBCgxCLvROdkZkXcuOd83/cz556Mb3CLaNaquqEPgAwwsIY5EoRmuSyXdlhTbznuihMK +mo5YyAk2ZmEeSU+3AqlYrdqOPV3tvgEQsVyIHytVT5L7prVALKpVZzg4+bN/+Le93tnOjlIqeZo5 +luSc4z3yKTQa+WsIXesgqxkWnrFlGF3d6Lj+KE5XfrgwrUFOGlbeQJKRJRfyCR5NRWsJUsQLoaoW +ukn2EghSoRvdJDsczF5O168H82d+stYtzH+f5SOa8WGHTXOiGXPLg5w+RHpoZp/0LBPIKuJ0/VVr ++KHZf5+2X1oeXjhQ1bZhDUDi+KbTe5W1XgTRCR7w8qwQVyuqxMdRAHkcR/FJlt9azj7wLWtdpcUN +L3U8d4iakpSupA5ND8k21axl0boumlc8slErLi8/c/wp5IflHxoe6VyftQ69cCHKcHlmEK5anSuZ +dD9HMowYDj5IB69pesGwjm60QHaageFMkMPVut+gYk2f5sUl6g4qi2EiRe1jWjRzqmggOL/W8HVr +MZi+7QyeGmbvq5/9xbPXf6jbS0Ub686Ckzt1hnhbzRgyBPdCVJzl7kEJyELWqNs7JalcNlxnDixC +CpEt6sasSE/z9Mg0x3XySX06TTru+dWqWK9qQBVZx+VNgS2Ot2K5vFzWNps3qFPQJSxeteZyTGRq +7SxZ4gyPn4hPdmRRbAIV6zWvUjbqeALXdJ11HG3A2pWq2mhYUFNQZdC6stxl2UwQ0kHv6ODgrSx3 +arXQ9o6J0ZParFAISpeRinLDqmI22NB1lq3uRRATcwTJxJBeMLZhNEFeg+mHVu+VYS8se6abI4oJ +SxWlUjM5Ple0PmwyZkNWE/LJQkbPdBe6BXs7s70ZI6Y4OYyPqnQkCUXtqFrTJh2xV83OOWlPY41w +qc3eTdI8g0Ain38erbPWSad/qzvTOmnCFcA0kU9JUtsoJUOH8Zl3yX20IyQ5RbkYoAmXpIIoe5Y9 +se0ZOLEojix7TPqRcflg9jFrPw/ik7x5rptT0FPgDPv9U4YLZK3b7N5m7ad4L4yCE7NKQ4cQ1c2Z +pg2AMxAPDNtiuDZKtUFF1ZrJcn6nd2zYw3JVo+jIi07SFsTDdd6+gR2rbz+eUZTbeOsa7UASe8FB +3r9ZHpDFEOhYlHMzX/3yD//6+vYr+D4F2OXt6s5S1gchBEbzlOcz0+y0++f1hldvOKgdCCHFWET5 +bdF9Wa0anjk83v9MlnIkEs1BYKQ032qPXh2efx8lu5WyoMuFIhUoZ0w7tDfEValiC9Iwad4ABqtV +SxTaGB1mFVNh6G2yp1RqFZ2r4exto+ExdIyHLGKej5DMAp9DbjVoH54OOurJE6HR8CW54/trsJtt +T3mSt9CZge2sBBkObl+zVnio1oIWcpqNyHK0PYMukrW+7ayTDAZ5An+ham340zA6GM/eN7vPRGXE +CT2G64rSsE5FNJtCTkiQE+bI9Zdkw7bZx/mhrskGVL3XHjxzwz2IWwHvQiOBdVWNCe1qTSecJa3j +2fp9b/xKIzfXWkBIx+6PxperzdvO+E4xx/h9GK1Nowd1BFHqO0PTaDp2QVrGqDlEKbnZZPQkKaUa +Npg9zw58b2YYPcebK8ZYVIdgYdUc4iI5IbadEa4zKY4hF213iQSw3WmcHYgqLEMBDdwdv857N8gW +w97dtoAEjPShMFFBgEQ3OMbZFKMfpPsUFz9+zAAAi+aF7c5hAOsU0MAE7Owefrk5+hpJK0hpp3eN +KwQS6la/QXsQFe3exf7pl5ev/hhmGaObzD9AJfJSk+FT5AnArVpzTHOQ5Lv01lduq28B+BVlqDuv +VjMkZL7er1VVqDtWbMo6JMdu2rrQtz21YSscOG4hB8K4HtTygabNIRiQ4bZNFp3qNZNns1JZYlGS +3rIzumsNX7789A9/+PW/Hozf7OxoQDM8qhUTwgz4RlEQY9Px9PV09c4hG6q9g8MvoviA55t1Oq5z +TVHrZ63jm+c//4t/8t+STziUe4IEsboo2s8dbw9JiGJBIilaD6NwHMjXE9QCJ2Dy544/N0k7lQXs +HsXmmrnyo8sguqCYjGy64FJByqCLgugQmAOssLy5ILd4iSyg9cbP3AjnR4BApoWuo17wTawoqRNM +4ubhwfn3aQsAtbD9haa1Lb3wnI7tgMjIvZve6FmzfSlKTUGIPXfq2AOOd2o1FuqU40MEZbb+CChg ++RjlZpE/xhlwrAs1omndID5oDe7SzjXAgWJ8BBqpxUuJ4YxlfUh0TgHAOY3zIzyB7L6I1t3xi6J7 +A+ZC0UFKuf4hvBvPg2hsP9j0x+9Md65ZQyfa1Jj4SUkUuMjzpgzjUA29Udfwvq63HE5fF+2LbTvm +YjC59AIo1dwCLmkTcD0Ew/nzn27f/UlniKxbnJx9g9pBkofZsemuUM6aNoad5/gAXtj1ZkG4CxWH +PIGKE6WWoo1UfQgVtLPDVasaiKPW8Bp0IMgFKR+xgBFo9W5VtQe5HsdnurGQSXBTmnbLJbZcFjgm +VuUh4Fc1R73pm+u3f757/uNs7xO0JUUlT56AFsmfBsD68VziuLOsOJvM3sFggv3hOKDKzi6/z4tT +io45qes1b/cuf/zuj/7jP/qzf/75V79hhFSS25Bz8DWOtwbIIKm23UX3nGCtWeC7uEZFDdI8rgc7 +jOLCNcO+yXoPyClt1+1ZQoU95KRhjiGNeCmTlQ44KyctNt4Y9pThM90c0lzA8CDKsW6sDGuN2lf0 +iSghwXoWuaPdBLKp5ny8/DBev0elb8eVQsXxYgycEaScEwBQUy848vw9oAd8XL2uGnpHIR1vMZNT +C76g82ww/VzXhxTIvaKohDfbkpJpVl93p1aw8aIj21tzYkzRJukblR/P9z6Ndj8a7krSBmShQ0w0 +s6MaZFcb7CR8xGT99XT9taR2K1Wl0XAUtSspOcN6UA6iMrADJORQNxDltFQSGnWdI3+wYJI/ZLMA +I1O80PanYbKU1Nzxx73R26z1LG2d+/ECDkg2uoDKIFx2+hcsHwpinhQXfrIH0BP4Zg== + + + o+5VaxrDuIbehSssPWFB+p6/tJ0lK3SqDSg3lyg6DrJELZUVCF1N7xkmZNXGtJeq1tt2ZQXshJWK +SlMex6U0Qz7kEOZI16ZheIrouOFukBwYNmgoLVXNcjWQlKnjzfICvLyp1zGNTdedymoHlFqpe6o5 +cMKVG+yl+RnwB/AFLZcW12l+TD6XXmvRlMNJPVWf6casQVLIw4PhEj9Yw+8AG/2CrBdRDDSSW61D +bmWms3HjMzs4MN1dBIKD2JPaSEheLCgmwgN8Z1jkM34lOeN4X5RDcVtE5O/FjAFSEX4cVg7Kdrb4 +7Om7v1qe/xzyFQIYmaOoeG1fs7pOuByuPuWDl25yoJgjwCwNmUEHmBAQH8Swokxc/zyIb9PmrawR +8K/UZMMcDsdvOv2XbnjEiR1JG8EFt5snrjuGxoMtHU3v+rP3kjZh+EJUupDZ3cGzON1A+OFf/XD3 ++Pz7py//2A5XrJQyYuSGsKUbcBNGpxnjvPOiNXjrx2eo1kpVpmgL6gsggxrB22EmLe9ANRcQe747 +Ac6oaidvHu6dfBgsXuvOviAN6pQPW2c7423jbJ8X/DDam+1+vtj/crH3haj2kQY07QN1kU4Aokbd +Z9nCC5eSUlAguIpKPvJR7cjkY/rEatWsN0LX2x0uXjNiXqkZtYYJ0BZEeCUXzyfLViWN3xY+ih30 +ypH1877lzLZ+JG/QMcu3ZW1cdG4w0nLFgG3s9l90Bq9D0vYigb6t1rUG6dPRYylvZ0dkmKQ7uLl5 +/eNw+VQ2Z7zU5YScF1pxeky6+sptNzoczj/sHvwoyDAvU0VfyNqI8Dvl1hqYk+5w+GLv+Puj6z8e +Lr9sMEml5pAL4wsesKZ2ZWPihmdJ8zptXdreCthIhEHdpVl4xkEQnkOqbT9dn6jHOuVsW+rEQDw4 +a8WYKDpqvB/He60OaXYPqo2S8+7gLoz2YUgFKbTdUdY51byF7i3z/rPj29+0hq/JXbm6SZprC5Hv +rrL8ClbCCQ/c8NDxdoNwI0vkM8Yp2mtQPhC42b0Kkv3tDfexrI78YA82gRVbvNy33c10/eV4+RmS +EIBDPnDYhFSbFa390eLOTfYHi7frk2/WJ9/b/gGKGqFpd66Hs3eatSvIY9OemzZG0RVk0tZHlBD9 +/enuF1ev/zxoXjIckROyAj0wt9yh5fXy7pGXnKk6WRhBWaG4anX4OLI+QD4CPVmG6UEQH0MCWfbS +MueNRlCp6gwTikKLfJVyFCbA3w12TWvJsCnQaecJ45hDjRBigQKH0uiNn08XbwFoNGPwgtds7Tdb +Z092RIC/pLQpPhMVWNQRWdqtbj8D05z54XGUnOJ9TRss0KWo1PMO4bJpWLOyjGdirnh5CPqjmbxW +c8tlReZT2+qRmxpa3wqP5offnz79VRcgAAZXO5D3q8NPWesUpF8HFIhd2zsK0jOAD8WGyARF6XQ6 +p8Ph1XByh7mtNRKKyYFdwJZK3aD5SNKHUX7dHt1FrTPdXaoYr9Deyvh8azG6mgFA3pO1OS92qw3S +5wigZDqTrHOZdp7m3VvbXahaFzpBkEgUHB/CeB9wBBB23Ilh9VgxAuSiHo+uf3j62V/62Smyt1I1 +KLKCNzTNHkfWMTxwTZxfAoqD8KBWg9HWYck5Plb1puWOeSkHpoVkHRUmcclyKWDTcNamswqTQ0kb +wm05wbEbbOAaTBuCf5i1T4fLl1d3v7q4+8PW6E5QxgzfhHYNgs12JWruhift3m2Un8jmCJ63TrAr +j5NNDqlWnMjWXNRGhr1MMrzpvqjCJY0W+69tf5dhM5rJKDbTrRXMKQFqIavVFElOWp3jvHkWpiCX +IcPC0GWi2I7iwzg+oomhbsfpiRcdqtaU5zuVqlep2gKfuuaEYyPS7geerns1nN6lxRnEM835cbI3 +md5F4frRIwpCNMoOiv7zIL0xnQXLJqWSQtFBlp877pLnE47LoSRdQC74MTj2/H3AXaPuSFILqqMG +xGASUUN5jkWhUIRchncwhl500B69HK0+ZMWRaU41QiXNZvtod/8Nz0VAVJgRXu5qzpIWmjUqYISC +FZqmMZbkVFZTMLVp7anaRhCGNNuk2KTaMGW9r2x363FKodqz9ujN/vXvustPkDrIK1APqjLNLibz +L/30env/pQU0Q+EA1bct5pd2cIhwQ8sRZNZ6NBNQTIC01Mxxq0f++JrlM1T3fP12sr71krFqDQDa +afMZyEhRC9Ps0qxHMY7njfFaEH2DLCzHZDVbarXb56rVcf3+/vkXUROGq63oI/KX5g2fZmM/3pgu +VErOiTkEvBsfJs0rIr0E1EWMUXvBNErHXjCU9S5If3P8U965Q9C3rY58J1ipZp+TMl4u0s7p+e2P +hxffZcW+bXWhRvxgd7x6r1qkoBiuBZvjBPvT9YeiAxzwGQhsoYXktPwDzVnRPCYcSsk0zH6a7cH+ +mM4uUNENTvaOfx6nZxDAitKrN6CyRra9lBXY7Y4gdnVjVzf3PP+QZdOdktigHNOaNugQNkrSxv3F +q9b0Q3/6mWmvSmWtVFIx8zBfujVhpQ7OgLKK0gsfBKGPYArKVU1S+mBV3ZiwXO7FZ04MkOmDRgUu +A2ZSDW+rxsf1ul+rOjQDPUPu+0NIqHqH45NyRYV/tKyl663I7Q8ZSBt32hcSZB7r01JO8TkndVDF +mrFOsyuOT3VjYCETzHGDTstVn6JAqd0oPUk7l4o5ENQm+fMBdz2efzi8/kUxfAG9QfaxiAWJmtyU +IaukvuWdueG17R/qFgRGtl2DHWbF9fEVMOEFRDVkWB0Cj4cOhyVHjkVQ8s3um9Hsy6g4Esg2MFcQ +E0UfaPaEk/I6ZbJCFiQntr9W9e5OWSY7jijSQw2MD2rgMDSphQKPinPVmZVrtih1UXcUncpKDwYQ +BKeas6L7Ala90nAAwnF2kjafQm9E6Z4fTkU5CbxxURySdQl/VWeScs2r0xGgxrAnjBDUGTdtHu6f +fnZ19/Pt/m2v1oAQjQN/3eldi3ILjiZJT4vWTd6+CZIj5M+TJxTD+IYFA5uxUsuJzpv9j+PVd06w +R+5bcXG5orBciJBpRAVFFWjpigaY9YI911+xfAKE7/Zv4O9KFatGJYzQKdVchAbKNoqPQrI75QoG +mZMKRuxX6bzSSBVtNZi+b/cu4C8EIQFPHV/+8OL9X3SHz+HFylWrXHUEsQ10JWatEZjO8v13f7M+ +/4Xuris1r1qxLXvR699B5f69/7D++IkoK8PD539+dPPLMN7HdYJxMA+mM0JiN+gEUkExDjqjzz/9 +8J+mxTPL36VFXEwL2MLJsCrQXSvN2qA64nTf9gYMZyPiDSoV+YHnHs3Xn6xo3eCCvDg4f/qToPYV +YyRbAwoaRhpCtqFOdWtEukJLBTTtcPrNbP1j1n4KuQsJJIm5Bw+bHQQJTlKUG1DIwyC47nQ/88Lz +ag3iM8QAu+N3WedOMoZ1Lqpv94SQ2a6plaomikVaPG0NXuPKKTYoV3VitPkMEhS61PB2W8NXJze/ +XR7/6KVnFN6iYmvqsF4PymVy9wRTKsi9KLt88eE/mu99w8AlOZP24LbZvfPCQ9jDGu3V6MC0ZjFp +xJzCPpDVMH3c7DxtdhGREVmHkQgOaOZA0tq8jB87kjqS1YGm94kVaricAD+1gMhn+RQ/NihXFHPL +mrrenGw8dqZBet4Zvyu6t2DJClkSh3oPofw5jnwUEuR6taKLUisIYNUP4P5qDcinOMsPIc4rFdOy +9/Yufxm3rm3nQNfnmJMkXIxHJ6Lo7ZR4WV/Y/kXefTdbfe8EB3XaLZXkPNu/fvFzw4GVcB+X5Goj +8MJjqGVgBUw6ZFVC/q7q1I82NcpBPfLyWDdXs+WXx5e/EqTOk8dkdRReRnNmkCU7OyosANJGtzF7 +VzBoFOT9+DVmdXnwXdy8qTay/+3vyHH3//cF/H91PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7tvxMJD7djwM5L4dDwO5 +b8fDQO7b8TCQ+3Y8DOS+HQ8DuW/Hw0Du2/EwkPt2PAzkvh0PA7lvx8NA7ttx97/+HTkOpL8jx9/T +9fmXb2Yvf/by0dXqkT5e5y/w88nL73729ttHB4/0F+H425/NPr7+2cevvnz57U9SB7+KgiSTwpO3 +Lz+XrN8/U8KTpMNvP77/+CV+efr65edvbcnDU7v471EkxVK0/d/VT4/8VpQ1g7SVFEkry6JWIbWi +VhoUUavZTlrtZhpLX/w/PqmZBHkepXka5VGSSp+TJ5HfZe12q9XMiiKT/t2r2u242Y6azf+XJ/3f +3u7zf59r+vzRh0eXj758dPyoLVm2dHWJUY3fPvrm/xxcTAa3nb/Fx8/fdn7/7eQtZuT/mEy8ChOw +fBTO3v7w8fXbk+VEujp49FTaziY5g7/9DtfS+r9Ggm+fSUkUS3FUkJd/+Pd6AfnHf/eif/f/LSnF +NcbN7eVm0vYMj3R9e4Uk/B2pSNtJ/Ohq/R9ICulXwouJqnc1o6+RhixdTujJ2ky3F7I6FEXysfyy +2vH8tWnPdGvESwXNx3iVIBei0iYNlIXYMDq2O4nSXTcizbk0vNaYmu4ewyf1hlavKyzjkK5S7tSN +9u3wwHB3FXvCK02KDcJ44fhjQWrZ7m4QHiX5pWrNBbGn2StJHXB8TjOhqPQUY6KZkzA7ErRepW4z +fCYobZaPKNoXhMJxF2l+boe7mj1m+FhQmoKSalab4j3F7ETFadJ+1hy+c5NTvJwRM5pP4vSkNbpL +Otdx8yLvvrCDA9kc0UKsGkNZwyRkDdqrNyxeCEQ50fS2anTrlIX3EqUuxSY0lzJCLpFubhNZ6+nm +SFZ7gtxvNm/j9EJQhhSX1CivTvssH3vB2nbnNOvTjGeYE8tekA56DOlnxPGJZY7b7StOzATST2pU +b7jlioZ/ZdmU5fDIVX2mmnNJnUjqqEo6AYX4JS+0BKGl6WNFHbBcJsk9mk3Ih1ELOccXDJswXGya +U8dekG47XFGjglJFw6Nas+p1DCRR5KaKBGBCinIEPqpW1VJZrDVMigkYLqGZVJT6otjB2RoUrjxU +9AHLp9WaStMBLrJaNTkul5WRKA1VdWpYC8uezmbP8/Y+w9q82DLtZZAeWN6cYnyqYXNshhMqxkxQ ++g0maVCBpg3CcM/3lgKfRdFGM4esmCIleLHQrYVhL1W1FfjjBmXhgeT0giPD2ZN1ZNcSyUl6eSst +mnZFufCivbz31E9J503JmDBSLsrt22e/GkyfCXLOi7njHbR6H+PiuaxNWaFgSI/yiA== + + + 4ULSjJ4NMV7S9lefsEKLFZp1yqvWbFw2nkDaEhl9TmqKas/x94rO3Wj69vDia1HPWDG0vGXUuu7O +PiadZ4q9UswZInJ58Yv14Zec2mowgRMcDmdfNvtvFHMpmwtObNFMgGnkhZx0YKTcclWnmIh032bC +ShXRMVg+k5Dw+kDChEttTuywQoeX+6LWJR08lSHmEBmIp+GFNBshUWt1gzRXJa0zY5rxGw2XoUKW +iZBgSCSBb3aKyyI/q1S0Slmt1+1KVS+VZQQRgxXkoaovBWnMCQPT2FjWbr3hkY4YQiErfYQMgMAJ +wIe5Hx7yUr5TkZ6UeCQnMMVx1ra1QrGQs9VdmiYfZr5T4qsVWeASRRmp2lgSm+WKisvg+axWNxuU +jVyimaxSCyg6YVjSYUq11wRYKBujqGISqjrPF1F8kaTXcXypG9NmcfbDj//s5PqLx08atrdLGiyO +Xmj2jHyKOIqIIy0z6rRLPhabxvTmbrhyvLmMDJfbp6ffetGqwQaVhinL3aL9ImneykpbkpNGw9q2 +RloBYTipw4gdWZ95wWHWvLScOc+Fnjdr9q68dFexeoo5xswbzjJMjjb7n4fJniDlSMsgPvXTc8Wc +s1xLVPqcSPJt+9HiWh0j4kIUoCijdrqyMgGyyfJIkAqKcUm7E6ODnOeVdpiczXZ/WB19P959y2uZ +YnTcaOXEu1a8ka15lF+PZp+1uk8Xy3fN3gUQWBByL9yLm+eWvxHUsaRjCCNBbANeSPvUugUoqNU9 +QeptG/t6CFCtbgsi+Zz8OhPU2JhBWMWxKM+8+FLUezXKxDzb/kGDjqp1Z6dsAGc4PmNYIFgEmGI5 +8pWhw3rNqlb0WhWh9Bk6cp25YYyRUZWKXq0Yv++BXqmqFBMKcs9y9jVjoxlrzzt1nAOaQVb0WdLD +qMXxCMFEkMe2e5AVt5LW26mI1ZrGC6QXmKz0BKEJKMBlb1vEJjs7AlKr0TB5LpakES8CQnOGyRRl +aplTVW2bRheFUK651XoMlBZI8/EOJ085gLaY4bTlikywTmjq+hhPkGRQ3igID4fTd362efyEMr1J +UpD+AizpoNQHGvBiu74lApQVZkBScMImS0Lc9OzZ3v5HzezTXCTKLY20LFnxMmbSBYBIUst1F360 +ywm5bo8kvS/rIwF1rY22TW+9ND0Yzl4G6SbON26yVsyR6S2daA9fZW0gyt1W68KNllXKrFEOz7dM +ay3JAwQUGELaJbCAL5S/V6cCiilUbY6p1k3S3ghzKytdResa1sh0Z5pFPj8/LK7c5EjUenF+FmWH +hjfzoqXmjYve8/3jn4bzj5h/1AjAxHNmQNRyVUMKOe5eu/cW0XG8PdOaSnIHsEM+dZ8JgF3Vuo0c +4LgCBCRKgKkcrMcgstJQkKaqvomyO5QMK2RJcmr5+zXKr9ScSs0FW+EkAD1OSMBiktJHvdNUAHSi +Gh4eJMeqOgdekzrbJkFWteY2Gj4y4UlJ3DYvyzRj2mDiegNXEjYoQGihGRPMNgiR9P8CMLIRL3UV +fYk4AtNUtcfxHvAHiU2zgKMUCCmCRvm8VFLrNbdWM3d2JIZp6sZCBN5KA5rOVGWQxJswWJSrKi6+ +1iDcR9HI7YFuH4XpuRdsAG6lslKrGcCuUlkol2VZavU615a75pVBnQ5QESxvbfuqjxAjyzvg5QEn +kgbTEAOG0WNZWxBiSe1r1soLjsMYoRwIYgpyHM0+cEITsQZrkF4YBumPhvOguFxvk7XPoHbKdROg +B7A1zDly2wt3nWDVzE9/90d/c/XqJ17NOTlVLUiyTZSeF62bTv+ZZo3JKHBmNhXEgW7uOcGF459b +7hGeJohNQ+u6wW6DzUDWFJNhJm13Y7l7urObZWcXlz+OZ3cURxqUB8lpe/CqM3rbHr3x4r0kPvjF +z/5J1N2r0i5LOrINMVeQB7a9hLzZqhQP5KJsm6/hzHjQhAigfzq81C5V+DppHJaypGx71bpP0TnL +tR1nZTnjUhXY4lBMW7eOHP/U8Y80c7nt5wLBhtA49bpOuj7V9AbtSmAWdYgI8lxBURFFgVz0et0E +AREBU7PLFbNW94GTSC0wCCCrCgCpKk92GGiwWs1pNEKGSQAUCAFyBrRYrmlVymaFFElrOXuqjqLo +Y9pR0ZKEzBnj5MAZUF6lYlYqFkXFAtduYBR1j+fSSkUGiO2UFNAWns9xSYmgpcFB7LHgI0+UMS1t +Qe7q1hKTpqhjaDCeA3ZJeCHD4FVFtWGWamapamF00/G7WkODLoVmID1QpBYv9U3nIG+9yJvPfX9p +6nm7eZC1zhRjhASDbJb1juct2q2r9uAFxcS2PTKsIeQiUR3aTDWWtnvU7r9JW9CxTcgSP9rIWl8h +oNT3o8O8czVbvv32+3+8e/pRUAvdmVrBnuXvwTL8vk+ZrE+Q5AA61IVuTt1g3/EPNGNhObvgStff +36w/X+5/1WBzis0lZWhaM9tZ4rWms0rT0+HgmRusOIn0Sla0IXRgnF+1+i/tYBNnx19+/ZfN4QUS +nuYSYJ3hrKDYgajQw0AAhsvxPSiD5xLSvNheAJcIlUh9SRk1KK9Bwm3gUa8Dz4EVE8Bms0V6DVdq +BvKE41sM3yaNS8SurE5UbSKKfYYp8K+lilSra9CiDBMAlyxzpmsjTR2axpxhc2AUC1Zlk0rVrjdI +17x63UGO1Wo2IitK7Qbtg93KZZFh4mrVKZXAmCbLgYxQsxDJIYhDAG2JHWSaLPeJ/5J6SDMSGqmj +qgNoZpwT+g3nxPUjtSC6atDzwKWaRdR7zSiXdaQToeOq8XukQv7Icg/05Pp7kGqQ98gxnBYBFcSi +UXeg2XBC0imbj8uYBKktqT3NQB6mtbpO+sYCJKU2iYW1aXXf9qefvOBA07q20dldvR7P70SlpRoj +zRzZ/jxO97v9GydcVeuu484sZwqNl2bnYXwZRteoWS8+l3XkW6Srve7wmmJ9qHFZGXT7b6arT8vD +LxdHn5vxQrfHk8X7qDin+Oa2Gcowys6z9vO888J0dnFJljMjfUXZlOEBJv0oPc2aT6fLz5P2NcV1 +BWgtuSOTgQByJ26w53i7xFGKbUysYU0g+wW5HWfn890vw/zMSw7bw2tebtZIDXag4uBEwLzgEUh6 +TZvijUAclaqpKd0kPYT5RUogIpB2jnek6TOmgereIk/DR8R50thopBprfIUwloQO5qFU0Ss1C7SF +a8OPNA1t1q7WSBehSg0hUxk2hAdHrKFUbXNRZJeGsWjQ8NH+1pH1kB6NOsxU1KBcvISiYdbgkVOK +Jmqf9AKuQxIHFDix4UP5C1u1AHhU9QmCDr+ATLCdFb5CIOFHvJHjrkEfIHEwYKPusmxWrdrlsgIc +I6KuagEJWYb0lCGoWIcdAxc7VSRY3cYb8VwTuQRRJ/KFqU+qDWSUjGwslxSadI0fQJSCdit1E5PG +CVGlwj9+3ICClSG5mVhVgZ9TUv7uQlQ7NCHl3DHHw9HzIN3HaR1vA+0tak3VbHvBUDfBWTFZK8jO +oXibraeGvYY1ZoV2jU45oQMdG0WHtr+oM46kIjMHjr8ynKnhLQR9yKvdKD9b7H0dFacswMGcSTry +duMnZ054bLr7sNt4Pg1xIhbIBIZPTGftRReGeyTqCwleSR1DyQBst31aOwyXongbNMRM1/NPSQtC +xgWegKwxXigugbSI7cva0A8O8uY1zSc0F0L2s6SZLwQ2OMWGtEAEDX0cx/ssyrAsQ3vj/FvTnTQg +fmoIegxnBwDBV0keWs6JYe7DektCr0aqmPRyRS2XyjBoQoOKObYHhUyCzpBW7PCzSFcgEhJjO+dj +QezWqRjaCUmiaRMoc0nILK3PceFOiUU2Iq84rsWy4KkWCJpjcwvmmnaf7NBV0kgXiBeJpKCgS5Fm +rm2vbWcX0QGHQjMTnb/taYjfVCoqLhtvQYZAuEzEAwDI0BnLFsg3XBgENqifUGfNJO1E6y5kGyoC +tNtrnV2f/axUVR8/YXEqkW+5UMvegBd8cjE1cLpfrvBPHlerZR6wxqBA6jZkJBQmwtGgLTh9iGrb +WrjOynbnCCvss+WuJKNXpw1BjlWtadkD4FVcXDjBLsWFhrtipWaVNHhqIsHi9DzJzwx7Wmc82CVe +LsCPNB/xShMOznB2W/13YXZlemtOLqL0GGmGWJMm0eYia7/szT7Z8bGok+6xyCteaTW4AK/ykhsn +urGQOdqQ5pFLUZqdBckhfAfxcZSLwgQr4eLxIyKFagU5wl0a1ixp3bjxiUwarJP2c3B2truwgk2D +i0s1Hb/R9BGqD3OlkLbLpHm9JLTwFiUSAgZBhCJimVASctQjIo7SBjJTjIcpRbYg7jyPkiyQM6Wy +SoQ3UIsNwbBlolss8AtRTTUbyAZWBQOKUosmnjElzEt6yCLfYEUhtAzkFc24tapq6jBH0y1TY4xu +qWxQjRAxhTvb2WkIfKzIbZo0CAsrIFACMq6mTlz/CJhMWLhh/b7xLmkJyqXwtoAppMqTHapcEZB4 +MLyiAGqzUEcwpIAvgjZKy4dZlrrb1Q/pCWmubWAsotyEUSKNEflY19sNSi9X2HKZrpRZmvJ0bei5 +C0EIWMoIvBEUJiCXpn2i95RWHWkgBKrWQrDA72RyYK4bNll8s+eKOaQZx/EnktbCb8hCDQQqQ6Cj +6Ly0vF2ogrg4pHkfE97YNpCloFrlIs6OgvjA8WZZ90yxRpI20Kw5PCmFTJBare5de/iKl8HI/dbg +ZdS81t01bBdFWnMOk/wq7V4D9KDTzHDd4CLS9LNOGq6BDePkBEiLIdjuFGkArULULxWybBqFx83W +jWoOWcbv9C/tZFaj9Srl1DA0jnDlZPZ+svuN4ix4MY+zQ0EB70CNGFC8CCVoK0/OLGtWqSkUZYhi +Wq6IqHSEGwlAWpqKOcODUhVOiOEiaSaBtAZbVatupYp49WDQKNppkAdZFmsQ9ULysFTW8GRdX0Ak +wHGwQkyxHoK4s0MET6MBetIlKaMpR5GyPFszPIAOriHewtqQoROqAeR0KhVJkVs8GwK4wFkMk7Kk +g21B2lOSFV3MT4F3r9b1WsMkXddruDATDAX5VK1hFDrLBVuJJe/s8MBhYNTWI3i+t/rq278mi2Ml +rlZTIfPwS+QtqLCGkzNxv385GJ4gqai6qEqBKqWwn9tsCYFUklgMRk/hxeBGkbdbxItqpP9v4LnT +7dKKUa/5LJNwpJ9yrukDsvSktGerV5rd3ykrVXhPIokj1Rh3+ne6NfPc5fXLP6hSGlnj4uGjm7Lc +NswhUsvxFv3O2cWLn8xgXt0mBiBalgdhdLY++Kk7eScoPd0YhcUJI2UUF4O5VMj48LA9eB23r/Jk +/+37XyedgydlYYvPpC04itF29mVtAjs/GL+Efq5UbGgG/Ih/db1d2GTSyV1sr/Y+qk5zp0QBK0jv +eKWpmYPl3qfl0TeGt/Sd2f7Rhwbn7JToUomX5Bbps6kOwmAfhIUykZScF+ItPckNAg== + + + KcQXI9tFOWM5N0iA29HvF7pLZXg9ONyeCQ0mQgilrjdTtO6THX5nh4NPB49sSadpmLsy0Q8pI0TV +urrFEwOYA7cFhESlQ2757iQtdquUuV0Wg9GAwEsISVUduuEpUst3FxxSSMp1fQhbByAl7apBZCBu +Ph0MbmS1BexCRSAVea5NbYsO4hwZpcqpYyPHkFoKALlWhegiLwStw1Een39TZ6xaRZa4GAYE2FUq +kYuvN0Aurbx5GkTLaoWXeFeVQ46Bs4BPcWSlYztzwJ1mTiGTaiDTul2pwL+4HAKhtExrCEgHBTfq +AY8MkTNSmCQbW0l0NJq/VI0eQJ4nq38o8HgrmAuWrJfOL1/8osG5stw0zbGidIFjktIRpEKQ0kH3 +9OXH3/rppk7kaI7ascyFHx40+081e9rYsrnmjquMo+idonUqKF0ORlhqq+ZkuXj569/9Z/PdO7yv +KvdEYBoTIEUVdeUG57Z3kLSfceoYdsyxoNCAtOD3DO8LHWto4yDepzgPM2wS4dRjOJ8VAmCvqLVF +pTntXf7uT/8lKwalEicKUZLtAWkRo3IFteNCqoXxGpYHmMMLEcf5vJCCFHBmDDwOdj9++5esBLeu +bu9JxfjK8wXoD1CTpJsXL/9wtnoDTimV2FpNRiaAXMpVA9iLGKn6AOAAXQc+BdpAG1crcrksQdE5 +5jwM1prZqzQsMCZwcqcsg0FAyobaNdSeY03CcC2JeRrv0owH2NnZYSkMnOjkAnWaFcea0f49DNbr ++tYeGsQngr752HV6njvatuGGRCSZgwSDIMQDAcIElso8HI1nLwGPjx/VyiWcHGZwCLCFa4CFrFRk +ikgpHW+N7zk2A3ZtbyLYnACt6+2UJWAUmFEUCwFOnM/hVsoVksBVAlyGICaCkJrGqFlcWMEuRD5p +r8lFDLkj5vJShqTSjKHtLWAhdWvMS80w3o9bp7IG897VjIGktlW9G8Vr1RxUKNCZRyQ35ZH+wmAo +ygIX68YA84zzc3JL1noAw2oDJ2/54X539KIYvXTTE0HrN5gAwEvMOGVVKVvW+nCjkjLSrA0nDcPo +IoxPIK4ajIN44Qoxb/UG3FZKpDId1mkkjFAqs/gq4jqT07x9kTf32t1DiBwoHAuhrPHlCocfMRWO +s9GMhaLDbyaQyhwf1SmDVBP8rzlAoqbpZXt8VyW3nEwUVKWCSUZ1S9WqTFG2YY/daFczJ2T1ifUa +da1WUxAIRJ8jK2btBp1C5CvKLIhuBLlLLCEFxYVw2BD2DYqs3Sn6PG0+g5sgTL1tLl8GRFR1jnbp +hivyWZbsIxkoKgIm8xz40aapAH6EYsh9MdOc4jk7kNllFe/LMKQtcplIR5W4XeAkuWujAHksY0g8 +CHmoeFC0L8kDJAkgi+fgRj2UHjxyuaITi0qTizH1GYi+XrUcfbJTkh49gu4inbWJOKmD+mUCoWRB +wwAdsxipPAJsAjzJokcVqZWR3s0MEikC1RKucVeGMWahWITEckaS2qS5hBVbDN/lpXGSPesMPySd +WxgWRe2CRgEjyGFANEiQYjOGK8DaeFORzy1zRHG+bnRNc2hYi6S4CZIzQe3AwkOry3DQcpOXCid6 +GrffuekFD7fI5bzUE8k6Q9FgLQbiUB12+m+d4JAX+xSborRFuQ1sQfljXBwHFbdQSJP3Tp0sEJnE +gzdsIK1q9QU1F7WWIMGRtYmuZkgx8kIiyBnNIj8TOAs4VkHug4XJXUWxCbKG1MSIttZ+qJlLQexJ +Ypd0ui/xVAPTqJRKNNiTYmPoSVZoSUR3+YAUBBQEUa2ohIbgExmcsC8pyL0WxbYkeaxrE5bzSXps +F0sRI05si3h3KE+p6zp7FARPReHZiIdorBlUHZQ04fg2x+U0DbWJhIFgLpC3ggQBP/a9PddeACLo +RlCvkV7Jjx5VIaKqRPOoOyUUGllKrRPzm8Fu0MRrmE9KElC0VvNqNVx2kMQbBAhZLbIJx5AbqQBD +DASvArVJ/CAPL2E2SyUINh3W+PETDgBOUT5ZoAPbwjzSwNKOrk8BKaD+WtXBC2W52yBLGWqd4Eyq +KmPf38cM4wJ0rVc0j3k5JQvvQlszN3503ey8sYMDGDHMRpqdGNuGxQi3pvVse247G1UbgSyqNUuX ++838rMECok1wsRcdDeefkuYN8odiYjc81qwVqUc6iIoXXnolqAMES5R7XnQS5teGCSXctP2ZpPRs +b5cVMtIdmIfT7+rmlBcwURr0HoRNg84bTFGnkzoFRmtrGvTPEHmCohDUQjWgrJYs/B0bVatao+aY +BAmzclUECZruXHemFAu8IguGjnfghyc0QU6XJXcDQbtduHueb9XqPnSygAqi7VKZg/8indMxUrAG +po6ORR6kUNTr/s4THuUP+Q01UiGrXuCgWDd3w/Da80/ISpE+ESVcgERcHuUA1SUiqHqOu8vQLs96 +utKulIUSvFtZ1+QFXgLGJLUP9UuHEBssl0I7gZsYOpOELr4KbBuF9vhxHexWrZC7k0+ecI8eMRXi +OgEdEcCkCmzhCvD1kx1ZELoch9nr8HwvivYNA5q28O0lxya/l471qoms49kcnkXkm6WSXCdOUwF8 +NequH5xilrbLFxYKGWlWIzcawMtenYQpY1ko1byMi6wYYCJEuV4nNyMgxhrQe/rcDQ/I5hPKkdWB +rA5ZMYclKVUV4CFqJ86OQXMU2ViSsTw4FMkJXnAkqaVrY9taWi5UvcwJPqKs2UPZJLeKDAh4b9f0 +NixZLIK2AYC4OG21boAQIWgVcyHqM4ZtH0zfH55+XgfxNVxkMijMJnuBwKdxlYzIaTdP6uRGXihI +Y8NaSuRG6kBWJgxfYP6f3f7y5vlP8GiQVeUqnLgvi7kqd/JwXxJTlhj5Dvh6pyqUa7qijfzwMMmv +HW8fKkvT25rRLVeVHUIBGcENviAPNiZbcbhEVfGvOrnLzwTw+JB8ujoV+F6jEaNmeTap1zRYM5gy +XNV2VwBZ3SrX4Aezdn5lma16HfgZ1ilcmFGtgWrxZFPgIlNpuuYQ9FSH4IcnQorWQLXQPDLRwAIm +cAZggeVk6VgR+iqgVZvKwoBquE+e0E9IYmvIBHxTq9gwBRBRDOw85pDNdGMFWqk3AnxtAAZrfqkK +m+ltb0AMfW8ftAW/iRHhQfbhAKx2BHIlkHAYO7keJH+C0qsQwvUk0tUdVOJgNuAfFRWSg6z5A1tw +WphljJ0iMQIRy1Uo/Ia3XbJAufmVig6yY0g3eWSsQJadkQM0XhUC3Hg4ULmnGlPonGpV4nlcAEg8 +5/B22xvx0Jxpeqw7w52qDBYw7ZlpTZAnDTpGOVN0QhOgVgXOV5UcF1ynQyCMbq4cb687fBO2zyG6 +kD+mvYByIOswKOeKjAsQxKYk9+qNkBc6HN+sIOERnbrNMIkgNePsZLF5P5q/gCMQeLLsA9JHRvFc +CvmqiIUmtSxziAkB7JAlWUi1Bkls25k59kQ3h8jhrQy2tsv7GTIfpAAphSlCwgCpoAl9bwE/hclk +MByykB6VSSN1xCWk6WBLFhbm+clj9sljplrRGDoBcWigezakG46hIxAKsQCg1wamy4VypuoOwrql +dbNc5p88biBL8Uu64ct80zBGW0nm6GoX0hHsDG8Lc4q3QDqVSgregtw1ICSI962XnuDkqiImspCy +bE6zbYrFGJelqr4D7m7Ay+dIfk0bef6u7a0ZjtzRIIvMZenx4xqolqV9hnLLZaQ3hgZLiHngt6uj +TV7MWTYkkMhAGDRlpU32R/HE9yHH4HlZspabkBUwUoAgX79atVDpuH4kKi/knJTXaA8TiHzDSxAs +fA9VGUZ7ees8TI5ZsvzoQ7bBftKsxfLwRxny34JGjSH4+3UGL7eK5oVmkOUgso8FEEruAiNkESyh +64K2Wtv1eUgXCLyRIHXI+qfSJTvuqECQ2kAqxBfwCCVPEomARoCC1Y0ZmAtxhNpBQFEIMI+yPvCT +AzfYFcSBqs3wWiiQCpIfgKP0WDZBemBOgCQU24QkRhw5FhOVGsaA3MUWuqo6VaQeTe4C4OI10M32 +XrMB+wPV2mAizGS7dTxbvXoCZGtA9za3e6V08FSlCuXvb+8uRQhKpYzyV/GV3NErKTs7cg1cRgXI +E3AcwIGF1m2Y0HIoZFAYwkeTDWBILdAQpItS2qFLO0hOFV6+QkYaNrNLRU0fP648eVyjaiSXcGGA +BTBmbXs/EdoJ/wTTgW9wEryLQDacLHVzDqkGGH9S1uCRif3ZegeQHa6WZkHrbVHoQqsA/SS+YGlv +5wkssEIkIrKIjiGcNIPsQlH0PqQOLxaiMtjeKSY37wxn4kS7VrCqESsKyZoQJal08SBhqiNvYx6v +IkYspLiQKHmB6ByTbKHsC2Kh6wPPm3jBzHIWojJU9ZFKVqKmopxEyTpOj2CQRbGJMFUpt0o50Ofr +3S9MewCHzotJpWHvkKH5DagFckN/QnZyakORbNuIdypWqWJxAlFK8FZAbzCpqPQNey6q7Z0yD+9c +rRnATNC0pAyhlkVphGRuUHAQOhhcVHrj2WeT2SfT2pMVcg8RhUO2oDTIrZPtVk9zu9euxYs9GCUY +dkAfKqtB0CNk2JahL20L9JEj8ciyw3azDVnBLinVCtntiaG53sIOVojRdiUzID69rNIwhnSTouFQ +yFaTBlkFDSoVa2dHAott9TBSy6pD+bBkCVQUclMbMLRZqwLWUvApHBy4hmHJhlJZbtWryuNHSKFG +pSwDgZH/0H6yPIH/IoaizKki2d4A8qpVze3O4Ygi98ExRhlD3t6cUqFVGGJCc5ZvkkHRZPtHnazz +648eUU8eMeSqCIXlgtiRyO61Nr5RkRJigrQsk/Jxf59aLNe23HXSPAuSAz9ex80j1YSLnxnu2vLW +UX6atm+K/gteGXFkYwkMIIzwGMEl914FVH1PkIBmAYEjuYn8tFz49BFijfhaLghrrZt9z58H0b5m +znVzppCb5kPHXS0WHwfDO9dfwsiT1ScOjqwDLQSRDDek6UPY9gYH4WGh9pE5vNQxnIXlb0xvF2YN +anx7z9fb7nQdS2qfgkKWun58UnRvZZOscoM6G1vcK9ds2EnL2zfdIzBsiSxaAtli219a3gJXW63D +iGWcQPavms4crAp3CSRHdgGEWbK9BwZkD2PnpDaSDWrHsoaqNhalAZIWLo8RkCRwAXmdLFYTTCCE +COIWclnt87hgJqP5tMGQDQzQmRycMo1SbdfpVFSHtruGam1QMVljpNzt3gMNqgmyFsZTEFqq0teU +HvIK10ORe+iEd8itJRHx7cCJ14jtBecCRiBXNIqCO4uBirIEeAG/t3xvWm/oAF7d6MXZEQoB+Im0 +VI0x5C5DzFHTcYZkbzPlI9CIoKxNRXXEkA20eZkgHpKH3HYEoRAY4VMARZCcJNlJmh8j3HDQDE3S +ldyKZTPEUbcxw6v+7DZuH8MNRfmR4a1UpES02+zdDFcfs96t4SzJTV4hTpvHuj0HPg== + + + KGRloIfouOFKd8ZBuqfqfcdfJu1T0yPb80x3FTfPuqPnrf5lkB0p5hQUFkaHMWSVOdGM6fY5cydY +9CfPTW/GSgUGotm7ln/kRMeGtycidlrf9pZZ5wxAlDSv0s5zzV7ySlezFioS1RgDELb3JZusmEla +Gw/bn/vxflxchOmpYS81bSIrQ1AnTZYs+gLZuBhAV7PQljIiC16GusjIbRS5ixPioZl4Cdkbz/DA +GU83+khgXmrq1hw+VDPGcXoYwIw7M1UfataEk9s18BoyUO76yZEb7Ylql8SIicg9UKUj47QmKGAT +pIeqNVGMIa5T1ltQEYLSsv2FF+2h9HAZktbHG4FekcAME/BcKAqwUZGuDXV9rGPSVEw7QLiPESFd +KShSJsJL8CP+NQz2QBaA+jodkQ02dAIGh1sxzXGU7Ba9k7i5F2bL+cGbKD8h+3+4pmrMNHMla2PT +HmfJKkv3ZL3PiDkiS5NtYA7Oj+EQUhOgl2yW84J4JkiJbrQsZwwJDR8Hw+56J2TjnIPZ60CTgPt4 +saWSAK2z3pkVrsPiJOucO9HKjYBdAz9dDhbPB6tXXrJBDgTRbPfoMydcS9CH7gIlH+XHfrpvBQs7 +JF6vP7yZ773V7TEHCHKWSfMUedXsXxb9p7q70e09UK2i5ZKKKBfAh6Q4iopDL9lDttBCbocb3Zlo +9tj0Vk50FLVukvZN3r0NslPPX+wefpW0ryg+U81p2rpJ2/j9RZCeqOZQVFtIFYXsjU/AtobZ6w5v +RotX7cF1d/g0iA+BKhSbmu5SM8cs2cGYbrdGhLBvENvbm78u+eMOqalqfdOap/mFE+4a7sQJ5nFx +aLgjXs5Mb44h4+Elh5iozvBZ0b2MWkeKPSrDvAuFYU1sf+0lR/hKBugtkuJkdfBZe3JrJ3t576ro +3+RkC/dBZ3Kbd4+RXabT643Px8sXefd0e2f/95vt+6o19IOlpIANHRDf9i8Cxm64DzYhhFKckCw1 +hrIBPMdk4oX9ID6Yrd5N1u90ZwGokfUhHDq5Zc+HstIKkt3+8sVo983m/MvbD388WL3TnLnhQQtN +ahSE0MSwF3FyOF++603uMEDLW9LbBQFRzDRzAHWkkR2806Jz1h0/zbtnYbwgf7AjIxN2VX3Cky1q +ozA7Sjundgh+WZM/ydF6qjlwk10nPvDT47R9Pli8nO69CbKFn87y3nHaPUm6J8XwMsj3moMLL9u3 +wqXpz4Akuj00vYkbrfGq3vDF2fXPz25/6I5vouLIDNaIRZTtxcVBd3KXD15Pdr/BnMgq3AfQI1eN +XphuQMdJ58rwN7q37s3eRtmhH68sH4k9i1tXfnbmxsdOeNjpnp/e/BAWx3U2QuCa3dukdeWE+064 +hyTHk3VnGqRHvJzSnIvsjbJV0tq0BmQsRf8ailExh168YYRUJJBLKBsIgBwDahn2lCF/EdOR1S4v +4jdpq3c7XLzpze+6k2d4YLowTFSQbAx0b+pnB352OJi96oyeIVh+uqHYQJILwwCYtE1nFWdnqNDO +6Ha+9+np29+Odt9iepuDp0nrAqHfXH27uf52sLqLioNm5+D46rOTp18vj94hVYCEbrxnhSu8RZzv +2950NLoGhCK1vGiDh+0TKlkdfT7ZfZe1T5d7L5v9Y1ZMJa0bpgfd0e1g9WaI7PIWnNRKm4ey0a5T +umq0szYg62Awf3n09OdPP/62t3g9nN2+/PCHcXbMcD0/vQzziyg/74/uNmff571nyNVq3RSEVFWa +frRoj67T7mVr+Gxz/t1k8xFxbPVONvuvDGfO8dBm0NgDy9lL20978w/z/W/C7GQ0fY4CgaHTzFHS +vu5O3q6Pvnv56S+//vFfPH/1i7sPv8j7p2G+N1zdDdev8v75cHl3dvvT7cffFcMrzR6qVtd0Bmnr +CAA1P/hsffJ5a3D16tOfbi4+14Kp5oySYq/ZOxmuX2fDu9bsTdA5D5rHw9VrSctozjadYXtwMz/6 +Zn763fT46+nR1+3h85Prb7vj06hYdmfP084VkCrrXo8WLzcXX+GFfoxcPWTEWDY6JqIcb+L8KO9e +jtcfFwdfGe7Y8kZxtpK0xHQ7QbLsTp5P9z9M9z5sjr88u/4REs6L99xoH3iL4Rfd6+7o2XzzaXX0 +TW/yFkgLrhSVlhusmr2r3vxF2jkPi6O4fdoZP/WyPdWduumBnx/G7fP+7BVmeHP+jRetZSXT9bYk +wAhEmjHLm1eH19+tzz4tDj/tXf0wXr16+/kfYWbAnm60Ozv8cP3uVy+//M2br3578+L7onMQpevR +4s5wZpa/0t1lWJwe3/xy9/Sr6ebd+e1PKHxOTK1gChTNupezzYfjp98fPv3Z5vTT5z/8/aOrL+Lm +vmJ0bfJXLdftyYvV+dej9fvO8HZz9o1kdCU5bHX2XX9M0abtjWabd08/+93TD7/+9P3f/6f/xf+Y +Nk+j7Or0xW+Gyw+atTSc3bA4N72NSLYtJUAqTohAhc3eYXt02Z8DHz7kvWvFHM2WL/7Nf/e/tEY3 +ddrJm4enVz/kbcQLwPhVa/QSwPv+s99o7oRiQx/Kqn+z2P9ydfjt4fXPV8efvvru73//J//CS/f6 +4+cXL3759O2vbt788vD6m+v3v37x5V9c3vz4z//2f5gdAH6H3cHpfP+z3dNv9i++PXvx082H3+xf +fP7i9fcffvgLEOvJ9efPP/v19OCLpHd99PTHu6/+annxU9be789PwuZSMdpuvJ92rzrzV53Zi8XR +p9XpF8XgZP/y7WjvZdw8zDqnVjjLuyetwUWrf3H+7Nfj1QfN6brJrDu+cmMoqzXB4fZF3r3uTV+v +j77ZPf262dtv9Q7DbFP0L0arV4P53WL/3cHZZ5+++7MX738FtPSi5WTz9uD8q4sXP98/+2p58Plo +/TFMj6+ufrh59QeSWljeECmxPvl6vv9xuHpz9fJXz9/8ya///F8dXX4t6n3kfNF/hrTvjF6k3bvW +6NPe+S+DcFdR2oY9sbzJcP40653258+K/nl3fL06/Bhmh2CxoncVJKvB9GZ1+H60eJHka8sZgA0P +L79PmieD2TNcrRfvDufP5wfv2pOnureb9c43px8m6+d+PJvuvc47h6P59dH119PNm/bwYn387i// +6b/GqYJkffH8x2cff3t4+/PZwYf+9JkXHULQrjcfP//2H02Wz2UtSovV5ujt1asfb979dPril7cf +/ywuTvPWjROs6pQJedAcvjx/+duT218NV58NN58GRFRcLndfbA5fCnLMiRmUdtA8Swm5X/fGzwm6 +JvP94/eD6VPY86h52Zm/LUYvxpu33ckNI0YM50N9GVYrSjdF52owfzU7+Lg+/W5x8i18X7N90Z1c +t0eHs71n4/Vdb37bHp5eX3z8N//2f949/SBpRbt/en33p9d3f3Z59+ubd7/uzp/vH7z5m3/+X/0n +/83/BJVy/vyHZ5/92dndH20uf7h68+vrt3+Sd69+9Qf/6J/95/+2PT2pM54fH7YHz2b7Hy9e/vT+ +23+wf/nV09uv/8t/898vj98jB/ZOPs333yHl3nzx57/4zb/68pd/2xu/vbr49Pzlz5EeYbqbdZBU +V6Pl2+PbX7z59h9/8Qf/8uDqx/cffvn85TdONCt6p63hddw8Tlsnw/mzt9/81bsf/hq80OqeI/Es +b4wz+MkG9lPSp6I26Y9fHV1/p1tN2x9k7UOEGNIiaUOCnhydfvFXf/1fXz771vAmhze/Wp/9MN18 +uH77x6uLn5Leq6Tz1HKm3d6tbo8UvdXtn40Wz59/+N9Jeu93OaozXfQfuIOkvXfnXF05p67u6pxz +Drt375xzUtaWhAIoIYkMhiFjbOOAbZwwYAO2xxHnCDY2GIzHMzY4jGfm3Dn3POe5X8nPUz+AQNVV +a33fG6rWeuvMwvbFzswJBtQLk2+1tq7d/TFWTMfTvdbYodbghBjqwLUlcnOJ/DyI0khiTI/3nF4R +JUIAznBTsezC1OLNJy88DGC+unJqdeM0L+ViqV62upCvr/dnTx49e8+1+z8EGLK8eOTuBz/Unz8O +nshPJsEsgF/OlA7Xxs7Wx04Fw93V1WN7Jy/G4lUMJlpriKFBID4TyyxMrV4Pp+Z8aFiLdIBPoQWk +ADB+PZSakYOtdGHm0p1PbBy+xeMPgOjCyGyusZOqrivhPkbmBbF24sTtd9/3dDDUYoUiVFS8vJKu +bvXnbyG5nAcJYETEg6g+RJbVWigGLbYO05RvHw1nlnA82eseDOglt59hpUSqMFtpbTRH1+udxbGp +HU7JWZ20HCgUqxuF2na6uAIsJun1Um3+xOm7lg5d8BPhfH0521iPFeYbE3vpxoYWH4dZPrl3/dbr +DwWiVZONFVVApIEa6UDRNscPw6DNzB750svf7k4clJTi/PKZgzc/OLl5ZW7r8s7ePROrV0SldfOJ +a7dcfBinU2qoAz9aqK1nSsvF5npneq/aPyQGG8eOX1lYOUHx6UxlId/aCKemo+mZcmt76eCdndnz +odjE5MxJks8Om3HAfFEFW1cnuCp4DV7pZopz6UynWp/DqIgEhB4fA07k1Xo0OdUaP6pG2ySXbkyc +lEJNigcVUSeEksmlWb1hRmwksisuXwD0ZCwxGtAbrcH26OyxWGGOADFJZEulpct3PKXopUxpcnzx +dL1/OJicFNSyGKhgTAbn8nAX4fgAwTVBzal6U4OuCXeD0Va2OAvCaXpqd3b+KCifWmd9bH6vN7PX +mz7anznY6q3oeuPBB578xvd+urJzi8MTwMgkzRWhbFKl7WQJxnyCIBNXLn/gmU+/WCiOgYSrdI9A +a1RGT3RnL44tXgERSNKgvU7mqos2Y0+xTPGFfGMrVVzsjB+9/aFPL+1eCMfbxdq826sSXJ7XWiRX +ALrJV1Y3D962vH5eEAvV5kKmMk1wKT+RorlqMDLIlNezpRUE1fVgPRLroWQUhi4QM9wZr3ZpNq+H +2z5UsbtIho/Gs/3u+O7y7uVsYwX8hcXOWR00Smo4FVRDtUR2Pl3ZqPa3JxbPrB27IwSExWeK9QUp +WBS0wtrRe6fXLhaaG/nqcqW9AXjiQcHUK7Lexeg4TkWjmUkog+bgYG/mSHtyW47UMDKgx+rJwmSu +uVrtHy50dsTQKEbGY/FWNNEDLyAq1VC4y7Fpv1/TtHptdKfY2QwmeuXOVqa6TAvpWHoMioGVi5xS +5dQqRkedXsWHBI8fu2bs7hlB/WgU2s3QOSwojZyfSGJUPJpolxuLQAGFysLc5tXG2M2h+GJ/4kyl +f1gKt8r15TNXn6Cl3D92dqBEhhWbodRyeeyWSHre5hIJOpYvz4OHypQXW5PHRmfPLm9cW1y9VKht +JvMLspw7fOy2Zm/V6ZX8dBIlExQP2DutxacBEILxAc3FtnfO5vMTGPhEqZbMzYbiU8BcwdhkrrYZ +jXYnZ0+kS7NQugC5FJsCkFSUSrk6X28v0XzKj0UwIgrlHdC7wfikqHVShYVYaiKRHA== + + + j0U7HJfu9ncLrU0p3OOU+o3HSmEfmuCl5tTiLYredCNB4Ecp2G6MHqn3D9VHD7b6hwWlkc1NnDp3 +L01HOLmWqW9CU1RHj8wfun1q5UwahCKZPH/p/snZHadhSKPByAwjZFFKd/ok8FaSUuOEAihSRswL +wW6yuJRvbkHDGgs10TDHZ8ORms1Bur2isZ9arIvaKEHXGB4kTd3mYFBM1vSinmyGEp1kaR5skRRq +J3MzoWhPVnLV8vT8xtlYYZKRCoxYFNRaIDQqB/t6ci5d3aCELNBxrjhX6WyWOxvl3g4TqPnIyI1y +HffhSirV3j1xz+aJ+0udQ5LWRDAYjTB4c2PXj0sxmVCng2HYFFBzKNFTYx09PfDTUUCV3uRxmE2a +z8YzU/X+MUDFYn1RDZUpLur0iFYb43SJFhtqtVOhcKfR2y21dmtjp0PZWfDCXlSRA5VCZS0YGceo +Aoh2SsigVKTWXqmPbrpRFS5ADw9wMu7HQrRUJqQ6YKDxvCJQU7SG26cWaxtTyxeTucV8abbd346k +pmDiQoHy0aO3xZN1m5sLZ2ayte3WxJnB7K3B6CTJV1AqKSvF40evptOjiF/PFucm50/XO9vJ3EIy +t0xxxXi8Pzp2GMUikWhvceNad/JMNDGtBtqBYIfmS3CnmeIML6VhpkgqFkkOQrF+u39ocukcK5Qd +diYgpe77wFPBYN3jC5JsVpArglyLpeY643tTC+dAsWczvanl06xc8iCSDxExPOT1Bt1uzY9EUb/x +bHNu4XSyMO/ygaeWPf6g2xd0esI0V+OVttnK7tvvBq+tBEZHTIixts0jgvLklSrD50Uuu7ZyLlYc +d2MyQup+IgpVrQR7itYmqYjVghN4LBAeFYKdaBoaZ8qPZ4CCXW6ZJKO8mKIZPZkeVSNtMdTS09OV +7rYe7cRj7a3Nc1OLxyg+glPhZHa8N35kbPpk1rAbY0Kg4SdjMJ7Z/AwQOisAX2xOL1/qTZ5Y3719 +efsqr2RK+e7u0cvZyjTQjct4dWg8WIvEpxJp8OwZpztAMxkfGnA6aZZPFlvrE8vnO+OHwV5tHr5v +MHMmmeyvLN/cHT/KyUWKz8CAwHm8qK4qPYbOO40XmhzFRGWtBIo6kJhEqBzO5sGwQwuwUhHBQzSX +qTZ342kDh1nBUBF2B4v4NVEsWs3IyIjLQInIaK68Umqsx0F+k3GUiFabm93x49AIOB0DGZApr8Wz +s0Z8Chv3IDDm8Uiqz0p5ks3cEP8FPT5ZbmyMju+xfNHjVTAsrIdb0MvQ76xQAK0CZjkQHjBMwecN +knRCUKo4k8OZgqqPNkYPTy3eOj5/S766BlxgtZNuD+fyMD6/SjJpLdZP5WdhHBS5ENDKZgsFfwjt +A6jOSyWCTJFUmmFyPrc01lk8dfZeH6YMDTmcdoJAgyrIJL2NICGblRa41Mv/8oPZmS2Lxe9HZD0G +Z5gNx+bSudV0ftkIi7AQkUgXdJTZgsPAekFoQd/xKV7Ja8Hy8sqJbHPCjfEEFw7Gm2q0zgdgRtJw +gz6PHIuOauE2cBlKhmHM3T4FxcMElRTkMmsMWmxz+3yhPqdG6pSUw9gYTulyIJcFu6eV/H5JlXPl ++kKxMqMEyz4sYHEwAL9g7hK5pUhiAJ0iafVsdX1s9gQIlVxlWg1XfLjU7c3u7l0SA5lhM0YyZT7Q +U0N9SanA+Di9GkjWdGGZV9NuNynJqXJ7tTt1dHb1bH92r97bCEWbsVj95MlLh09eM9tpjEzxclNU +2uHYOMcWfD7NC5OIh3BCh1mA2uaDLVbpCNpoprxdqB/C6JTdxahaLpYc5cQk3C/oUobNMkyWoTI+ +T8Ay4nVYEdSv0GxSDTbBqYG6cHsDglRRg21RrTjcfKowmSwvhFLjlJAC0+RDAgGtUm1ugD20WAmr +laTZHDRvPDVZqq5FYoMbW2BInIhmC3NmC8bwyVC0XW5vCMEWwWZcHsnp4oEH/YTuRUNqpN8c7I1O +n2qPHUkXFkmm6PLqMDJwPS437fUJFJMIJweTq7e2Bnvh+BQj5OHkCB6kxTQjpjgxpwZaidRUKj0r +goKiojyfMllQ04jPZSd8bpbEw04HZywmtNGymD9x9FI6WjOPIBQRVfUOwxc4rkhRSQyPWq2Mz6tl +0tM0nWX4rN1JenzQs+FwwrD8ranlXGs82xxrDGbnt46sHN3rL28riRKjpMPxbiBQD4e7FJ2wOSmv +jydJTZLTwXBVj9flUF4JF9Kl7rlL981unkhXR0kxRsupSKpW68+Hy323X4D/P58bDUerNjvKsIA8 +oHzEbHGh3D2sJadQJiYq8XRlVEvWtGSZVhNeKkBJkWA625qby/amcCmCs2Hj8TibcHmFEZPT6Wag +sBPZqcboLq/GCVLgpHAgVqYEXdSSarTIqqlwstafWpxe3wlmqgilqXorGOnf2KcgDg+7R4Y9bhef +zk7GUyByoH0C0MjJ0kIgNgCXhLEpHxHGGD2aqQpawoVyHlxi5HSptUZQaZuNMQ17/B6BJcMMFUNR +ze0RHW7Bh2qSWtESA5zLAnFgRHD7yLnF7ZOhVNXiQh0+QdE7odgYTiVGRnwmE2K1kX40iOERm91I +QnA4JU4ASu3G0tOhSF+UCztHzy9tHsvWxgguYnWRoBCUaI0N5N2oSPPhbHWWlQq0kIeSBo7GqXyz +e2IwfU7TWzYHAaXFcIloalQM5HilKCplWS0poVKxNV/sLOiJWiLTS2ZnMoXFaHzcaib33WQ9cMBN +0Uk91HQ76aED9pFhr9MuSmK5XFnO5hZoJm+xUGYTimIBTs4eGPEMmTwjZj/NldP5zURygaFyToeo +ahVJThYKrYXFrY3NY6fPX7n3oUceffrpTz3/uW9+99tvvfXOX//jP9/9t/df/dHPr939aGtsA67N +cmMNGIlHc6B1c+16ZdDqzg3G51bWd07efP6+hx65/YGHL9x73/GLl89dvePaBx65866HvvziV774 +yiurW0c2tk6WahOgBDAipARLAb3KCLFAIFWp9qZmFlfWNo+fPnnpzusfeOyRJz/5zIX7Hjhz9Z47 +Hnzi45/7zMvf+NrXv/fDr3zrux965nNLW8elQBrFVbeHITAlolcSybqshhPpYn98bnH98PTyVnt8 +amJhZWZtd/vY6See+sjPX/vFb3/3zkvf/OaFa3ePTawlUy23W3A7JK9bJbBwMjFaqSyQZNhupwQ+ +3husNPsL+dpEqjSab0xsHb310h0fuPehx7740kv3PPz4tfsfuePhJ7RoFaQUwJ3LwQpsRhRKslIX +pQJB6pF4NZVrlKrtZndmZuHgsdNXHv3g00889dS3vvf9X7351le+9e3zt90xM3+oUp3ixazXp3m8 +MkAQwyZAzcIJnU4BwyLx5KDWWU3me8l8+8TZix/61Kce//jHbv/A/fc98uT1ux+4cue99z/2wa98 +53sfe/bZO++57/j5q5yU9XgEt4ul6bCq1aKxMVkqJ1O9YLCYSLSarbnNg6cmp6eOn7z55lsvX7p2 ++/Nf+vIf/vTnf3vvz3967/033377qY9+slQaGzFhJhMFTReJTORyy3abYLMSiFcQhQxFZ3xICEFU +io4wbCyTae3unjx/+fYT565cv/fBxz/89JHjt/SnjzV6W6KUM9ay/pObp/VeY2JtafvUsVNXLtz6 +oScfefmlF3/1xq/f+f3vXv/1L998883/+vvff/eHf/3Kv3z96U98cuPQzeXWuhcJI95gFFy5nExF +Ml2wEDt7Z26+5dKV2x5//PFXvvb1r37rO5/90osfffZTX//2t1/7zW9ffPmr3/vOq3//+99f+vqr +H/rE54+fvZrMjBZK093BWqE2oem5XLYyPztzy7m9B++/8+Mf/9Bnv/Dpb33vW2+9++73Xvv5V159 +9fs/+8X77//5//zf//vn/4Ar+cP3fvrT+x9/qjO+Fo61ADBJQorp6Xqls7KyCsf2zu6Va9c+/LGn +n3vx88984TNPf/Yzz7304k9e+9mvf/OrP/777//nf//PW79796Of+NT5C7fnC2MSV2SIbCTcz5eW +/aiO+iRdTQNw7+4cun77HQ899vhDT334wSefeulr3/zxL1776euv/flvf/7Lf/znb377u9/9/vcv +feUbO4cuZPPTPF8Kal2OL4QTo3q00W7NLC5uHjm6d98H7n3sqQ9+/NnPPv/yyz95/Ze/+u1br735 +5m/eefv9v7z3v/7f/4Fu/fHPf/3FF76eK03anSxwosvFO4wVkipJJdRAKZ/rbmweuvfBB+599MFn +vvDsT9/45etv/uYbP/juy9/82lvvvv3279/5xRuv/en9P/1//+d//+7ddz77/HPnbr0tnW0zDOht +zOEgEEQSuHilNDk5vnr08Ok777r/occe+/JXX/rZr3753Z/88Ovf/fbv//THv/3Xf7397ttvvf3G +3//777/4za8+8PCj3f5KobKoBlsul7H42WLGOSoisNGIXq5Wp0CT9EanDx47ee8/P/j55z7/2hu/ +eucPf/jad771yzd/87/+53/e/9vfPv/iCw8//ui12+/R9SbHVVgiMGhPri9u3nz0xNWLZ++58+KT +j97zza+98O//9juo6Lfe/vUvf/mjF770qdtuO7+yspItNMPxDoqGfV6ZIYMCHdCVUD1fPrS1c9cd +dz3w4AceevjBTz3z0R//5Ec//PGPXvnay6+++u33//KXn/3q9edf/OILX37h4tW7FlaOtbqLipKN +R2qF0mg210ilyrOTSxsrawc3lu++fO5fXnnh619/6Tvf/fpbb//mT3/922u/efO1X//q3Xd/+x// ++dd3//3db37/G/c9fPfC6lY02ZCUrCgnFTFcLTZmp5dO7p05fuz4sUMH77p+5aWXvvjGGz9/853f +/ui117753W/86s2f/+sf3n77nTd+9w40y+tfeunFK1fvqLVmCFwnMD2o1eLJCYqMc7Qe1TKNYn1n +ffmJf77/a698+dXvf/e5L3/xZ6/99L0/v/+3//z7G2/9/L0//f71N372/POfeu75zx7eO6eFKyCH +AKyUQDkca0ZjtcHY7Mzk7PGjxz701GOf+ewnv/D851748nM/+8VP/uO//+tf3/vTa79+7fs/+Nr7 +7/3hd39496WvvvLE40+2OkuIPwjGzWGj3U4B8QUEPlOrzJQK3YPbu0988PFPf+HTn/vS8z99/efv +/fX99/7215+8/tM3337jvff//d/++PvXfvnj3/72tV+89oOnPvTY5duupjNNQYy5PQSUVkDL66FC +PFJZnl9/4P4HvvLVr/70tZ9974ffefdf337vL++9/e47v/7tm3/925/hPD/80Td/8rNXf/H6j556 +6smT525bOXiroBRNJtzjkj0uDkN4lx2jMHm0O33z6TMfeOD+L375hRdehtn8wk9++v3//O///P0f +//BTaLtf/AQm6rPPffLChVvWV3fDkVa5shaSEq1Kt15ulDK58YnRxeX56an+1vr0HQ== + + + 108+9NDl69dO3nruaLmUCgZEmmQQhEYRwWEjHDbc5cBJvxhTEuVEuVvtjHU7O5tr21srC7Ojp0+u +3XfP6YcfuHjblVuuXr966vzZwdR0OJKW5Fw4Btq75HWziIclUJ7CWBAuxw+d2dw8mEum2vn0obWZ +i+eO3H/vpSeeuOM73/jSLwFu3nz97d/98tnPP332lhPj0xMhPaEF8xRYV7+EorLEh48ePH3mzJVG +a7xSaU71uhtzE2dPbD778X/+7quvvPnWG+/+61vf/f4rX335s1/+4sc++ZF7H7v/wpHtzXZ7IhSp +uN0cQYS8iGKxga/B7HbS46JUVi0lYgeX5x++/eIrzz/78le/+NKLT//8J//y5z//4Quf//DV84eO +bs71mq1SqYbjnNOB0VQIDhRT4aBIlSWFWCjZLLfXZhaunDr81GP3fPoTj/7Ly8++8caP/+2P7/zl +r398/edf++RHH7x86VijVsRQFvUHSCLqsIOkMZYoW0x+AlFiWiGhZabGJpbmZ/f2jl689ez1K7fe +e/ulFz//0e98++UvPf/p55798Gc+/uiXn3vm0btvO7W7nUtXKTrg8bE+n4BjGsNGM5nRoJYl/FxC +T+2sbt11+53PPvOxjzz5yF1Xb/vok4/96Aevvvqdlx+559zHHrz+0UfvueXMse3VxX5rNJvtdvo7 +erhtNmNWC4WhEa9HcNlx1Mvk4qXdlbW7brvwpRc/+9LLX/zoRx596vH7nnv26R/94IefeeaZu69c +3lhaqZZrHK1iqOL2yE477bQhPg+F+hgS4zUtl0q1Ou3pmdlVmpcQP2hL1uNl3W7Gj0gEEXQ6qaED +VrvFj3plAgv4vQKFKrRxCCwtxcI5PZjyezHE6/f7cJYWGUbhlawbUa123OVkMGOfgmZ34SMmcLUo +7hcRD4MhgqyCSQlznBoQVcqPihSdjUVL+czE2OihI8cWV5YTiQTMo92BWe0omA6Qyi6XYHcwDict +islQqMiyYRyXeVaLahGwo1EtmE3E0olksVQdTMyEQ+FUJDraaNRz2RAnY14WXDOGBRkmrse6FJva +f8ABaicgl2Quo0vxZq5cTqTTQS2pBTcWFvuNfCUTHWs3kvEix6ocq1NUyo9odiths/itZq/F5Dab +fP9IsmLopCLkK7lBJloqJ/J3XLm4d3Crlo4P6tVGvjjTbc12qoVk0e8lhocspmG3zYINH3AMD7ms +FgywC/EqNB5WpWwEbFYsm0rkRS7g9/glVk3qxZCcKKTKY63JifaEygvpcDIkRilUdDroEQsxYiFd +HlWSSopSZJgw4uP8XujcSDRSg6YW+UyjuT63fH588pgixVC3JywpmXBSE4K4HwAThyoS5VKzdywQ +7Fmt1E3/jwmEKI5F3C6OQlWOUKJqNBNJJcOxbLwA8p3zEwLOBYSUJud1rRTWmy4XdIocjrZFpbr/ +JjuUisnkddgJxMORZJzns6XC+O6xq25EdrlBW6ZYLs8LRfCVBBH1eBUYARQxnpUNDdnhGDF5LWYM +9ck0GdMCNVEs8EySomNGkJSDtDkwHxr0IREYc5ZKYf6gxYq43JTbK4CwIVDZ62GcTpqgE4yUkwJF +Rcl5vaTPS1KEhKECRWminEEwFbw/TsShlfYbm/s8oHV9vgCGhXBCo2jd6WIcDtrrFW02zOUinU6C +wDTwyJKYp+kEy2VQNBCQ44KoD4/YRobcPrdCU3GgdYrJa+EJgsyYzThoYJ+Xt5gRy4jHZfU5LB6H +xe330EElJ7AhEhNJLOhyyeC+rTb6H1vLHXYBQ8Net2gzY05jp5Jgc4huX8jhkoHjSFIv5Hu72ycy +iaLd7BBwRSQjAqlTcDuAUUMus8mP+yNmE7LvJpNpxIujIbudgQNa3uNT4XpYqPxI1+8PwFUFtEom +N6tp9XCgSPlVn5v1uejx7hpL6QB3cCqUzBFclRVqslLFiKjLK3ugo2+E3yqBdiA8nsytZUsrrbE9 +LTJmtQLHCcVMz++T9++zWoxEC1lTm4PxE83OYYJMDx3wWEa8hfQYhoYODHlgNh0OFkWCilxNZ2bi +sXGnjTYNuXAfkKZgt1Fet+zzBlEsDq4Zfk4LjQ4PIyMmt8nsMlvcFrPHB76VTLDGg+txkkwkY6CF +Jjghy7BZv19HsShpLGsPIGjE7Qvs328dGnLAj9qsNIGGOTrNcVkov1J+rlJfHx7xjYy4YdIpNi0H +uqLSgNMiPkVgws3GLMOnTSaf2ey1WhGfT06k54OxcSlQZ5hEMlkNhfMeLwd/124HwAx6kaggNbOF +HT9MhNnvdYORbsGp7A7KasOg6nz+oCAVRaFiNYLRSIAyFNUAIf3+IIyYyyUSeFwLNkg2bjJ7PR5V +UZpqoE5SKQ8SJuiC3SmbLQSUn8NB7jd2LjhsZp/V7HPYMAILQbv5kQCApNMp7bsR9+F2K15v2O02 +MgdIMuVDdLsNpILmRYJGkp6ZMtt4GCs90klk+n5Mgzu1mHwUqkMFDu13DBl71XEw715PIBIc+Dy6 +2YzCYbXiw0Nuq42CETYWGODxoD4IRafdHpVhIppeJ5gk1LbDQo0Y69sRHAnWisssHTWPeGkyQnMl +lyfocKlOIy0qq4bGpEDb6wvieAhMSrV9KJaew/AUTqYdTtlkQlQx2x89giKhA/udOBmnqLTAZjWl +5EeCoN4P7LO7bPjs5CGCiJktFEEmECxKUBlF7aZzK4JQs5opm4X0Iyq0hmnE4/MIFJngxDonNhVt +lONLRgQloohSjJHiJgtis7NGCqhQloKNcGys0dtJ5SdpLsFJBYbLq6G2EuqRbMGNRBw39rdCs7s9 +N/b4D/kJLIZhMcQfEoWCHKgPjyBGGSASRsUUvUvwebtbhH9NxiqLy8cEtWKGMfTKKAalHgJPBFPj +cnHAjwe396YXdqC0EIA1IknTeYrK8UJVlNtQ7RwTCwXLXi83POyGufD7VZJO8HI9nJhWtQGOxdOp +8aBeh3sxKNjNo2gIgIXni9CJPp9GY6FqaZZiUjCDZhNqMdMeb9jl0V1uTY/2QXQdGHKBQyGB+u2k +y0khPtkCk25ERAYpKgMg4HLDVSVQf8zjDY6YEZuDRfB0INRL56ZYIedwika+mVd3e4Mg7yk6Ad1h +MpMcW6TJ1P6brEP7QX9oqjrK81WvJ2RkL5tIcBMcm4Dr8Xlkh5N33liI4vEGjEgTFEYmMjl9tNZe +8OMhuHKGzlFEkiJSJJHyeDT4W8CqPg/vdAJsGouxvf54IrMyv3Z3ubnr8mowCJyQQTEjMA3xJYwN +Vlo9FKzIYlkUygQedTqMNag2o7AdI8Ne84h/eMhgIo9b0LSKHw1DrXJ81gbywwEUIxhbz/bD/4n6 +fEHEF7zpn0xwAbhfwTHdbOFMFmHEzO0f8h8YxkBGbm+cnV49PWIjrE6e4mtyeCpWWM1U14OJcU4s +jLVXTpy/x09HbW7O5hI8SMyPpTi+GdBnbS4VMMHnUW8YCoWm0wydxnEYkJgfjwOS4JRGCzGCS6N0 +ghaLolbB6QTF5xW9H0svCXINoJvlkwhubARTQOqoRYwM+TANmJcgDIwaGnYNDXvsDhbKj2HSklCg +KGBbHDgFIBp4HLDd5Q36sDTJ1DixJkoVSanBbUYiNbeHs1pROBVgCE4kSSqtB2tbG2c5PjViQiwW +1I+ESTLLMEWGLeFUCoYObO+xo5dSmZ5RuhbU5xZBU/FCGdrQ45YBVCW1QlCRYZPXZPbb7KTbK+FU +Ugk2ESzEcOmZ5VNyqL7vgGvfPqfLKaFYBMfjAa0Ri4+5nKJlBCFRjWaTB4Z8Nw4EDp8vqmntaKTL +C1lRKrq9ssmC252syyPhRAp+ulTfnFg6x/BQY1K7u1auryNIyGKlTSbCaqG9HokiQsCYI8Megowl +0rOx9KwfTxjbrzwBTq3nG7vdqT1RKQNYkXQRxpxmM04n43axdit1Y6OfBvw+AqrPRhkbTFwi6g8h +XtXl4C1G7gTj8QUXl86pcm7fPpvJhAGKqnKbwDI4lnK7gS59TgcHJxw6YLPbcNAq0BRur8YpdZAo +qdRoIFI1gz/ya34qgXPZYHKSEosYnVC12vraLScvP+SnIigRlrVGODIRjUwkkzOyPjpsIRkyNtk/ +JMnlAwcARiioZBxLBkO9wfTZcmMjHq8fPXGFkYuUkI3nJjPVlVx9rdjaLnQOi8EuTseT0cbjj31s +MH8YWtLnk7w+xefXGa4Ujc8KUsNppMFrABo+IzwnjRFZP54lqaIWHNXCPZdHNJk8qLEiyNid4fXr +GJ6Ag2FyolTKFxdEMRfWq6FIF0F1Xiwreo9X634q5fJpLk8ArhZU041NuAGGK+iRUYZKgVDUQgUE +VfyIQpERqCuHnUP8OkHGQT5hZIxkM6yYBwqGLrbZSFDvVgtOU0mGTQf0dn1iD2UzJquRkgEg6Uc1 +0GZQfi6PAoxDg9pEobWxffvdQ8MIlIfHrZFkURDqoE8EqcaLFYrNomSc5nMgbj1G8FSE5fOCWnU5 +eYGJXr50vyRnADRMJr/XqwId01SCIMKgtZxOjmPTLJskyQhcTCIzka4siuF2KDXBikWcjAVDTQyL +mEZQq4XxeXUcT/NcQxQ6brdusXI4Go5Ge6B8QEvDfY0M+4aHfHB5BJEPhvupzCxYDCvYFmM3GY94 +g8amMJvo8emCXI0kBqBpJSEV0BI2u8/mwB1OzgiQ8RsvXoG2nF6JlYs4l/JgoVByQg6PRpNT7dFj +7fFTieIcx6VSqX44OUpS0ImaH1MBt0esBJyzXlsVZCMnx4+EKGP04pJULFaXo6mxXG5878xdjJJn +1Vyps94YHGlOHMk319OVVYovUGy831l86UvfPH7LnW6fiKGaIBRFqZ5ILeWKWyxfVdW60aRoxNgI +jGU4qaOGpxO57Xrv5nBq1gt+E1VDoTqChu0u0QYOlIgKchk0G8XmAuFetTp/5baHJxdudrrB+xT1 +5KQWn+K1XiA8GY7NgTJxexWKy91I0QkbexzcQafNiA7wepRUoi9JBahtq5WhiKgWqDB8npdrcrBV +bqxnSkt+POxyAyriNisJuk4OVOP5uWxzl5KqnFKTtS7oN7udMN4V6i34i5H4ZCI5DaUyZMS5++FX +AAHsdrAqBY4vs3yJ5oxAG0asCIE2K9egkW03wvAxIgl3pAQqYb0+PraGYQrUM4CVKIBUSEOBmczo +8LBH4HM8l4JftFlRhgon071oepQSclqkzwhlhs0HQ22aSRtJVkZqbhLxR26kAWh2I0QuoUiVTHoS +eMHrkREk4AAeH0EpMo0TaYrJAuwDpgGtuD3STTeZh42kHRBXaZ4vSEoZ7h0INxppgy8fHrbZbMAU +EkyKEzAfi4FXCsenqt2jwehoODUQgg053FGivWh2Wgp2QF0Makv33fnU2PxR0OdgXhAwKb6AKFcC +obaqtW0O2u2gcTzmdElmM+nxCiDUI8lBuriYLMyRTFjVcrXRdWOxsZw39hrE+tnSYg== + + + q7szMbO3ffQOVoz7UCEUahq5qWIFrgqBsiEieqwfy884vYrJjEdiM82xU63JvWhujuKKPjzhRgCL +irninKTVSC5D8xlOBPlaV8NN4PFArBnLdhu9pVhugONqs706sXRrtX+ClZu80oLD7pL73fXb7vhg +tjCw2CjQnyhWxrBSMrmYKx6Mp+YMFcdn1WANZIwFhKiD1hMTU3Nn9s49XG5to0R0ZWVvavoI9Dgv +pHO1xVJvtzx6ZHzhwtLOA4XaYVChFB0W1QLOxEDFAW/idN5uBF9IdgdjbA83Y14vUH/I7TG2cPrJ +NBdoxysbocySn8z4cU3VKrxcAhyjuawgFxW9ma0sapE2aBjAFrBmNhvjNlY4MD6f4vUFzBbcZgN3 +rNqtfjd4ajICLB+KDSKpGYovk2xRCfYr7SOZwrrdIQ4P+/xonOHKOJkRxDJqSOU4xUCpVAAJKSpu +sxpvM43EHi+YuwzLFkJ6BwzsTTeZrGbUYvKbRxCAMnAWLAdOPMOwBZKIO+3A0aLdwHMUZB7FZnip +nC7OpwoLE+NHr93x4XC8wwjZfH0zloGJa3dGj4wOjmera3avbDZjFJ2kgDfRsCiUKCZjlJMFSjqb +LU7jVAzuVxCygXBbTwySpUUtOqaq5fGxrSv3fMTtk2GIUoWlotH4C8XmRqGxEUlNIagmy0BJbZsd +rD2FEzEosHh6fn7rtvbUCR8Wdthpgoq6Ec3m5M02EkBGUFvp0ub82tVIfDQc66VLMxgdNttQlNBD +sc7M2s2X73ny9OWHezPHOSWfiVe3D15QI02TjUapRDI/nSrO8WonXVjsT26pwYLLHciWt/XYNEnn +JbkpKHW3TwXCLVUW6u11uCow4CDRZa2uBBucXLS7JY9PHZ06lKvOejBZj7V600fGV061JrbLnc1Y +doZTiiwb+8SnXjp36R6U1EAc6rHZUvdEvnVYDoxabRzMUa+9vLF9ed9+MK1BUeulG1vNuTOd+fOR +wrIbiwZDlaefeWFr55zFSoGrDUUH1d6x7RMPtMdOGcFxw06Ri9F0csSMWWw0VCzD13i5De4MbILb +SZNEiKLjXkSDLi62dxsTe3M7dy4dvq8zcZLlCgcOIL3R3VC4ZzeiVjH4CRgBoInO5JlEZt5tpH+I +oFd5DryPCs4C9JjdrYOgRTAjhRvU+xDoHxOG+3XEFyCJBMhsPxIFrvR5Qc+HADwJIgBT6YDi9MoY +FQaPE01NlJrLGB3hpGKpvZutbUUzC63Ro+HElBGHa6NxVJXkrM8PIy87jQBPyWrlPZ5IACynWATA +FLmsHqkhmOz1SzeWgWUKtdX+3M2D5fMcm+z11svNZT+lg/qKZadDiXFGrBaqa43Rw+HEGKgUji+m +srOR+Fg0MQgl+qxc96ExjoPOTQyN+A6MIF6fls7OJnOLicJKODlFUHEAq1xlTtTKXr8mKlUgoFpr +6fDe1dO33j+3djMtptvNuat3PJbKGcne+crG4VP/fP3Bz05s3CmFJ1AqDlPDUJlsfsFm5LzhfiMn +UHe6ZYyIa+G+kQ9gJHJzfn/E5RZ9aBilUnKoFU5MZipLgXCj2Zk/fOJKINQg6KgfVwgug/M5TikU +aguHTt+bLowbj0fQUKO/BzSqhNp2p2x38giiZlNj3d420CKKRmihwIh5Wiip4XE1NpYqz/Znj5+/ +44O96aPDJtKPx4LRgax1SCYDHmpkhAZIUaSiKGb37XfYXYIcGkRTq0pooIbGQA6B16ZoAyr9WGj9 +8OWz1x9dPXLbYOGcnpwGqB8xg/dhLt/+sVxpHqSm3x/T9B7ij9NMIZ2fB28LfeT18Pn8QBLSYBv3 +gQc0U5RQj+TW4vm1ZG4FxzI+b0hVm36fPnzAaRrBb4SgkuAlQRQ5ncYOoN5gHdQsXJtxs1gQaiMQ +m5J0Y2EwlJakNwhjiVpGDPQ4BXCsQmARjo5SZBhKCAcIRdMUWYbDj2b9WBpg1uHgqqWFdGFgpOpZ +UPDCvFQrNbcag6O5+ryu5c+fu392ac+DKonc9Nz6lcmlS5X24cHMmbH5s7LeNlvJQLAFVtcPhOuX +YUgJuiQpPagHXikNAwgb376JBPUWxWUxOkXzRYzKCIqxO5IWcoyQ16OjDJcShWSju9qeONycOFRo +zM8tnx6fPa4G63q0U+/uNHpbnYltLTHmRuNG7LNLjOqdXH7eZCFHTDgnlFV9TNG6oJd4sQ6A7HZJ +JBn3GRGUOMMXo6np3szpavdIIjutqoWd3dP//MFPAm/CGKKYLgV65ebOwRP3nL32VGfmJJSu08PH +0t1gvO9BtBsfGyIsds6PRsCYIP6w2y1wQg4xcokJl0fjpGYiN7994vqdD3/6zO1Px0vLVqfECnkY +Cg8ShJkCFsOxtCjWeaEOBmdo2AvQFIpNU0YyvAwmCOYOyFoB0U5EAAHGJnd6g41kdjycnGakNsmX +aaECVNKdOo+SaZtd1CLjklY30hVsnNujGfn2wyji1wqlBcQnH9hn2n+T2QUjYGyCnuDkBoJFh0YY +p0cHV2U2GU/AHHbR6VScLgU8FIpGjRhtPJqpLNJ4JJsZw4mw1U7BLcTzq1p8Tg71E6VV6CNgW8l4 +TtUkmBzcHWh+gEqng3c6BI9LBtsCw+52iqBLodRvxBLyoVDLacRVeWEirA4OroQRCpLxyYxqNNZo +tNeCoQbHpcdn9yaXz9RGNwPROs3FMCriQ3WvN6CqVQILuZwsKEM5MJ4pHKy29sbnLvmN8GeGoZPB +cBukkcPFgT33gWUI9DS9D+qXE/Od0fVma4UiQ7hfzhenFjYvHjpz/9Ez916592O13q4oVm49ecc9 +939QUHIIFkKIBAOWIbvUGdubnr8VxTL7h3zDgCFESouMqdDIaAy622ahQWyDF3Mb3zySlGA7oHcU +UHd0CifiopDLl2YGq2cooeh2B0rl9Wb7RCY3PzW3N7NyhpWKTpcQ1Ip3PfTRQHR0ZITyeHVOBE3e +p9iSy6OC1Af60KM9cHB2J8MLxVhqOpmf600ePnHLvUvbF1ilGgq1T566Dr7P7VUDoU4iPZ3JLaSy +S5zQMr6HZadoKgpCC3hteAT0czBdXKr1d1PFBVBoKKbFEx2ni7M7WSgtaIK1Y/cOli/Vx0+QXGH/ +AT/ujx6/+QFKSAMjQMG7vBEvkpQDY7nSdr68O2w843K4nCRJRYdHkBsfdxM94NaZkhaZ4qUm/KLd +ivn9Mthku41F0CjJgJ9tzKye3bv8qBvuiE0hSBBBjNVrqt5WI/1Qal7PLOFslsCjxcIsw4H1VnjA +eT4vSmVBAKRKe9wyeP+hIfvwsHtoyG020s7JG5FloscVILAYjgZdTloQ8kqoEc9OxPPT5c52KD4G +XjgaH9VjVYIJUKxGMbogZHgxF9Cakci4F2Sti2fIMIoFHU4aBCrHZkjKiPjz+XSWzoGzBk8Eze7x +ygCeQFgWKwvUzPGlVGY6EKpjWIDEA8FwIRDJx0v95uT22NyJUnWxUJhdXTtbqE6RTCwS7+eqG4LW +jqZnMuV1VZ/y+ZIIEpXlMi9kQVw5wBva2BviIUiTafAXNF3E0DCo62GTc/+QzeuVQ3ovGp8tVnfm +t6+BBguoxfWtW/XkAODL6eK9NzZ30HQ2Eh0tN1dHLLTZRPJsGVDR5mCHRrxwOFw8JxSC4R4Kpe4T +oPUoKuZyCSDk3H7Va6wCzbW7h6bmToDnEqVcs7tDMxmPW7JbGeuNcG+7jaLpqNNJY0TI4wtSdC4U +6UtwMeEOK5U5pdLu7/BinuUSre5qfXQT/gSls25/0IMEJKUWjoPjXjWChsAAaq1wfFaPzibzi5La +stkDUHt2G9NpLkxNbhoxcWbM7Q3waj1ZXql0DinB7tCwXw/Wcrmu2eQ9sN8BaADCIBLrSUoBGsFh +YzweDQ5eyHNSgWaT4MvS5bVkYbU1OJ0urWnRrheVtWC12dlVtLofizpdQTCtTuNjeZTVSlgsuNmC +/eO7DP9IwyOwFOqLkP5ILFiZnTtCsDFWTLcmDx09/8ixi4935s6osXGKTYbU7OLM9tzcKVmtur2i +0y0gxtvGMIYGI3oNQ1WXiwwoWUXKgmHB8KTPn7I7AjcKGHcY7+zIkRHARgxQFNyNIDZ4vgY+wocG +OD5Z7y5Mzm0tbp5ePXxpbffCzvFrkwunMvU1jI5VylObG2c5IeHxCYJckNUWzdZkdRRFkx5PALgY +zLXPoyI+HUUTKBL1gMTyyjDIHJMR5BLDxRQ158cCOBkl6DROp3m1qun1emPxxKk7pUBZlPLgLBgu +JwcqsfhkINChmRyI4WikUSnN2Y0cbI/Nznt9uijVOKHE8QUCj4RCVUBd+K+go8CSJ7ML7cGx3vTx +9d3r8M/Q+53O8srGuX+Ey/mRAGYsxaERr8SycRwNlKrTgpQFEIPCg3YTA/V4cbE5c2Zl+/Z4or+6 +fOyr3/pxJNa32mSarYOnKFRWzl1+7PTFJ6Tg6IEhFLpGEIrwK9BWJiNjkLHbNUUdDYYHilpFfAoI +J5eTc7l4u5OzuXiTTTAbH/JQtVBbkHMOFw0m2m4nrVbMaqw941BjOQfwfpygc4IKzqgKhitXWYjm +xuP5mUJrK5yZFfUOKOR2Z3tt6/aA3rQZEdxG+AlLZzEs5vUEgBCBJY1kcuPjaLRx727N61JwRIvo +pU5/KRRt1JoLc1vncvXZXH0hVphn1TZGpcLBysbK6cXly+iNj2i43BxJJnmhQrMZSSqRVEISs/n8 +OEGEwGt7AT2YKsvVKSZvvxH+bMyCjYIeB1q58TZc9PpCNJcU1ALMb72x8JGPffG5V743MX8U/gRg +M5aZ6gwOVxqrY72duZnDmpbTAkU1UJWVqqq1CTJvt8nDQ8YnlkwjCJSW08FZjHdY3uEhl8WM2iw4 +jurBYKs3ujO3dNLmZEDVIMaH+XRRq6YLS9nSqhps4oTe662Vq/MeI6Wfx3FQpMYrMDDmuUy/VJgw +DfvMIyiORcHf+RHNYqGcTugplWXToXATCsN4PEimJKUUSw9UvcmLRU6oAHT3uquD8R2bjYXLoKkY +MKnbyft9MkWE/YgSi7dY8MgjHhQBzRPmpaKitzQAELmEY4Fcun7mzDWAR5av54u7hfJOKNRNpQax +xChBZ0GEy3yumJuAthoadt/4ZkFKEMfmFu+cXb0uqU2TiQDLAMzucbH79tv2Gx/R4B3OEEHkwHBh +dBTBNbdHOHDA8Q9wY/hsojAHpg+8djy/FEnN0VwhlZ3UEy0vqajRRrm71Rk/tnHojtMXHr/1+kd2 +jt/LChmOT4PMQBBwnUGLlRge9phNiNsFiMpQdMpp5OSwQCUeF09iAQxXRS3d6i0fP3PHYOGQF/4V +yDG/WG4eBtRVtVo42hHVutMjk2wKp6I+JACQTrNFQaxVG9vNLlj1jtXGY8AsDKB6haTybk/Q6lCt +TvXGB/4knIhAq7pcLPSLx8uHY82F1VOr2+fLzYWFleM7xy8GImWWT4QTo1qktbh2ug== + + + OziEEVHELwUC6eXlE9nsKPwtcNAeT9B4lojEGTqNeAM+j2w2+S1GUJ4R9gj3aDH7QRJEY/1kejKR +GohSen3j1lZ3C6UjfLBW7h1tTZxOFha1UGtu8VS1vggwBQMST07E4xOiUARytDtok8m37yaby86i +iIHJQ8N2kwn1eQMIEgC9ZDfemAgkHncYXtXn8wOfpkEnFMpLwaDx9gquhyJiAaVoZLgNewFOPS4B +R0MEZrzjtlr8TjtO4brDAcCOmSw4yAmJT4pcRBKTLJuMxrsXrz62feiKxxvA8aQgVIDTM4VFULAE +KrF06EbyM04QceNxKFvi2aIeBh2etFtJSYhFQmVQODfts3l8Bs2B8jEbX8LCrDbS5RGBd0wjXpsN +B6ECKAeOxuNVacNtJXAqzghFaL18dVnTCztHL8yu3Fytr/QGuzOrN/fn9hL5WZbPZHMDNVi8sTJH +hREYHjJWHBGokQymaWBbcrXGBoKFzWbE6xFoNpUpz20dv378wkOdsd1Llx64ctdT4WQfp5IknSWo +tCDXIonpaudkb+6Snprk+FSjuZmvrwajHVlrgJC22Y1840CgD+5j/5Br/wHXsJkguRqnjuJ04UZM +n8Qy2UxhnmKioCdTmdHDRy88+sFnjp25nq7OBxMDTiytbl1e3LxVDpX8RCAU6fUGB8vVBV1vZLM9 +SUrAdIDzpeg06Bm7w/jGqPH1HI9mpDdgYAwDQwcM1HI5GFkqasEezZZxIh2JVJdWjiXTbYqLRNL9 +ydVza0eudWdOlnvHpFDX5ZbzqfFT5+/D6JDFhrmNxclg840APbuF9Xs0hc9NT+ysbZw/cMB1YL8N +zg8kGIwOYEBwIgHYVSnPrKyfAy+M+EMUA+0cp+k47teCQUD1OMA4R4VFKet00A6HsXLGasbhV7we +CfHKphGnHxE4Lg5uCCqtUBqfXzsxvbgXz83VWpuAVByfmVs5S9MZp1My8v9trMPG+5CwoDRoJgU9 +ZTb5AAmhbn0eicTDBAr6B4cfNY8gIIM5Nr5/n3X/PvO+m8xDB+xQ1cDRipBlSb1WnUmAcbATqpz1 ++BRWyInBph4Hpb3YGuzVO5vzg9Wvfv2HO8cugWeUA7VUYTqamoAb18ITJJfx+CSOji0t3uzHwiPD +DovZ6XRgDjsFSAiqEtSsKKUEKYPhUU4oBuPdenelN7Fdrkxdve3ui9cf0BNNis8ns8uJ1EKtdWhx +647J+XNjUyeC4W4y1j14+IIUTLpRsJYRBE0DT6laT1Q6Hl/I7hTAlIFDsThki/EhMBwsEvisaGJW +j02CWTu0e+vo2LqsFfXEaLayVu8dm1q8sHvsnjPXP1Lr7zTaS8dvvhZOTYYiLVWrM2wGfDGoYsBD +VWl7fLLNbnScD9FlqatpY2Dw/f6I3WZkMnNMzmoFkPGByESQpJGf6QsYr4eEfDDSZKU0zcVhrHxo +TNaac0tnBhMHoTYqtQmSDQtSUg/VXMYkKm530OmQPU6NwmL18kKvuzl04yESiiqgB1AizkgVRipD +6/XHtiYmdwUxx/NAlBUtVJXkAsPE1aCRjEQS0UphHObRbsdtVgwqikChEXSvW7KZCcC0iF5OJY39 +ODwd6Y2v7564vHvyLj01S7IlBE0sL5/68le+Xcj0QUDabTRDpyShJkltQWq4PTLIDFUpjE4ejUSb +DjsB5WQz4S477fdKmE/R5AxFhQDYOSZrMRspu0ND4CY41Ke57aLfGwTqj8e61+96zOliCCrCiFkp +1AxnJtPlxWxxcmFm+9EnP90bbADRNzrbQIux9BSUFiMCeYGE4KJa+QMPPCvp1X37RoaHrCPDbgvc +kZ0FZuGZ2Gh9cu/mq6pe8YEqkAqckgsn2qnCoDW+VmrPU3wilhkrNjYktaFH+npswIr5QLAuSpVI +eLTaWJSDqUSuIWkNl0cDUkAJ3e6SwfnSdE6Sm+BwMTJlcYgHhhEQXV40ooa6DJ8X+OzG2tlef00N +VaLpiUpntzd9cnHj4rHTd40v7cWy49Ozh5557muBaBfUEUCZIFciib6mj0vyqBLoobiuqKV6a1OU +S8ZTGqf6j0RQOEgyy3Jls/E6mxwx+aDG3B4FLoOX64nsfHP0iBKEeUkPxraK5QWGy3T762OT2wK4 +JJ+CkzFwQJJYsNt4UINwWo8n5HUHvQ4BWB7gwjRCaFpNUfN2YDErIwc73ZnT+caGFukieNTnDzVa +y5F4HSMiBJWKxMYyhblwdCCJwI9hqCing6GpsMvJOI0XbWGfV7UZyyEU+sbONeBKWcrDySPJ7vTK +2ZXdK+u7t+0cub5z9OqgP8eQYEuDNJUw1nZ6jG82EUTKWK1BxMJ6u1CcD4eqThuJehXCr7tsNI4E +CL/mcdJWM0pTuUhkyguURweND0gdQNwO0WEHfZIG4SqKpVi0geEaRUdxMiRIuXhuYnz+xNbRy1tH +r4+vnsVoA3LHZ08KWo2ATmGyOJmi2RzHpUGfDybWwTnu32dxWimfW3M54DZZt4tDvFwl39g6cpZR +kh40GMvNBiJtOHNj8lCmtckqZUnKnNq7srZ1FpQVigJuFKLxycnpEwuLN8eTk6JSaVbGPvThT7bG +Du67yW61EW5AEn80GhtrtHa18JjXp25sXQgnOgdGvBYb5QWWwY3MOilQi6cH5fLU6uqx6cXjPjwg +ajCknVC0LgULlebi4b3bT11+jJGA9Ofy9TWSKyBoGCMTHiTs9hnvtTP5uWxxzotIwyMITafCuuEZ +USTudodGTIzJTHl98rDZ7XTTGK6HooN4YanQ2Co2t8A151L9hx/55PGz97rckhaux7IDPTXQIj3A +bcSveb2SIlc6vSMsVzKbKeN5tfFskBsa8mFoIhjsjo9t3Hb9YZYvgpJUQy1Ra/nwNOjMbHlteff2 +UKw1M3vw0tVH2qNbLrdqLI/0RYzgfSxKksb7Pp+HpwkdhLTTZURkj5hIu1P2+qPByGS5tpFIdgbj +mysHLx05f/+R8/dtnbgaivfcSIATMuX6cntwEApA1UrgdgkyieEGUNutnNMuOG0MwFQxM6Wp1f03 +WU0jPo+bdxvvizm3G5ShzLK59Z0LLrfyT//kMJlI0Mmy2glFBjBf+/d7XW4eQVU/rlJsTNYr5e7m +9MaF9tRpIdQXgtVYdrLU3sDJuK73Epm5WGYmmVtUIx2UClvsRiCqyyF4XaLdSgEqDg17oBL8qIZg +IZdPcXh4JVRWY1WCjyQK4xPLZ4vNtWJ9uTm6U22BmSqAfvYbG1gKPLhvMk5ScZZPiXK2054/d8ud +erQ1dMBJEBEt1BTlMoJGbqT2xXEqlsqOM2IaAMRmBwEJxBSR1DJUL4jAUr6zsXGkN77ix9R8dWlu +48rO8fs2D12bmD/Wnz4cTfeTsdZHPvnCHY98yvi4GBatd3bnV24rVQ6XKoeC4b7Hp1qsaDLRFKUc +zNGBISPk2WKVXZ4ITuWT6YlbLt97212Pgmm1OXkXEvCTCTFQq7fXmp3Dlc5xnMtD1aXLs4DVGBUj +6QxOJn1+wN5QZ3BcDjasDhbFI+DHb6g4DWoYABAkK0mGsoUxkFUulywGqsXGWnvs6Or2henFU6A5 +FTl15eJdL7zyjXZvwWYXWLYEKMrzVRSLwbQ6XaLA50gyagGX7RGEG2PFSZVSa2dp9/Z8aW5t6fDH +P/G5xdW9+c3zq8fv7Myfa8+cXti5vn7w4tahC6XGcqU6+5Vv/viBRz6OY8GAXFKUBiAYSyXDoZYm +13ye4IEDKDhWEEIjw4Zf3n+TbfiA1zCS/qQS7ElqPV+YVQJlVizIobagNWW9p8UmXB5JVPPpwkS7 +v6WEKoXGyujcydnNC7NbV8ZXL+ZaO2q0n4wPTu3dvXPkKiPmWaFcqK9nyqtScJoXx7zeiNVKgY1y +OKBfGPONZWxemLX/n6T3bI4su64F/8CIXQYuke5mXu+9N+m9d0gkvPcooACUAcr7qq7q6u6q9r7Z +ZLObTdv0LdE8SRQpPlqRHFGkpNGTRm5iNG8iJt6bmG9zshSBQBRQmch7zll77bXuPWdvwgWOL5Gb +jucnSvXZzYPbW2fuHF5/fnHrSr6xwcgVlPCAUOH4HAyrwSANRXSOL9fbe93Jo3h6juaBROejIO9E +FWCsQDASgC3Fhm7Nx1PLoloGK+sPsgTlBIKsP0DRbEwxasnsVKEyB75rZpWm7UJ1qdHdqXc2Yqnp +dHExU1pQjUrMrR2cvb64cQbBdC8xma0seOlx1WqxYiUQkkFooFHp7JlbhcIMyF8+nwBBXjSajMLJ +cMRKZyZv3n6hN7k1PIxRTMpMTMcLK53po2v33nn2tY/ntx5gZLpZnTt3eIcXEwBjmfzK2PT16aWn +S40LhtONwAocVa5celiurvX3MI9QwE3DqAccejy3WO7sA6vSaixNTm0DPifIOCsVeaWSzc9NLlyo +tHdjiS6gzWy2p2iloX73XnRkhCborKy1DbMbDqujo7SkloqNLV4qADVOsQlGTMOopmnFQmlWUjLj +s2fPXH252t1NFWYFJQ+ukKY8y66fvfjsG5/5+sLKRWCsNL3LMLlwSIJCtG8IGRroF7QfHKBNexws +xKc+NTxwMjoyTAZ8wDKYFFsE1x+NGrpaAekYI2Plsd3Nw8dnb749vngVWI9yY3195+7VO29Ozx5c +v/fa7PqFRHl6fOkIKCavuGbHQYq5eeXG61OLR6JWNd2JQn09U1xW7CkET/5nt4WBkxEcszHMCPV3 +0tIY4bBijpcLbnoylunt7N+6+vSrXq6bq8+3pkF0n0qV1qrtc73ZG9nSehTTEUwTlDLFZ1WzpbuT +kjGhe3Oc3MTxJNR/7sYQVIxgsyHYRohMvxQtnQr0Wxt4ulFB+ndWyScHz8dbE+cnFy/laps0XxCl +TGdiO5XvEbQdy87Orl8/uvH69vnn44V5zanitMZxzsLSoWJkUFLjlALF5/u0ySYo3CnkJhynDnRj +qF8Vv9+cBRAmFDG9eK9YXmC5/qkEHAeKvSppJVkrFOuLc+uXU6UlBLe3lw9efvUztl0gCLs5dq7R +PV8ob1jutL9/fwYHFu/mteebrbXBfpPZfg1Vxegkcyu17tlic4ehvXt3Hl25fs83ioNYy5TWp1dv +XXn6vXO33vVyq1DUxDHtC1/8+vb2RX9I+s8OI5o56SaWaaYwOIhEI1K7s5mvrg2PkBCkwkh/vwEv +l5z4tOn1BCF1697Lz730WddtR2FdlMt2bCJXWl47df36g3e600cMX6aotCTXg/3m0eGnnhoBw/SN +MIBdCTIXDBrHjwWjkJhKTAA7OTwI7AMbhV2QFgNBlaHSQNeB2VPMeqmxWevsU3xZUfPN7un21BmQ +Ms4f3n302vuN3oaV7B5ee+Xu4y9unn1xYfXOi69/Y379tmo0C5nZ3YNnnGR7NMiFIA2oNZ71ohE+ +0O9GpMTtandsi+eToRAHo7qgFDPVtVJ3d3bt6sTyke5WlzePxubOZOpr6dq6mZwR9A== + + + Gi3lRaueqayYyV6EMHEuCYPRmd1EeRvhygHIRqkMp9Xc9CzBpjmtxGp1gi1xYpli8xTTt7ehsAhC +j6QdnDYA4Be37y/u3O/OXap0dtOlZbD0XqyxceaOk+nFslPzp57ONE4p7phsVIBjXVk9RHElEGRS +uSXNGmPZjG7UYdgKBnmKckyrznL5Y8fCA/1ncxInJPPlNc1sQpAeGGUdu4Gi4L1YOExXGku3H7xx +5/7rixuX05kp3ShDEIshssCngdsa6vcCZig6VqwsFYvz8XjX76dOnAgB1wPD/RomBGlxfIqgbIrQ +y8WeYaaHhiCg7WfXr2wdPpxYPB/PzhF0PhIxOdZ75Y135ub3/CF5eITuF5bpt4fo34EBcg7HjHJl +TtNLT33KD3woSSRltSZpTUlv95+q29XnH7/29DOv8zzInonJ2euN8fOZ4iIgQ9sbRxDP1z8CwDVb +OyThDg6iGOJyXIWh0yTuwFHz+HEo6CfH28sffvTHI0PoSYA6HwMUhaK1XG8m5nY4ypiYWpfkNMhZ +FFvl9S6BS6XaYmN8tz25Wx/bSGQndbNSra+s7t1a3rnQntxI5We9FGCSJvC8tlXr9k4pWrm/lYXL +sEySJi0ArX5lgIgI/s2xcb+fCPhJoAwttz27cvX8zbfW957uzuwtzW//+C9+eu/Z1zSvZSWniq29 +RH4lX9te2rp78dYb8xvXGp3Nhy+/r7rdEGw56dli+3S1e+HU4RunLr46tXaj1dr81p/89P0vfz+C +OaNB5UmPPAUhk7I1Hk8vVmtLt+88u7F/ozV7ZmLlQnv2IFmeG58/M7t84fyVR7cfvZMuzlebazcf +vPvsq5/fu/jc2OyRm5pixQLLl0SlFYQAN9IgzCMw8EdJQazoZoPhsqxUCUEmLxRhRPYHUaQv6uqy +0RSlMoZ5ID0pam5y9kA1S4lUvVafzhTmdGeK5isUlaPIJHBe/9lFGkAiGlUx3AsGxcFBYKVZkogj +sAnSPUV5FO3RTExSC6peB6ps2IeHIR4H9g0G5l2S1bTjNbtT+3MrVzSjSlBWFO2f6Xiy4w6H+hur +LIZJ6XYbRsxQkA+McoBpA37eP0pHgO+D9VJzfW71Yntyz0lM43TKH+A0Oe86LQyzAcwwLAbsnq7V +aCoeBvgkvf88pRUJKSePR08cC504HgQ/YohGoP0naCTpHn/KH/QzvhGi3x5xIPLkEQwTGCV5PkGQ +BoiUeGYmkVsSODOTmyjWFpu9nUJj2/K6kpQFzjFdnOJlmxVU1cyKSi6ZW8pWNoHXC/Y3uBqKXJHk +wpMztnj/DGBYIHA3FODAYIcGI8AIE4RFkLao5r3MdKWxMT1/dnV17/rtZ+ZX9hvdrd2jRys7z5y7 +8ur2/r1yfdGwS7ZTr5Rnjy7dN2PAL0xPLFxc2b45NnuYqy46yY5iF7PpztMPXr329IswblvelGJ2 +Y+nFU+df3jr/Yr68ODO+/t3v/fnt51624u1cZbE1vTOxuH/z2Tc+/80//caf/vwzH3/34uVnP/7K +J6+880UvO+tlZo3YdLa8Obt86+jGp1d2HjNCSeTTval9EEQhSA2FJZxygXnUvZnuzFU3OQVE3dj4 +kiTlNKNpJ8cVuw7EpKjWmt39g4sv8XLStHOWW+OUSnP87PjcdTuxjKBZnMzqTk82WsC7qUoK4AHk +1nBI9wfk/jMFH0sz6WJljRdzUFQFemB66Xpj4rTqtCRgEtU8jAokayG4EomyFG1wYoKXcoKSU80y +J2ZCYZaX06unrhYrc0D7CXIZjmogfUQgTRQr0Yji8xGABAC0IFih+aTm9vLVXVFtMmxaYGMC17eW +qlYOBsThIZKmY7pZ44Qi4DcgIyFgMU5E/aMc0DkIQGxIRhFj1EcBXd3fGRgQKMIFP/pGSBA7QyN0 +EAKqxqH5NMnGTbdeqC0hmJt0C8l0m5cSTqxpuuOa2TXtsVR6JpGZ5ARLlm3NypG0rVstMz4tmy2Q +hhgm69q9eHx81EeGgxwKq5EI0CTc4AD0pKYQhEQN4PtQ1OCEFCtmG+3NU3t39g/vldtLvBx3YtXZ +5cNktpsvdpOZMVZIARCqakXTqrbTBCGcKUyXG8uylqeFHErYOO2oeta2itn8hJto9otAlgHeJkAU +TM2da42tJ71ir9F77rnHM8tbhpmfmtm9cu/Fuy+8+ezrn33w6qfvvvT6mav35pe3Hzx8/ujqc9Oz +Zy/dfG1q5ebM6p3V7bszi0fAtJK0F3Nqj177aHbtaGAIG/GRDJeS9EaqvNOcOGSFpCTEX3ntPdMs +A4EUwWwHGOfG9trph6cvvj61dlsQk0fnb7725oet3jbOpES9SfAlSqiPTV44uPxmrXcGxc3btx81 +OmujAb7fEj0gw2iMZPLNDtAhFzS9OtHbXli72hrfL7fXBb2E4B4nFRSrVmpvsHI+HOHAuBg+xotp +krGAASGZhO40JhYv3n/9q92ZA0Upmu5YtH9IhO4/0g3273cBy1BtrPNCVpKSidSYpDerY+d0b4pk +gHUC9FsWpSpIZ6GQSpJx22vF0z1BLqK422+TNwwYKQIWGsNdwLH9A0RD/c1sQ/1thP0Od0DMnzgR +RRC7339qAA3Dpua07eSUEetqVlPWG8GQpssJirH9QQojdU5Mx9Oz6eJ6sgAMYFmSk4lkXbPLUESw +nHa5tZevnaq0Tj8pStmvvzc6gllqwQETHqQHB8ODA2FAYsALUwRI0EmWStWbawTjiFLKAkhurmpe +m1dzut0oA8nKuaFQfyMQw5dS2ZVUYUOzuihqI7Bq2A1GyA75qEjUZJgkiCY30ZWUIorZwRDn8+E0 +ZQNVEAj2d5KQuKYJdtrJZ1NNUYwZarJemxqbXKqPTaVzHc0uGYlGsjhVac1Nr+zlq4uTk5tX778+ +s3EFzKSm5RnKRhEJjdBpt3Rq52qhNg/0s2l0ErFp2xmT1TqCg4yPq6K6u3sWJ2yGq9jxuXJjZ/X0 +/e1zD+Y3r7vJCZn3nn/4wk9//TfbZ25RQiFV3si3z05uPnf70Rd2ztyrNOZsO/P2pz/YPXsnBMnA +3Kn2ZLpyqj154fD6u+n8XMJtvPDCp28++64vIAB7Eo7qvFhe2bp7+en3Lj58383M12sLr733tUpj +JRyWoKgkaeVqa3/r3PO3nvtgcv4qMFbXbr6SL86f6Hfnifp8LILEACqyufm55cuSkLl5/cHH3/5T +QcxSfFX3ZsGnm/GFncNXj+5+ttzcR6Lm0w/evPf8W7FkZ9hHDg5j4Hs4LGNojOPrA/1eq+SZ01dv +3XgOEMixY75jT/k+9Uejx45Fw5BrOvMIbMwu7HfGN4AtlXXAezkU92As4Q+DtUsBk0XgumkWYFiK +gn/TMc3ppArL7d7u8qkbVnIcw9RsdtqJ9/o9TyEF6MYRH9PfHknZipiAISbkR1hKDgXQQIBEyRhG +p4CdIcgURiZCEK9pBSDh6pP7W+cfLu7cac9fieXW/EEGiQqaVorC/Vt/T5w+B4Vkjs2k8/M0lwUR +EY+NgUuCoiKY7RE/D9xiv3wfbChCLtDfTyKkc7NA7ipijiFjkbBMIBogn2SyTbNmIIBQlAUIR7WK +3ZnTG6dvzK0cWk4jkWg6sTZOWDznKUqapV0cUVhCp0nwFmZoGAPeiqFSIORxTEVgLRQUJC7BkjaF +m8CSgwDn2DQQzDhh0qzLMJ6sZBNutd2Yr9YXQEYAFz8+c77S3oynWrKakiTP0Dxb8xQp2X92P0Jx +TFICF8zEMEyPRoRomAXpyYuPCVozEFRiqdlkftGwWhMzBwubl0utNYIwi+n66b0r2dwkgXmJ1FQs +NWE4DUnNakYeuHLgZEUphxPu0JPmFEArWvaEF59T1BrLeJroVErdbm+tf0qxuBrLr1Z7h9XumVR+ +xk1N0kycRPi11TPrp66IUhZIQd1oEiRQX54s5v0+0j+CW0r+0XNvvfTqu8DL9PurjvB+yCG4Yqqw +lswumGr6wy9+9fHLb/t91InjkH+U54VKprzbXb0dDAohP8UzYB1rOKYD0gApCUw+0H7t3jYQQhSY +Pc5dnD9drsyGITka0YGIpdkUmBw4wgRHkdFhCA6jEitGoQgMYSwXKzR3dHdS1sdoPs/S5vT42s7u +9Vh6XNZLbhKY5QWUyITDAo1rEh8LB2koyOKoRWIuR6csqw18GYx4FB5XhZzCp5uVubmFQwjRQVpB +MRMKywFA+35SoM1sdtw/ygwPov0WzMMkAutgTlg2zrAuAIbr1UU5iWCi7dWLtbVYak63xpqdPS8+ +gSBaq7FULs+GQ/3KJFEYWHUvEHQQJCcKVXBJQT9syDFTL40C3xSS/vMJIAQZ/ZP4Ed3v5zSjH6Ek +lTLtjm3VKdIJhQQgg2naQxEtGCBpor8jkcA0AFoUUcOQMjxCgoggMcU/AvdPZ/vpcIBmCZOh4pxQ +wIh4KMSkc714thuNAotqymqW4+OKlLb1jMS74QApcl4q1YCjIKwIHFMAvBUFXHAaDMfvp4MBjiDc +CKSiiI6hJpglBBJkzuIoCxiKaEQutzdkrUxRMYqOo4gJ9BLPJjQlTaJq0I8PDUAgNgnMOHkiPHgy +EvChNMYKtBK3SsXsNIjTkycjQ4NENBojmDxOxjHMoiiZAaal3HbswsmT0f65MGeiPXFuZu3mxOIF +YDFwACfcQBEBR4R+dkBkMC5BSjluzXbrAPmq6OlKnCZ1sBA0ATxpAsN1HNP8PgyHRRRi8CglcxKJ +4jwj0ZTmJuusnEEwE4ZlQ4pvrewdHt3WdCDSYvHkdL15xkss4LiFRFgoQARHcTgsYIgKRwQkIpK4 +SVEJUapxdBqNKKaUOrd94cHjd2BMC0d4FNWigLiiGomCLyXgx0eH0TAQln7ghqRIVHtS5IGHIIlj +4rZTo2iLwJV8cTpbnIulpuxYz7DGOECJsGabFduugReDVfBi48nUKk7UEDgbCkq+oUg4gCiCJfLu +8X4ZmTAAMI6nKDKPYjEI0mHY9OJdlksDoQIjDsjj/V+iDhDGgBj7BUAGIpEgjQDvPIz0qyIM4SgG +KC5JoAaOSr7hiKnkU7ExFNYQSEIiGokDJaBFIDaX77qxit+P0aQhCDGGtjnaITEZDhNQAGVJLZ0s +hv0hOBQlUJBrbIpywcf5R6nBgYhvGAPS98TxwMgQgkSUkJ+JgvVCFDQM2APATOyMb6pyOhJiaMrF +UAfHTBARYB1HBqHhgWBgBCURdbhfoQIG9hCHDcfMWzqI7hQWNY4fD4JUeOJEX0s/OQaL+0dxkTcF +zsAx0TcCA7fIsmlFrVhWzUu0FbXkHyXCIZBPoyeOD0eCKIaCBeI5xigXx1Oplq7nMVSBwsToaCQU +oEk8jaMmjsrpeKs6tjk4ArgCGhkK+YZCJMLwpGTpiX4lIjfDy7FQn+rdVmUqB1QQ76Iwn4zVTCMP +MhGCGcPDeDjIRMK8DMyLnMNQGQROKEBEQhQcEQGnjY5QaESztWy1OF4sdmlSNvUkTQ== + + + WUCjgjeiUREOi8ePhwFlRcP9oQ2c9I8GhEjUYbmiqjZNq6MbZSTKAfKZmd2VVGBGPKDiJLnseWOF +wpxl9+8cBgM0TVssawOo95+L9RtQ4gjw/rAQDhG+4XDQFyFgHoHApbJ+P5AxtqKUBb5PFBAkPjFZ +dcA5DFt13MX+IRdED/YftAFeJYYHg1CIATaHpuOamuFY70lphUBgBJ6f2tzfv0niht+Hhv0kHOQk +1gODQiJCKEAOD4QxRGRpwDZiKEBhUY5COAYXSExEokjQ58cjCPgRRCLPpVgm0X9OPUpAIRas0fGn +RvxDmH8EHQYwOOYfOh4aHcZhSGIJSxESQLekY7kz+1eAyATJLuxnAatEQkI0xNOoAeDnG4Ids+7a +YwikECBHhPiRQeTYp0Z9w2BdZPCJJ46NULjKs17QTwVHwRRhwL6NDEbwiCRQMQLWI0GWJV1JqAwM +ho8f9x07NgyGTGCKpgD5rTiqc/bsBcvOj/rJcIhHMZ2iEwyXJ8i43wcbon14+uq7X/peKCp96o8G +Tp7wR0O0xDqaEnPslMzp589cXNs+H4H54aHIk4fy/efyJKFxrCYLeswGCnNK4LIUaQONF4VY8Hsc +JjlSUIU4EmVhCIdDBIXJrl1maCMKgRkISAzt2ACTbBAiQmEEZASZTytiEwqpIBMNDkVOHB+BoxLP +xxnGgfumVYNhA0dURYhRmBKFKFVNp4vzMAo+UYBC/f2ZT/43YWjZUT82MBACbhoKijTuwpDoH0UR +mE14qaTlipQY8sP+UQRBJMup5UrzAFGhIAuuqFpf8mKdflfowQiAExzh8X4G9GShQKA2AFLSrWXi +9WgYB5Qu0CqJiCQq0agQCaEhPwT+/vnDQwLlhk+GfIORk8dGB48HQ6NUv8wjbT55ECzCkBEN4pFA +xDfkHx7wQ4GIIyulhFPJxAxZK5bbouyODAMPFRzqLzGMQhIU4AZPBI8/NXz8U8NBHy2wGZ5JRIMs +R2iekY5bWU3JBHwYHOaxKMg1gg8Qy7GRgeN+3yAUHsV5ysOion84AhA+OgKQzxCIjcFuyM8PnAgO +HB+V+QQA5ODJIMAhSLs0YZpyhkb0kI8dPolEAiCyyKGTYd8wGgkC8uQCPpijWJ4iFJ4oxs12u8Zw +PAwMkhEv5muem2RYKRqJ4tGoA0xjoRlLVE6cCAwNhCNBRhc8V/EkijYFpp6JLS3NeclMMIz5RtEI +BHKoKvBqzDEzSSebsNbnuw/v3202p4eHw8NDwaFBP0sIMpBHqqzxAgpFbVnIeKbEAkSNRIN+noim +XLGcMc+fmjlzsDyz1i1WwR8TNRWIDQkImCemGANXogqqpcuaIlq6w5KmKmZpwgayxz8U4Qghny5W +6mOqGsuk6gxjYAiHwzwUJAdPho8dG+3fy8L75WLA1IVGEaB+66XOzPSMJspIGPf7EAxRgCpw7BzH +uyRlFovjup5R1QzPxwJ+IhpmAGYoXJBZlaMMNMqDlM0xKY62ZUZSKDLrao6qy5xgShKPozwAGQV3 +6/HFuZbAAlYkEYiDgzQeEQlYBYkMwANwCAUUJsRGAgE46I8GAgYvNFPWXNndmcxd22td3h1/9YWr +u5vTCUOnCAmOcCD3sagBAPbUHw2ePB4IApcdZIPDUSJM8hjtSoolyjovYSB4g7DM8jxNUYAfKZbF +BYl2TCUbCTODJ/3Hnxo8ccwH4AGS4yBwnYPk8WORY8dCJ09A/mECgD88CsMhJOllCJghIpQhuEgI +aH6SxlyB8QKjyMkTPv8IQgINE8Kifj+Ph1wZrqXY6Ya9OF2oVZxcWu6UraPV6t0L89trzWbRbOSd +uO1qso2h/MljQ6NDATQEGwzncoSKB9IKvNKJ1UqWqTOGxlumIXF0wuKrOXmpbbx4e+PFZ3YfXJ17 +5uZyuZAYHgoMD4bRCBCsrsYJFk86HOLycK+grXRj40UpY8DdnHhqMvHindUX76598tmj3/zojZ// +8qPPf/72xkI26dCywFKUh8AuErFEysi6RqtoTDZivWrCk9mMY4mMEA5A0WDYEoRGMd3tlteW5158 +9dVqswMjaDCAgAsYOAH4ilHUJkWl+rfmjp1gECRlmrVsJp+0sWgYDcPRECyyUrOQuXx4ZqzTtkxr +bW02nU6gCAlBhCi6LOsC5UYDXooCImDAV8ZyS8ksSIQ5i89r6M5c9vxWb6oWbyal7V7i2evLr9zf ++uC1c68/s3P38sZ8r5yyTQKC4SAG+QkKMSQ+zeIii+AqjZU9drygdgvaXNM8N2ff38m+c2fmS69v +f+XVU3/4xVd/87Mvv/3M9sF6r1PJ6ZyIRwgkTEIhmqEcnrSIMAxMdV4TGzGtaLJTJWN5LDHbTG3P +Ne9cWr98ZvrBtaU3n91/5cHly3unO8VS2rU1gUbDYaC+oADtG0IBnHxDOGDUk8d8I4PBqB+B/WGN +IrKm3CmlPJk3GKKa8srpZEJ3k0aSiDInjvtAwEJ+DIgtFQvbxGjdihxMqM+eqdzaqzw4an/0xplv +vH/lg5dXP3zY+d33bv3jr9/7s6/ff++lMzuLnazrAvsQ9AUh3zALjWb46GQcmUoGl4rRC3Pa1VPZ +w4300Xr6xl7twfn6q7d6b9zrfv65qb/58xf//tef+c7nDu7uJPIGGh71+30RhpBZQiQjiIyEOmZ0 +v0UfTfKPD1IfPZr/9NPdt+80Pv948uef3PzH33zm59+6/MtvH/23n77wP/77z/78G3ffvDd/abuS +izlEFEQr64h61pIaSW6pru5PGDMZZK6Id5LEUsta7XrrXefqdun9x5u//+23f/mrr3/xw6cf313f +2xhXBSLgG4UCGBwVBweDJ44NRH0jHhdJCdGcAnvsqMcFuhlxrmYuto29SePthxtvP95/8e7mV969 +8OMfvPfaC1drBWtuqjs7t7O8dVfVC1jQb9FwnEdaFnYwrjx3rnp/L39mXHjxQunn33vuZz948XPP +zH/hYe+3P3z0b3//5X/5/Qc//tKZf/7lo7/8xsVzC45NQ0igX5OQgkUyiglwIM4G57L4vc3Ydz+3 +/7PvP/z2585/5n77669M/fBLZ37/l4//8uOjH32088+/fuFvf3j1g/vF+/uZ3Zl01lFzHsiVcVNN +SRSbEKIdF14pMDdXvDdvTLxwrvD4fOaPPzz/6x+9/i//8J3f/fy9X3739n/87dv/3//7N3/41YeP +D8vfenvrFz945r3nNtKmHByBQZIFNpYjFTQUIkDKh3w6ETDx4dkseXkxfmk5vTehH81bjy62/uQr +9z56eeej1y+9+fzVjOPCERYwsIwRRZWeSmDbVfLOovLh7cZ3393/5N29n3z15j/8+PX/8e9//ruf +vfOjL535m/9y719++9mvf/ro1FQ6DRwkLTqaJxKEScENA1vMwue75M055eW92HdeW/rJ129+/4Oz +33hz7S++cOYf/uL5//jr9//1N2//+vs3f/u9y7/+42uvXpsuO/0kCERIyB/BwqgnaiVNXkhQL26p +716Mfe569pPXZn7zzXP/5+/f+LufvfBnX9j79XeO/vGnD/7uh7d/9OHmTz5a/+U39//L57aub6Xr +aTcSQJAwRUfwlbHCettdqUrXl/QvP9f90RdOf+u12W+8vvC7H7/4y+89/Sef3f3Bp9f/+999+D// ++w//8a9e/913r/0ff3jzex+d2R4HWPAPDw6FAzDgdothpzN8xwy3tdHL49TDLevpLeulC7mPHk9/ +/3Nb33xz4SffuPLvf//l3/7Zo9//6IV/+9sv/OU3b51ZLM70utlcG0WUtOVWbKkbI7dL2KVx6vN3 +67/42uFvvnPlu++tf+edtZ987fK//vbdX3zn2vfeW/+vH5/733/16q+/fuGbD4ufv5k6M8YDVpEo +zjcYPPnUEOobjTPBqRh0rs1eXzIfn8+/f3/qp9++/U9/9dr/9pPn/vDDh3/40bM/+/jwZ1/c/bN3 +pj57PXtpWh6LEQkJ65cTZXWGMDwj163UVzqJqTQ9l0Qu9qjP3Wv8yXtbP/zimT/7ws7PP7n4+588 ++7c/ffyLb1/+xRc3//YHl/75l8/87gdXvvVK59MXvUdnCrWEBocZgcuwtKPxSiNt1BxizMPO9pR7 +a8qjHeOti2kwG3/9p7d/+cnFn3398P/6p6/+3//6x995a/2Tz5x7fGuNw2gswsZEKcETaT7ScdCl +HH40Lr14UPjmq6vf/8z+jz9/7t9//en/+R8//rsfPfejD09/+HDx1Gw2odIcRhCIoMtJU046kudy +TE6C57P84VTy7lb2+dOxH7yz+r9+997vf/Tul15Y/uLDzvfeWvjJl899/c2NB2dLB3P5RrZggJgS +UiRmAC/GEmrGTJZtJyvi4y5xMG6dm7SuzlufuVb94Qd7v/rk3vc/d/Y7b21+4dnl1y+0Xt0v3VlL +rLWVeoo3RToSpkUm6+gViRQKlppTqaKCz+eFB6fy33h5/i8+PPVXn1z+zffv/v7Pn/+nX779069d +/NmXdv/5p8/+2y9e/NWXN7/zOPtoPzFXEBg4FA4gllrIeG2dsywarxtES43OO8Eb09wrh+k3Lxe/ ++nj+33/37j//9s3f/fDp//bLl/7tD5/7yTevf/31lfefnV0ai1mKzlIWGE4l0zA4LiGS6w2nF0Pm +4tB+g7q/Hn/9UvvR2dq9jfQHtzq/+ta1n3x8/Vuvrn7pmYm3LnUuTsfm8yCnIiLBU6gKlMzwSYiB +aREOeWRwzMY3Gtb+ZGZ3LHFlMfv8QenNK2Nv35h588bM2Y5+rq2e6ZjzBTvGiwrJCgQHNL/ExQQm +rolpXXDL8UTRlAsqu1J2zk2kDsetNy/Vvvnq7F998+Cffv7oL790+NXnJr/6oP3ytvVwQX28mV4r +ihYeYqKoLCRNo03iDrCBRITkImGXhGoatlbkzrapZ9aNl/cTX3zQ+f1fPPP//PvH//irl37zvQcf +v3xwcb44kXNVXo1EVTTKYqEw3d/XhWdVtmYxE0lhpaIdziYvL6Wf2S1+5dHy1944/fbdqdvbpamS +ztMwFPD7R8JQmE947Wp5Oe60FUbXCLLhGWcXuld3Z3pJ/GhCfeFc48uvXbp9euzKcu7WZmGn53Qz +alJjgcFhCKtfrjBqEWQCGHngoJNe1VVsCUEtiszrcsEUKja3XLMPZ3LXVuuXlop7k+npfGwqFQPL +mFR5jsDgCBEK0YEARxMJElEifgj2BxkoYlH0eDq50ckdTrt3Vt2Pnul9/7OnPn5h/ocfXfjhB4ff +fWPtk5cWP35m5v2rtcuzusdHgGkXGbVf+hh3ScwKAUMEUSU71o47KSbUtaOnW/KFSePGgvXJ62v/ ++tfv/9NvP/1fv3H9u++de/Xa1NXNwmLLAd5YkZKW1aRIh6ZMNMrJjN5Kl9MSU9DIms0VZKqq85Np +qxdXZxPMhen43e2x81PZjsWUVTEpSBrJUTAT9LMjQ9TACaAAMZWP8QjBQpAEIylVLQ== + + + ek7F82qOlZWZFE/lZK5iCS4VBVowzon1bEtkHOBKUKDkYTGdahOYEQ4AsU2gYVKh5KKbWxxfmW/0 +6qa0lFNvLOW2yuKl2cxBL7lekDeKykJGnUsbFZWDgCwYgmBIYek8EgU2MAycpm8ggAf7E5uR+Lol +5kV4MsGs5PnL09Zb18Y/fWv2uf32QbeYZBgBpkwl46VmGr0jhvRUMc4SMoOBCVF1QVUY0RCUejZb +ihl5W8jbvCfTpsTpksLQIoqLwKoPDyPRqCJKKYpxRgNUBBIF2jZEK+1m8okiBUExjq55VikOOM2U +SV4iOWAooiEKOCkoxIz6iJERAkFj8dRCMrvQ30Imp1lKpxHOED0iCtI0pbPmeGVmujXfKfViqq3S +vM67Vt/CECcHfP4AFUVjNFsRxbImlxhCHx4Y9Q36ga/XBceWPUc2s6ZWTxkLDe9wIbvdsc7NpI8W +6qu15ERK6yassmXCwejJkyOhYP9s+/AIeuJkEPhNksqkkrPl/EI+0ZIp2uGxisnkJSwnwqdayRev +bL90++DC2vRipZiURZHACYRgWAdBLBgx/UFBszrV9plKbT8Tm5BpY3Fi4crRTRrhwXpxmOzKyZxb +LCcraTMtkwo8SiIh2Qds6YkIABUUsYNBPRhQENgWuURkFMZDINfjvmGkf/srSEXCPBpVadxmCIeA ++ZAvjIaoSICNhDiu/8TKoImY3D/MMhYKScD2Bv00AesMbppaSZFqIHCoKKtQUjNTQv1hT3RTVtHi +LSZC07BEoYq/X2k8hMAWRSRGR6hP/S9Dxz41BPwmAcuWZDtKjIJpMoKrpOAKSv8sLhY1KdSkaYfT +bS4RHMZG+wVhWvn6ruONG+ZYq3vKjpVRTCApW9Or2cJKIjtH0SaOiZrojrVnfAFkYDDs87OcVNOd +Cc0c5/qVtZIin+72TklGxRdSUKJ/KAMj4mFIw2CDxrTgKDpwMhAcZQnUFfgSRWUATUVhE4I0gUsB +WTLq50cD/VZHGO5petmya5qaj3k1vr/lo/+gDUUt8F+cUBSlkqyWDLupW1VRiElyDsFj4agehQ0o +YqC4h6JOKCSiiErTlqJkRDGhKMVYbMxx64aWp1FeoEUdLKyQGBkJhwIYAuuy3LISKyiVGvVTAwOR +EyfDABgonpG1Vv9A4ijp85EY5jCEi0doHMI1VsunAS/pMCJjuM0+qZUHI/2C5+C9wyBSEF2SCpn8 +CiuUQmErHJajsOa4XS8+4RumQgEwvY4o5RS9HkXcYEiNRAyBL/N8MeAXRoYZkszlihu61ZWUBoLH +h0cAcliZ8RQhBjwawxfs5Ey8sFjsd6SdfNJtXKJIu9Ha4vrVy3XT6sYS86nsqptaGgmoJwaJk4NY +OKyPjtBPfWp4aBCRlGa8sJEqrOlWD6D35HEICop+H//UU6HBQRQnk6ox7iVWdbMXgszRgDI41H8s +xVIOAPNA/y7ZyOBJKDhK4aihSQWZi/mGoKAPJqIigSg4WO6Q2D+yFJIjqBuO2k/90YgZnyW4NCfE +11ePWhPbKB2jxRxOJwUlL2tl02q1JvZCiBSOSjSXMmItjElFUC+KxUWtXWvuHV5/I1dbHhihghHA +E7NOalPQegSdjUS1QIjDcIsXiwBvMOogeFJUx3RnCjCirFQEIRsMq1DUjKImxeZVq+MmJyStihEx +2+nkisuCmFO1Cs3nBL2VqpyKFdad1JzudHgx25m6IMjVCKxKWo7ms6rdYeUKSmdxJms43WZ3f3nr +BkbFhnxkMCzTXL6/wY9Kklz/CI+ll9udbcVoyEaNkesoVSCYqiD3gmFAO2440t8T6A9S0agkSXlR +6ZJUIRTgw0FelkrckxMNolpPFpZTxXWKr1F8NYrFINhk+BxJp6JRjecy4YgeCCgYGaeFAkbnR4La +wCBFUl4Y4kZG+oVkYdTlhArN5lmugBFJislxQkkzO6N+MRJ1YCyFU3kYS1BsASOTg0P40CCuqnVO +yAVCbAiSSD5P8EWCLShmW5D72zIRzEbJtC+oBiImTGbs9IpsT1nJRTO2cHKAHBlhGTYnSHkoasAI +iP1YGPIAOWN4AoKM4WGKoNOW07Ps8Shs93uPhjRaqPJyW9cqcEQCsDx2LDQyhAdH6XBIRFAv1D// +a0AQQJQ1OoQBWiNxy7DHNGdCtsZFcxyncydPYIzUYMRyLNE7c+5hpb0CYTpKxxHSs2LjVnyqXzFM +b7D9zTYTTmIshMgjIS4AGTRfrbTPV3qXsvVdUshGEI2TKqo9pTozOFuGyTSYf8PuxlKzmjMG6CUE +aZLW9tLbZmyZk1s4lYJRD1yAoDRgzIQiCieVACpShdV8ZStTXPOSs4nk9MbuHV6rUFIp29ybWLk1 +v31veu1WrrFTHTurKLVUfGxp+1oYNVAqBqClurPJ4la1e1junE8WV1HSY8WcpNVZoUIwWYBP3mgL +am1y8szG3kNRrQyM4CHYdFOL+frZVOEMxTUjaBJCXJiIPdkLJ0Wi0nC/C7PSr/2LuQSViSCe6fSc +xDRG2zBhg0Vk5LZk9TssG7EpgLFwWB3r7hpWG4x3xM8CSiS5EsXXRb3HiEUY0SKQoGtl1WgCKo5E +AQE6sj7mJhfjmeVEenHUL4lyQ1K7vNQCnxVG3NGwMTDCQbDrxOdIJtuvb4+7jFgSjY6gdxmxEoRU +AGzVHkdA1uhXQqtiTM6IzXJKU3UmGaUVhl1JH/NSC74AgKUCoEWQBUFq6fY4GFEUdqOwo5pjIBED +BA6P0FBEldR6PLNE87V+zZYRClxVMGwCZjtxzHfsmP/4ABGC45La1u0eK5T9PjYYEAShwIIQRhzw +1S+eicUUrc1JrXxpK1de1Z02zsRYqWDGewjtcVJeUBsAhIJaj6WmKu0t1W4EIrKg1zAqjeAJksuG +sGSUrMBE/j/38IeiRhTzJHPMiM1Uu0eLpx63Z69FiQSC2Bmvu7h4GMYcf8QORTyMLCrmZKqyk6rv +Sma931gtM8XIJcmo80qFV6qi0YplF93UFCWkzVj71NGj5YM71d5usrSuujMAk2Agjfra8vYNMGOC +UsrXdoqtw/rUpUJ7T7LHYSrrJCZnV2/mKuvBkB5LzC5u3JxYuNieurC291DzpgCJAfzwcpkRMjBu +4nRqeunO5MLT1d6NWGEbw1Mo4UpaXjBqAyOsPyAB7lL1Gd2Zd1MrqcIKQmiSXvayK2Z8EfBDdfxw +fOFaqrimO5NAaMlGK4JaglIU9bbu9kBeEI3JQKR/2M2yO9NzRxSdCIbBKtu6NZaugBmY5I0Jgq0E +QnqhuOZ6vZGAFMVS4YiLEhnDW3Szm6IxFYbjydTk/tl74X5lP3rIJwDi4gCFljaXD17mhOrFS899 +6Ws/yJcWB0d4f9gQ9E5l5uLE5tP16Su6Nx2E9FR+AYSGb1QaGCQQMhnBAK/WsuXTdnzJP6pAYVUQ +CyCmRnwY4K6BEd4XUlkAodhStn7mqeORoSEERvRw1ApDNsAkjMaDYRtC4ro7E8+tggQ9GhDCfX0S +x8i0l1lD8SQOHBabA2Qim71K6/zE6m1GzjrxsXR5uVhfr7Q3E7lZ1aqDyRT1SqW7B1at3zZXqlix ++UL9bKF51vRmwDD9EQWhPEBTIMNSfJHXQGRNkVxdsydbE+fr46eQ/t7jnuZ0JaPDiDXZnjAS07JR +nVs4t7l/T3fbaL+qfBoo4dr4md76XSM5b3utmZmdN979Sq23HsZtWmrkanuNicvduav5+hpGOiN+ +hmTTBJOGSZsQMmHc5bVGd+7awubDUmuf15ogddbGzrJyFaXTkjlR6py1U4uS3gV85SQnB0fgYIR0 +U614rmt4nQiewuiyovcS2cX1U7c2T98ZHKH8QZHja+3uldmNZ630KUqoM2z2wfOfL5RXwhETsOLM +yvUHL3344NWPFvceKO4kUAua3nzzrY9Nd2zIx0fRlGrPpcoH7ZkbqzuPyq0zNJvqTu5mCzMjATqM +WLTU8nK7c+vPdaYvjM8cif1Ceblseb2/iBFT0tuKM8lrYxTfyFdOT8xdgNEYkMqAoiWjKxrN/qZW +Kg8029r2tav33+TkIkoknfi8kwAGuEeLNZIpADXCCtXq2Bk3uTAwxAWCuu6Ou5m5VGmt2NoBvOQf +AS59anzmEAjggSES5HrdWxGNrmz1CK6CUaXBYS4R61y//qJhVD71R8PDQxhGJqzYUmv62u7F1wq1 +rUBQuXLjdSc2HoroIaDupU4UCCckBsZiJ1ZqY1d3D99e3XtO0yunt680u+tAcWlm3YlPlpsb9e7p +xsRBorwkyPlCebHU3sXpNKeWeL2KsyWQWHmtbcSmc7Vtis8CtcYrjUx5vzJ+rTl3Ld89w6llz2mv +7zwdy00CGBjeZKq0Mbd64/zFF87feLM7e+TGxse62+3xHc1spgrLjcnzqdJWsb41v3p95+i5ZLHX +6mzMzF/V3QlaKBFCHqPjQIkxQt2MzXNyTdXL3dk90ahGMNdwJ0FSkKwJ3ug2py7Nbt4HmDS9KS+/ +Ord5ffng2VznHPBJQdiBYEuzG/nmehBmFbtMiRVO6aRLG4nCqmx1wCiGRkiCSsp6Q9SLnNHkjRkt +tuCklmLpOQTvd7PKFedVq8pJKSfVq02fTZaXUsWlbHkjU1hGcAfQo5Ocd5Jglbt2ehYIadVb1J3p +fO2UGesFIanS3GhNHWrupOlNClpNNpsUV4gnZwCqWSFHMem55QvXnnlv+8LjidXr5c5Z0+2ybOL0 +6Zt3H34QjJgIEXMTk62po+bUUX3ybG3yEIi0q9denJs7i6I2xSSqE2enVu/2Fm7Wxi915u6yUmvY +J9JsLgKbdmLaTs0biRlObwDxkyyuJ/PbA4NsFPbimUWaKw8OI0Mj+MAQBSNJMM/ACOhaOxgUj58I +AfnKiRWqj7o8yRQDYQNQ2ebus4nUNNCrCO4BJIDkSFBZkKaB4rITs9nKOohlnk8vTO9kihMobqpa +NQ8od/Pu6s79WnffSnRFJTfW225Nnw8AUUfait3Mlk81e1dzjb1MdTueX5TVaq60qFlNw+ulKtvx +yobsjtNiKVdYn1m7Z6UmUMqttE9niivj0/sHh/fnNq47yQlFKc1OH/Rm9nkpn8nPnb34eO/opaVT +92c375Y6pzUjfXT+zpnzz8A4IGFAX2XZbAMMJIvbmjdPceV0eurq0697mR5CeKn8ihGft9Kr5fHz +py+/Nrdxx4vN7Ow/mFy5zGolN7+keAuM2jXiS8nibmXsUNCakpy5eusVwAlhxEaIBMGVSaHKKjWa +y+WL69XG9vrm4eTCOZKvcUoLEHIY9WAyprudiaWrfdqk3WRuJltfTxQWS60dL7sE4xmUTGWqG/H8 +UgR1OKWUKK3lGge55rnm1M1840Cze7xYuHjt8d7hM4JaAeKKZPLAIJRbp+PZJcsbAwqW4VKzixfm +Vy7E0z3dawO0u/GJfHl+7+wzqxvXgV9Q9WZv9nBu646TW+LNMd4YA/L13OGDfH4iAg== + + + SZJSLLW28rU1LzEBwo1Vx/yQM+yTJLkMo1Zn5vzWxVemTj1INXYz9e1UZYtTesM+BejY8YkDji9E +o8C8m2HIIoDmUcdYvhqJOAMDGBTRBbEGSGlgiAmGLE5ocWLbdJec5BLwZaNBAQQUgsWBa6CZTL+A +fFgCM4AzGcXseKm5fnTIfeUpCGlRrrjJSRCMklYD8pgXS4nciux0B0DyxUwArWrnoNo5L9tjOJv2 +QwrHppvtXUUrs1wSEN3k6g0w/4tb9xe2nm3MXBTMOkI47ckzJAMkjdMPeaWq6I10djZTWOSVIkHa +jlOLJar58lQ8N23EeiyQYUo6nZ003SZIIixfeNK3woqSpuJ07OSC16eRWTc9BmO6qhWOrr66ef6x +nVn0Mgv9Q9NWXZYLCwvn5pYvAqYFOr/QPIoXtrOtI8AhJNCiISkZ6+yfu5evLpwYRDAqA+glXdtx +0gsgtOOJiUZt+d23Pnr00vvBqAOhMYqrmfGliZW725fe6Szd5aXq6dPXPvP5bxWry8CjMUqPloGE +nqj1Li0evARWLYqYNrBFsXGSBXhLYnQap9K8WE08YaeN3WuJzOT0zBnL6XJyBXiNCBrzQ1oI+E2p +WqrtqkZDNZua26XFQmf8YGrhciy9SND9xkm5wkIsMU6BVfPmkkC7Vre93KqotcASA5uQyM7jZOqJ +6RMBGUrWTLx4OpbfoLg8TsZqnbW5zYuCXh4ELwgrFF/KVHbAW2KJKU2r9euDEVoiNYViCZ9PHBhi +QU4c9WsolkxnN0vVc4JUyxXmM7llOGqFgjKQ+sOjEkCaqLTd5DKKpSSjKWgVEHcgBCguCyQ6K9VE +YwyhshDqYpQnKoVQROHlQrK45KXn7dhsuXm+NHZEq9UQrLqZaT3eC0Y1nM4Am8YCN1fe0Iwx8DJW +LCKoUW5sljun4vl51emyWgVh4hibiWcX0qU1QA7AoYtqVVJqyfRUtjhnJ8b9YYlhY068jdE6z3uK +XtXtbq4KrOU0cEYkl4OilqR1eLUejPCilonlZ6tju5NLNzqzlwOQCPW34ufbk6cJPgusU78wOF8p +t7Zq3c1qZ5vlsgyTlTXgv9whHwmiwEvNLG/eBhrD8ibgfnFCcniUBj6aZOI+Pwl4w3BbufxkrTa/ +fepKKjMOwY5mTRvOvGb1BK0BLAPgN8ud6E2fnV+5BONuBI3bqfVc+6KX39Kccd2bIrh+wf+l1avF +ygIwyxDiEUw+Xzm1sPH02NS5ch2kzplKdeGtt77Y7R1E8IybW03Xd1PVrXxrF0w4isemxre/9sc/ +ufXsu0CsAu8p6uNeei1f30sWVgxnTNNrW5vX9w8fU3weECnK5FiprtsTvNLG6RKCJWOxzvjMHsll +YCIbxTOBsOkPKJyQy1eWppaOUMJm2YwkV2xvojd7YXLmLMnkRgPy8AijKtWZ2Qs0kz15khge5jih +Vh87n85v8HILRjOO3XntjQ/2D26dOBEBviAYTeJUOZ5YTCYXdL3N0nEwfIrPwJgNI4Zq1ik2zyot +lCkCmZ3IbnjJFTc1B+YcKE8rPi70C/JXMDqDUhlarCSyS73Fa5o7NjxKgevh5Col5BOFBTAKkG1R +wuuXeiutcnIB0JTpTcQKK4XWQWfuxubZR9XxfYSMcVK2D6egGI1awFlQbBEls0B2AojChGk7FeCz +ApAKVCiYkGBEBx+hu9OiMU7yeYZPrW1dkbQSxaZAnAJTABDOsOlsfmlu81ak32IvISlVhs0B8RbP +TtnJXgQxnxR2LsOYFQjyrJhzvGajtWw6jaFhZmCY9Yc0lEobdhfHTZrSVaOULs1OzJ3tzh8mCrMQ +rAGVoujtJ9UhaBAXQCp3py/Obz6U7Nkg5A2PCK475iQmwogOIAq8fCBk4FRRc2aMxDyImiist8ZP +A4kI9+8Gx6KIAxg4m18p1/cyhVPhqBdB4m56CYiuJ3cV9AisQ+F+FbjtvXvN3g5BOarRzFU2amN7 +Tmo2iseBVgR6rNnazuXno4gh6VUjPgsicXz+aqKwEYy4o6OibTVb46dwKk5SOUFtKtYEzdfc+HSt +veclplDUmp896LRWaMqBIjJCuLrb7c5fmFy6hhFpKGIGQyqBJXA07vdLEKT7g+A1/Y5XmlFJxJsk +4fl8vKx3ErntMGT4fczIEB4JSSzp0HyZ4koomQEU7STGFb2VLm7x/UY2Y9WxQ2DHVHs8CCkQpDBs +CqyIZnc4pSEbvRLQDJMX6r2zvFYb9lEsn0fJOEzGOaOO0skwyLNsNp6eyVTWKS4lqcVya8dOzRjx +CTPZixWmQSID0OKVMnAxgZDCcGVgUaX+SY0qjCeB4AFoL1eXgTmN4B7BFSA4BgShpAKj2gJDI7k8 +uMLOzFEYNlkuXWufypY3gcxQjU4sOZsprwKHzos5SS4BYocRV1AbkgWYMB3FLIyyMdK2rIZp1/1B +cjRAjPjpwSEqgiSA5zITsxSdZAljsrMyOX06guog9CixiHN5TipLSoPli4GgIMnZWGpct+tOrC2b +rQiWGQ0AV+7ki2uGNzYaZGBERVEvENQougCmC+03XhQZJrlx6gaCOSdPwsGgHEVdRW92py53pq7K +5syJQcYXkMFy+PzckxI0EoLaLJNWlbqXmJX0piBm46kuxTgIroEwQcm0pDad2KRmdYGdjETVdHY6 +W14FqynobVpu+II6jMQFoQZeBsMWz2ZqY6fKY6dRIg20EEakgK0LB6XFuYN2c5FlHFFOe4lOrrLQ +nj4ACm00oAwMkr5RkSYyLJU5cRwbGeFpvgi4tNza1cw2BGnDwwyCerHUnGZ2jp+IDA70KwSCC1bV +mmZNZCsHZmLDiC/QfApGVYaP02wShCSrVEkOsEc2hCTAeMGUhsNCLDUdz6x4iWUgb0AGjOCxYNQG +jhUnnCiig+xWbO5Vxs5q9qQgNwx3nJUKnJguVZar7R2YsKO4FSVs4BbX9+4fXH55bOEKcOvhiApM +KOC0KB4bDUjhaAxwl+lMbJy63e5tm16nM3VA0NkgpAPAAB3CCBXNBpe9U5+6ipFplokVSzOW0yBo +IN4Aqk2aLylaVzM6JJ0cHCZIkKzFighcntECWX40LMGoncsvgVQyMBAeGAj6/DQw4BE0AVOZCB4H +y0pglme3ZKUw4md5pSmbE8As2Mn5KOaO+kUArUplPp7uQFEBJM0AZKBE1o4BUTcFlnXEzw/7aNNq +UHRqcIj2B1UYz7JiO5XdKFVPp3LLIH1gmFuurhh2o18JPCQFwxrO5EWtS3AlnMkGAkynvZUvzENR +HRiuCOwADIz4OJbL2U7H1y/ACKP9WkApHAyZjIdheyTQb/TjxSe8+OT/z957d7eRbXtiH8CPtyUm +ZKCQYxUqBwAECIKZYBApSlRqioJIiS0GNUWqu+/1u/fNC37vrQmeZXvWzHi8vPyPvfyXv4o/kr33 +PgUGFLoF6HaTALvQaok8qLT32eG3wzkV4fTHLz5/+Ol/qa+8A0Zl8wsgpR5PJpMyLKsJMh8Oq+ns +nCA9qkzvCuIirokLC4VC9fmr05mZzXzOFOS5SHwqX1ytTH8rFFfTqZlJ3D8kP9N4sbJ+ANY4EBA9 +nvzYWDoRr5WmXprl59GoGQzwoMv5wmwiVvL7BFBtSVvJIzIpg1vP5GYB+UdjpVisLIGmm9uyiYg0 +I2ykAH3FdDBBidQUwLZ0up7nV9QSBLDfKdbTSEL1h7KJNMQsS0VxFt8cJ69DhFia/haCwfWdH/PS +WiAs8cVZMGWLa+9fv/tz68Pf1RZ2s+LiytaH7b2fzJlXk4FCNjdfrR+IyoZmPRX1NUlbLlceb+6c +R+Mlf0AwKjszK98vrH+U9O1ccTWebkQTpSy+p6kRj8vJhCUqm5Xpve0Xf1zbOoPQAFTb4yvkCksQ +fOWEhebj0/Vn/z24J1nfAuMWS9QCQTkaNyMxLRSWramXK9sXy9vfrz79sbZ0HMvMQ2gDvnJj+8yc +egYmQtC28uKarD+hd5qA4lsz9ccXP/1b+NkTkFK5hSy/DHFQubY3NXMoqlsAVxLJaVXbLgirheKq +Zj2HAyZ9+dFRfGnXUvMgX5yNgrJErXi8UhSX07lGGIQkIEajyrOXJ42F5+GoohiPGsvflae/VbQn +2XzT4yuOjsYmJlNFYW58PJ7JVquNV+tPP//4z//3y/f/g1F5AnYjHhFW1w+sCoB58F+42QhQF+G0 +AiCZ5JTHm8UNeXC/cd3jLY6OJb1+Ab7NZKbEYi2blkRxShAb4PgCQdzT+8GD8DffBHzeQiaF78MK +hQv+QCaVmQoEtXCoBMGIKEPkODU5kc2mS9mM5fMmJscSnolcNg8+FNerJhIVUd4yy7t5cSMSr4Q5 +My8sp3INLlEBk1WUH1XrremFQ6W8HYioY+NpjjMTKYiX6+kC7uRTrr8sqqvpXCUcSkWCyWRSEeUF +iCuXsEbzD49e/jGaboDfTKUVTalrGlhywGaLEHSvb58f/fSfmi/Oc9o6gAdZbRal2VhcK4jNlUff +f/rpv3384X9b3/k3uFFYRDatR5K+mcrOgOwJ8mZBejy3fFqa2o0npyJhXlXBWG3w4jz8iSVrk95i +IKzy6sbSxvdW9WVBnF9aPyjXn3OJMli2eKquGE8byydTs/vAKEWZ3Xv/9xvPPyfyM1mpKZhPs9I6 +r6xtPvu0sLKfydVKpY2lRx+K6pZqvixqT3PFZVlbnV/c23pymsWVfTO1xl59vjU18xK4kcg0AAlP +enKZ9IwirQSDOYjXYmAVUzNm5UUuvywrm3yxGQjpleoLUWr6/cVorJzOL6rll9X5d7PLHzL5GbCl +8GDr26cCIE/c+XDRFzSBonBETSYr+Vx1ciIuFmenqpuqvlypPYfgF19I4cvIxYauNgFMRiI6mG5B +XM3l52NxCAEs8PuTk2lFXc0XliYnC6BcAD8yeXzvWDxZ9fuzXg9nmsvV6WeBkPo3uNdfNhgEi1eI +hI0QSJqPn5hMzM4/f/L8DNz9g4cJOACwVjrVSCWqoUARLv7wYTgYEMMhPZmpjY/HqGwqg/NN5ZYz +fBMgeppvivpTiPt8oWKhuFyqPFvbONvY+bM2/TIQNbxBNZWZD0Vwc9d0trK48n7/439c2/mzoK77 +/Ml0XMiktWwOZHJaNtaN2gupBJ5xMy8sZHNmJi2lkmI2XxHVFVFt1hrfQsCo1p4Xy08lc1s1N9JZ +sJkaBMvV2Rd7+395/e6f9ForHLEy6al8YSYa1wEDl6ZeqcaOrD+rNA6KynaYg/hXVGV8n5fXl+Ci +ckFYiURK6UzDqD43Krjnc4GfXljZzeSnIRYGrSnKG4vr3zdWP4rGE5h3SWrMLb+RjdUgp4jG9vqz +H169+ycwXytbZ7y4BDHO0gLEsLvBiFEoPppvftx79/ffff9vn7X+MjX7OsqpU+X1vbd/mlvYDXMy +vpYuKMWTNUXbKOTmMsmy35eyrLW1zZOCuJLOgbkAvhm5wkoyPQ9UwJwCaFlcPFhePw== + + + FrUtiO+SmYYP30DB5/Ozy6sHiTRwch7krag/SWTRUAPIx93yJ1P5bJnPl3O50szsK8XcSqRrYAPz +BfCAyth4MhTWuajpBeOZqBSLzUxuMUG7ESpKMxaven0gz3ApHaQoxFlw03SunivUKtWd8tQLYOnI +NyGfXwbOT0wWvD45FC2FYxA1zEOgZJib4FXDQTUer0bCJvztxdd5ZNELxEqK9ojjLG9Y+2Y06vGk +QUhyhQaY8frcwbuT//ju43958vpf9MpLf1DM5OsSQCZxkVc2C9oT0XheX/x+bfsv+L6hqKTqC4qx +Upp+mRYfTUYqE17ZVLeay4fV+otoXElnrUxhVtK2NsHLzL4ORgreQAL8pqQDIMdXFIFIF4uzi2sH +q88uBPNxIjcbiZWBTMBLsaRumitm5bE5/Rp4Dj4xEIRZ47M5NDjp3Hw4omRyjVKtVa6/56Un6ey0 +x5sYHQtyMZUvrvn8uNttNjcLU4zvKzHXdb2ZTE9xUR2EHGYnU5jn5UeVmf3Z5ZOi+gxNTYgHa7/X ++guIWV6cjWemQ7FqJF7N5OdqDYD3NYh8G7iD3/ermweLzbeCuhqKlwBLGMaj2cZLRV32eDMA1QC5 +xZONTGEBANLoWGpiMqNrzaWVNxFOxj0NIiovNrd2fth+/mcAPB4vn8nU3r7/CxhAMKep7Fw2v2yU +n5tTz2XMUJW83pxmblQbL6Kp0uhkJhA24uk5QIC8sJpKmLmUqUqzz16dqdZWIGKOTuQTmdlwrMol +6lZ1F0HRREJXludmW7Q9jvDwYWxsLMHFKqnMDBezJiYyoFlm5cnM4rvG0occv5BM1UHYwMWDmc3k +VvwBLZedUyuvphYPJGML+4jCqs/LgyAVMvPT1aceTwLL1g9iqcRMKlWLQNAXVQGJgeMIYnOLATY/ +z9frc7srG+9XNg9XHx+X6s/A+6fS9SJbic/PzC0fPt39x/Wnf5pb+x4QC+AE3NBDqMZSpqhuGlMA +7F+p1sHi8qfV9TOj9CQYEeAAQYbgsZLA0KwRS5Zlbe3Vm3989/E/gU/x4rsahYIwnYJYVVxRKi8S +uYWZxePlzc9ZfgVC9WZzt1LdCsfMIIS9YQNi82x2cWH5ZK55ls4tAhKIcFKBXwLDhTFaWI1ETQC9 +1ZndJ7t/4WLVRLxS4BcA6qdycxBDAX7I5OYKPG4A6PVnQLkg3FjdPN49/Kd0YWXck/f6C5nclGE+ +Ahmgfox1ENrd9//uResfc/hunQwgybnF3bnFbwH6lqZeKNbL0sx7QJup7AIo7PhEEt+fIjc9nuzE +RDoSLcVSDdl4UW0cs0YjrzcdiRQFoQ6IJRqTYwkLAHwhv1woNEEFsFMlahYgHI5ZsXgJ9AskxBfU +M5lKubrJi7MArvh8Y2rqxfTsW3Dx0ViFi8jJmCoW65JUi8dFvjANEl6rP5+efcNL6/H07OhYxudN +p+JqOmmBAYnGzGRqWlY2FP1xLF4B//jgAVfI1+cXXmUypfGJFPg4X9DISo/LC58WNr9X9bVQIFst +ra6sv4NoceQPkfHJvCegxjNLgvbSLO0G/YD9IpI4//TpxejD2B++CU5M5FPZRb3ynIsaoMXxpJXO +1iR1WdWWIAIVxGoCX40hxeOmaT6uznwraavp7JSkrljVrSxfB9qBk/EEqjMvryRzVUFqatZOUX1S +1J4B2gTkAPIAWiZqG+bUt2CCAC2bU095EV9WW6k/LyhrnpDi8QvJVNUsPy5Ky5Wpl/NrZ1kRfPES +l6r5QmCBzVRhLpGd8fjBKa8VlSeAChLJGWAOhF0ApUC2QWIBXfh82XBUDXOGrGzzxUeCtJ7IzPkD +SjpT5+IVT0BOZBfA0Uv6DkRwIGP4lhlPHEQol58Gw5vMVDPCWk5cL2rbVn3XGyyO4jsQBQhqogmI +9Gu8tAaizhcXF5vvqzOvi0ozmTAhHAMAD3GZP6RPePlQWAPzKCpPIN6fmEj6vBlfgA9FjGyhKevP +PT45GFajcSuJ+YRpvy8dDhUgLAKUWCiuQEAE4BZMSjQ+BREHhA+ASxPpWUndnl36CPwH7EGv8Srs +PD6emd6OReVgoAjmMR7TE/TH54ll4vxm88X/+l//T7E47fMLPr8YCJsFEUSoGuVwG4pAIK0Zazw/ +6/cL8LReLwCzIoCoTAZfiu33ZSDES6XncsJqrrgeS85PTmZw/zRfRihUc/n6Nw+jHq+gWc8ka6cy +sydqTyc80h++iQJmy+cwQ+L381ZpS9GfgtUNhjDsAm3KZCu8MGeVt7MQ0qbAdaps54RE3BClZc3Y +Kk09BWsjiPOCPBNNqD58fV4+k2ng62PExUx+ChBXAV/Ru1TUtmLxGu7DU2zq5WebL//05PU/mLVd +mPq80IBJ5EDk4mY4Wo4k6tnCim49LdV2JKVpmFuy/jgYNRLZWQ5MMd80qi3JegE+C5BJJjef47Gp +D3sgAwqENhFuSsLWr5mx0Yh3MlHgATlLmexSND7j8cETavHkNAhkOFaDUwrSZoZfy4uP/BH9wXjy +4UTCFyjkcjOxqJqMq6CbRe2xYu3k5UfRdN0bFIIRJQ5QuTAH/gsEWDWeVmYOytXdnZd/rtReAt4r +5mughmD68C2r4Fyyi1bl1aPtHwX5SShsTU5mQyEpEBQnqS05xzfT+SXF2FEM+FYeH08GAkIiVY6n +Kt5AMRIvQ6gLAaaoPDbLLyEUHZvEPeTjiVoqMy2pECzvePCVpsVCuj499SSbtmC6A7487t7sL3gm +M57JfDgoaOJMo7q1vPjM58WNsPD9GskqhMzArokJsE6BSEQqVV/CbE6MJ1PJKlgGCGBT6elw2Bgd +jT58EEgnzVx+MRjWfT4xAHAiIAUgeMR3uukgiuPj2Vy2sbj8FgxRIFiEX8fGC1x0Kp2Zh7kYH8/V +qpv//O//j0rl8YMHsYcPC4l0nYtqwVABd6FJ4GqIZKIEUu0PQMxoplLlZKqU56clZZEvzqczVQ1f +WPkcIBmmXHAHDyOWMMOcGAoX43E9mcZegjCnJ1NlWV2vzu41llrVuVe8vJTMAP+nAiHR5+chHE6n +ZxKpuUwB4PQ6iEciPYXvLAtjFrGxdGrW3htT7xRrL1OAE6vxuJXKVMGJww+lyhvV3BXETfgDsXwg +LI2PxbmQJAoAjyVR2lS1l5ncKtg31dxR9OchrlTI10CnuFiZi9fSBRC2RiKzoJvPdGMnBNKY0J8+ +/S7HNwB+ZPj1VAHfXK+a64XifCQKUV5aKC6apZ0ovv0chGHaH4Q4KAl+LZHU/YFcMmWCs0ukgJwZ +kOHxSd7jlRLJhqY/Bb0DlOX3i7H4FLAlkW7EEuDg+AkPn8zMVxv7peqLVLpyev6vr1p/m8wuxBL1 +ZG4+GC1N+jG2TaRqfrR7RdC4TL4JSCAaVj2T2QcPudHRVD43B7YIRAhb1FOzurKlKRvpdH0Sd+pL ++vCNe/z4eGRyPAFWJZqEx2uAbckVFgNBbXQ0sbLyFvQU3CWEeOMT+aBfTCcsVV6AK/zhm8g3D6KR +iAFWcXKiMDaamoQDgkY+tySJK+C1x8bjHk8G0BSgMsC60Wg5EFDDYaVa2Vhb249GSxMTxWzhEQZ6 +nBUI6+FY2c/po57MOHAjUMznFszyE0HC4Aggkx/fBZNNpQxwXtXGe7PyJpWdz2Rnk+lpr7/4cCw2 +NpEOhrRYYgrCZOBGNC7jzkKpSjo/n8xAeDubLcz6IwpcHAKfeKzEcaDUuXjCyOIbsReN0ja+niYz +DY9qVJ7LxmMASLj/ubikmpulqZfJXGMSX8IlQNCEuyTFLVClVBICn7ky1tE2QMi93jwQmIYoKQ6O +spLJzmSzs+ATdX0jk63j+8iCWnX2ULW+FaRNzdhOphvgnoRcbWpqyx8UoomyUX6pWi/gXkBFMKKO +eZIARJPp2USiCnYGwIM/YPqDFqiqxyuOT6QDQb5UeZTK1kbHE16fWBA3FRPAwzPNeg7h2CRtzxiJ +WnDrCV8OIHFBWNOmni+sYTIEcCyos6Et/ulv/+dnL08h7ouB7SosJ3ML0WS1CADD2AqF1HS6ZE1t +T3oKk54c6A4AoVhqXtRe6uW98fFUIV17tPpdlNNAkHxBABiKL2Ra02/Wty9EeXlsNJyM6jFOB3UG +tgP2BnD1cCwb5mqy8RzM4Ph4JhK2gDrgKrAilbSwp5Qz9dJObXbf4yn4fRL8iUaAzxsgzOGQBnDL +4+MhpgMc9c03YY+H56Ilnl8C75bNNkIot4AzhWxuMRyFCG41kVmEP/HMvC+s+QIipqOzs4CLoomp +bG5JViFAnoH4Ip6wID4timv12XdG+VUkNh0MV/zBcoSrTXpFX0ABOMEBnEhP5/kFbNhOT8H1AV1j +A2qyYlVf5YtNALdhuIsPBDgZj0vodhNGrjgrm49ml95V6m8SWFwzwULmslPT9aeLK/ul+utYug7j +RXEpnaoAOgJQyudq6ZSRy+r4ypi4BqAUi02pCscpXk8WPLumrvGF2VSqkivMxVL1SLwGXjiersFD +BsNSNjcNzynrjwAuZvMLIADZfENS1yJxCBl0wMDlekurPAdpSWWX6RWQYEamAGGCBoFJzAuP4Gqx +1JSgrHqD0h/+4AcDqBtPsvk5CAAnvWAN0mB2ltdPVjY+gtCGOaVUeQZPCJYwmZny+AoAKqzKk9Wt +k6dv/g6CZaBuZu49oMQQZ/hDCsgJGLfxiVw6XZW1ZR/FlaR982B+I1FAd4WJiRQHkp+cmhiPA7oL +RIxoEiDHsmI+SdI7tSGsyEHEHdbAwuQLgJbXEok5AAwg4dksJp0mJ9KhgPpwlAuAShYWStOvzdre +3od///nf/F/V+tsHDxJgzeDP+FgagBnYN68XwFij3mg1Fg9y2FBdWFs/FqW1UMiY9EmTQSOSmFLN +R8+//fFf/6f/B3c4jFbCHIDVed36NldoghCCsoAgxRIVoCKXA/i6CboQDAPz53L8XBpfpzIP4Z43 +oCXSi7z4VBCfeP0qNl0ElTCnAi4SxHWwOWArMoW5cNQMcZhAq9Rf5UW4PkwQOFM9mQR9gR+kWEzJ +CTOSsb62faGYYKDms/x8ImFlknohV8rmwJFh7aYy/cqwnkY4IxyWCvlGLlsNhnITEwFAp8FQESZl +dukQTEEgJIG6ZXAxTjUYyAMaSSTKgrRmVl8rpWdgHLx+HiYaRCvEyalcPZqsIc7RweBsSdoGHIDd +F+JSub6rl5+D5wKlAyiV59chdguFwNFkeWFlqn6Qzs8lMrWcuDLhl755GAkHxUKh4ffnvJ6kZzIB +980XFmqNlm49odcx69WZpwUBkKqWAbuUmAFfD4Bh+9ufXh78fakGUje/+fh70B0Q8qL6KJ1fBHVO +JOoQzgdDAsTC+cKsUFwGFAdyAiguwpmxxHQ8WQMU9OBBcHw8AY5jwlPw+IRwVEf1iegQCJiVl/F4 +BeC6JD1OpuajOLmKz5cffRgYHQ0H/VI8WgPzG09PVxpvn+3/y/L2D7PND4AtvV75mw== + + + b8At4tIACP1CQTmXn1X1xzOzBxBggveHiANQ2eOnF5q+5fVJQa5cMF42n/7w6S//+S///F+OTv/B +H1a4qAVwDuKaXGEJjAwIFb1dtJkTlhIZ8HfShFf04MvjKhAOg3LBM0P4Fk1WwHJylLcPoCusgEym +0nWARiFOjcZK4LM0fMXG21S24Q+pyXTNFxT8IXCU9WRqMZVZAt2PJWciHAhYJYMVbQMsWzw9V194 +X196B5pOdCmA4kIRCexMmNOCYTBQjYKwUeCbYD0gjpucjKeSpRi+8RY42chAXFB6VW0cJZM1Lzj3 +sVgc/abFxdREZiqZb2SElYK4kS0sBSOS15fG90Zpj+aaH6aXD1P5RS5RxURHRE6kS/EUdrVBOAlx +xMzSx8bSRy5eHhuPeTy5WLzMxTR/oADIIRKrZgUQyFoyBbOsPHwY9kwmg7hgIY0L2TJgRhpwYpZv +FOUFLq7l+Hplel81XynmNi/NQwQUTZXBVArFhdLUk0CoGI5osv6El5tg9MIhwzNZGJ9I+P35VLIM +UeHDbwLg9Av8Qja3EAiXxj2A3PKI6IIAS+IPR2MAdBPJSioNsGolnV2IJyr0VlYwO8WxsbjPWwgG +FZ8fNzmE4CiZaBSLWzA7+eKyIK+lsuCGlIfj6dFxgYs1coVZTQe/vDI5CWw08vlGNF4Clzo2WYin +q7niYl5oKtpjsD9gvgDLKfozRXuE+9InTJ83F+Qq8eRsMjXrQREqwB9/UOaFJYh3wDbyOuaLvH7A +SPnxSYBbajq3kpceZ4W1dH4ZJiIIYI+zQCBDEd3rF+EP+LtUBvf45aJqMMRHosUIKRGuF0tVQRQh +HodQDpDt7Px3Lw7+w8L2jwBfAQCD5MTicO5UIlPOFRdqix+06l5eXoulp8HM+gBm+ARgCDg+AMOx +2Eye3xakl4rxMppA4z82EU2la7X629LUXr64EYyUuMQ0RMGWsZnP1wHjQVg63Xg9NfuOS8z4Q3ok +VgaYXa6+kpQVAH7wLV9cfrR98WLv77LFxQCn+CNivghh6Qr4JqAukaprpV2zus9Lj0Fbx8ajXl8G +0BcYGdARuB1wMlNYi6fnAezx+RmwM/F4STPWm5vvq/OtZG41zFUnvTyEddlcnV6czYfCfFFszi4f +za+ezDePI/EpEAOfjwerC+IEhsgzyQcCeqG4wMV0Lzi4sThu+RgvRXGbvsj4eHrSU8wXlmvzLX9E +G5tITXjSYLTDEYiV8nA8pq0eJkKk+KDs4F6DmD+fyuRmKR7RPD4pELKiibpeeg6Ujo6lIGwsT+2W +qq0ivvZCBnw7Ppnw4Hs6KgFv4cGDiN8vl6vPn7d+qC28iKZnQ1w5GNZCYVNSHuFbfaNWXlyvzb1f +XvshHIXgpRFLzkcT0+jfvfkJD/CkXKvtNh9dbDz7u9rCiccvj03k8MFCegjMWrwcTc3ki49l45li +Ps0WFsE2IjCYzPsCEDNWheI2QDXaXR/R46Q3R6/UkcDiQWQdS83EkqDjU5LUNEv4sntwtaK8Xa6+ +LoqrEJCGuWI2P62WthKF+WRhQZt69ejlP5i1FlblJtP4cu2wyOcXVW0HQolccS1fXM8VloXiSpTD +Pca9voLHy4MFNso7grxKBfd6ND7NC00IEwIRMxSdyuZXGksn9YXvQAjB4OCGw2mAarO6uTo9/zov +r1bn95c2v1/avMjya6DUMDVW6Vlt9iCRWQ5H6+nsXDoLVJTDUXytT4SD2V9tLB/vtP5FMJ76gwgn +ojHAA3OZfC1TqGjljYL8OJ7ExAioFSjXxCTEcZgfwC3Q5YWisiZIjwACZbILmfScxyOMjSf9/mIk +bOLfnAaKCcY/LyynMwv+gALW6cE3/ly6lkCHqIOCA9Ko1L9tzO+DQfP5U6FwwTBXDfPxNw8iYPy5 +mOUNqZEYhKjTmNodpz0w07N88ZEob8F901nwAmWvVykU1iHK9kFoNhqFI4FXoWgN3J/Pr01M5EdH +Y9GQks1UsKiRmMoUN+bWL7Ze/LkMRgA8eLwE8H5x/YNqboHTnwRTEClnCxuC8hiMjzdQBEmIxUql +0lattlObeQ28nfDIXr8Gtgtsy9hkyhcSuWRN1J5Z069F83EyvxAHesMWwXiNQoxyIgUGuRlNzIUi +5XEPvucIjFI6N6OWniqlF1r5ZTY/H0+UASeEOZyFHA/AeBXMERjhXH4mlakEIiKYXNDHjWefX3z3 +73h1C6R3bDzlxQxeLZ2uBDGPUQBfI2lPwRQLxbWJCQi0kxCSB0NSPGlk8vUQp4FNK2IeFYLEhUBQ +AbOZyi2lc4tFeZ1L1CDaygmP8sIKRA3pLAD+mmpt1Rb2dl7/+cnrvzWnX4djdX/IAOwqCCuUiZrL +FzetyktR24ympyHmnUTbpUnyigZQTd+MZuYiielUdkFW4aarkThESdPzq60sv+wPqD6/6g2oycwi +BKdoqMPqxESMi8pm6ZFmPC4q4Fxq/gAEdGokYonSuiRt+DCgtiRlsyCuxzONUKg0Nl4YG8+GQ0o+ +PRMMiPi6H4jpyju1xmtFfwzg2RfkJbk503gtFpdGRrwAREV1TZ/6VlCep3PzgYD88GHM6xNUbTuX +XwiF5GBQAySZB5ML/lF4VOBXwdx5JnMcZwLqmACL4ZcjCVDPeiSsx8JaFGKHVK0grlnTe9OL71V9 +I51uJNCVGIa1sbz6NhQUwaJCMBKKlhO5BV/YmPAK/rAeCBvpVJ2LKtG4Ap46nWnGEyvhcM0XMLwB +edyTjianYtStF4zp8eysNf129dk/lRc+ANQBuQLXA1qpqE9m5k545RnVX0ywZqA4YNXpFfMLWWEd +phuwHFrmRMXnF7x+AcQyka6bFVx8HQipoN1zS/szSy8Lcj2eqYLRVoxX4IxicT2dLvsCBa8/VyjU +4Vxw9B5MLEuYzeZMy9qOZ0p5fmp1+1g0IOCyYslpXGnu4X0BiZdW0nlAKVowogGAz0vrsrGD0CsM +eiEB1QWhISr1glCLJsvg9Fce/aSVXsOk06uO+JywGE9PBTk1FNWV0tb2yx/Wn3xS9dVspgxohBeW +64vv4hlUKH/QhDAnJ6w2lt7rJbADvB8AdtgE4czwa4ncoi8EDAeklE6lpxS1CeFPOrcMVjEvbDYf +/SgpjwEAx2KVSQ+grOlsdiEag3C7FI6Uk6nlZLpZ4NcDAeXBw4jHm0tnGh5fEcIoLlGfmn9jNt5P +Nb5LZxcfjiYePowD5yH4SmZmAlwJrgBqJSpPeHAQyWkICkbHE1xsCrxqMjUTCGoF6XFOAiMzBW40 +HFTBZno9BULj9clJfmI85/MDnsG6PwCJeLIUDMmjY3GIHzOZhXxhEcsfUbC0Usl6wgHMC/A+TvOG +tCBXAi1OpJYUdScYUpKpagYkIV33+JTRcd7rBZdaFpVNpfQ0lq6G4wYuH8gv1eferz/7o17bBbyB +fSwRHWctakQBVnFTmcLjfPFZll9PZgBgqJSDran6s0c7YBN2AVQDDJsEgBcCHA4hOciYCEjeKL+d +nj0R9Y0wtoHlwxE5lqwmsjNBTpv0pgNhVZA3s/xSPFl+MBrFjiMvvkMNPD64hiCQxpmg4KK+Hc/N +jk5kI1wZ9M7rU6KxCgSA4ODi6Vm9vAuh+pgnB0ZYUjcV4wXgDVFp8sVGJCoLhbqur2Negl+c9Muj +E4VJnwimJpWd8YeFSX9eMdZXt77bef0j9W8XJjwARCWBXypVnkWiJkQ0srKlm88167kgb4D8fPON +1+/nUxkIYNUAZ+bEbWPqsL74KSc0sW4VlEbHYoFgEaYsgShIHAMsPZYAM1sQmnl+MRCSwcKXp55D +fPdwLDPhlf3h0sOJPEwNIFtR2ihid8oOBMhBTvdHpsZ92phHiSUWq413VuUJxBfhsAx+6tHTz7vv +/rVc+xZisdHxzOh4LhyxwLpisOYR0rmFd5/+29L2H5P5pbGJwvhYNpOdr0y9BpT7N//d5B++iURj +tfVv/2Xj+Z+K0io8J3gc4EM6Nw2C7fHJABViqbXS9NGHz/+7or/K8Mu+CDyMCbYlGIVQBXDXYiKz +AtohKavZQtUfzMKMe7xKJFQt5Dfmlj5kxCVPUND0te0XP4XjU7HUdDRT9QKG4WoA20BPk5lpfCs0 +pwOmrTW+n136QbVeANwFCMRFtALEsOqaIMNF9FEPIOSaIDwrlb8rFLfHJwB8FoHAcv1ALb3mUrXJ +oDhJPSHI7Yn42HgiEtEV/YVZbcGTewPC6HgSA+2QChAUcGmqsGzW3mw+/8eFRz8UlMdeuMVYNhGv +TU4Ko6NYPQGWhqMVUX26+/5/nGt+74coKTdjVV8a5deF4jqEhxO+woRPSGdmJXwRswLhA2bDknWj +9MIow4xMYx6GQzuQSFe5hBWKwq8lLj4djVcTySkMhTz5YBjiqXkA+YGQAr96vPlIRMtkGvnCHDYe +5xqCsl2qH+jll+AlxzAlDui9CMg/GMStkACuj48lI5wpCBCqr0H0N+EB+CSp2jqA87GxdCbbbD79 +k2Q+y+bWksk54IlcnK9Pb0YihQcPQ9HkfJZ/opUPZhcvcsLapC//8GFUU1ef7f6YykEokf/Dw+i4 +RygUHwFaBlsBQTrAKhnXVW3x4sqENwf6GIrWk+nF2YWTR0//HOZK3/wBs6MQyyRyswBLHjyIQwgA +YpPMAvd2IEDzAryvt4CrC2ufJOP5uEf9/+7J5/VdP8Cv9XEJGbSPS8igfVxCBu3jEjJoH5eQQfu4 +hAzaxyVk0D4uIYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1c +Qgbt4xIyaB+XkEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3jEjJoH5eQQfu4hAzaxyVk0D4u +IYP2cQkZtI9LyKB9XEIG7eMSMmgfl5BB+7iEDNrHJWTQPi4hg/ZxCRm0j0vIoH1cQgbt4xIyaB+X +kEH7uIQM2sclZNA+LiGD9nEJGbSPS8igfVxCBu3z+v+9J5817p58/iaZnDt5O7t3vjeysziSrC9p +u/D75t6n8/2zkbWR5G6xfnY+e9g6Pzw92Tv7iSvBkCjIKlfc3N874jLsSA4O4tbPDt8dnsDgVmvv +aD/LFeDQMvw/InISJ9J/Oz+N8Kao6IIiq5JpyvCPzJmiIQuaJiqaImqirHDHeJBqCIop67KpqqKp +Ow86woNwTLUs0zRUXVe59lmWJRmWaBjsIMftejrIcbv3I09HTkYejVhcJsvtPB3ZvvYT8M1Evs2c +XXx6v7F3Diw5uWTm7trpycbZ4cn54ck7nmfDM/vAqutfjKx9xG8kkX219WRh/vAI56B4+SPwvriz +2lw7fbuPP96YlJ/9osxlfjw+OoGveHiss8M3F+f7n3BuYF7P9jqOaL0/PHp7tn+C38tccenk/Oo7 +/Ov8p480r5n60m796OP7vV0pyxW3Tw5b8OUWXP3k3c0TPu8dXbAzDt/Ckd0OOdk7pg== + + + I+Ax8JjCbZNy+ua7/db5zOnFyVt4tpnTH3ul6IAmBQ49//TLp1yj8MY5t06qmOyVti8w4RpFPw40 +HT/1TMdPd0CHJPZOyfv9w3fvz3smp334QNP0w+Hb8/c9k2QfXejhwQfFTJ5fnL25ONo/ae33yhJ2 +ao8cad/nlqmSeyXm5OJ4vXW+93m/dwN5/ZRbJwynq1fazvY/XRz1ro/tw2+dppPTrfPD89YX1OyK +rk909OPDoz4m7cY5t+8NBFHrlbo3e5/258/2v78AnezdN3Sc1YsF+hlCpF8gpDs8uoY39h/3aE6u +Hv0XJmOAdevw5Asm5jpmxGNvXeYOT3ql5fTj/tne+elZzwRdnXDrVG2dXpy19hfO9j6+P2z1Pll9 +zNUdKk/j9Pjj6afD8z5057d4DgoAen2E4uz+AVce8BBQdUNANwQcXDrcEHCQabr3IeDB2R7EM0dr +p4ef7lUQ2LPVd4NANwi8jSCw50y0GwO6MaAbA7oxoBsD/hox4Mz+5/2jrfd7b09/uAfFQF6+LwFS +P5QMeIik3sMQqQ+a7n2IxFwOJZN+M4czqNHRp/O3s/ufD/fwgfqA2tdPunXi3hxdfMF7/QoR0h0h +hIW9i0+fDvdOZr5I4yAC7H5mZtBV6PTg4NP++ZfnYfii8Z6Nw9veHfPbu/DMvRPSO1Z6++Mdav86 +ydzw6b0k9uxvPu63Lo72zuZ+/Hh6sn/Su7Y4T7x90NQvkY3Tk0/ne19B5NWJA+1cB92EIzvXL77A +/uGz30cYNGAvb+v06PSs9MP7LyYUruO9n456z+3bR986hT3303y6ODvYa+3bDd+9UnXjpGGKVCCo +hk+vzPljzxz5410kCLQ+SBnwXIfUz7T0me24IyiycXp4ct7sJ5vx2+Qq97dsn9i0rd7woaOvyi+4 +1Ye7qD70iRhcAHSnyZKvKKcMik3oW9AG3R7snR2evz/eP++9aDdMduF2qpK3Hkecb+wdfik8Hb74 +qGck9uELCaRrxOChA0zIF1IT1wmRBjlz8qF3M/fhLqxc74QovROi3BMXOjxxdP+5/WHpMFndP3u3 +j5wcPkjUrzu6x1Py2z2H23j0azUeNU5Pj2bO9vf/2HPudWC7jn5H6094LXlPco59dPC4/VW3TpPk +9lddMuPt4dFe7xWq4UsL3KvOsZ4JGZZsQO8z87b3mbkLLy0JPW98cbb39vCid5fcPvzuIPLp2cf3 +p0en73r2VIMTttxf63ZvbNq9W0/X+yom16a5Nu23lK9B1/yeE7ZDo/r9LXIaYN3nf7s+5DtS+WFt +3+1DpgZc3+/rbgc9N0QO224Hb3r3/8NioHumaNAN9O9h14aeJ8vdteHOai09p7kb7/dOTvaPtvaP +9lv9xNjOE29dEjd7rkp8LZHOEwfZNA58v9v9wUxvvtCqMoQuuGeKBt0F90zIp/5WwPS+9OU3cUez +h58+Hu219o/3T85X9z4On0/qQ8IGXPuP9+BSPRf8hyFWetNzXmFo7Fl/W5wOsD0TufZ/nONH6caP +vVJMP/Ueb7QPv8OGy6PTs9UelG4gzV7vgjjgZq/3tdzDuEFKz+miobGAPVPUtwUcnj4a7Qtm7lrC +vPfNY9ixd7D25GR/r+fua4CrrdXT3jtor51w65Sd7RO07ZW0vbdvD88PP/dO2tUJt98QcPTD3k89 +CyEYi/O9s76MCzv+9lFJzzS9wXej9Z79Y0ff/rLPnn3WNTls336Nnr9XYbx51uDWRc5Pew9bTgcZ +jxycnR733mtNB99BFa6ftviDw6OjfrrHj+6AopPTk94teqt1cXzx5aaw62p07ZQ7ikz2Tg6P+3jk +32iNypBvf3dfoqPWvWub6Z2iQU+h8KbbNjMY6t6HTA24vt/Xtpne9yUctr6Z1r3rm+mdokG30L+H +vhn3lZeD75/cxpn70jjTh20c+MaZ+4OaWveucaZ3igbdB/ccJLmNM4MqYQOu/fevcaZ17xpneqdo +0O3ZF7pl3MaZATd7buPMMDTOtO5d40zvFP0GjTPDUCIanvafPqayXxtyR1M5xJsV9tGQ5k7G8G5U +Mjxz8ds9x90+w33aMnKWtgra7S/Jcs+aWO/vdkn3co/43lOcv4PteVz71pN901375tq3IbFvPcuq +a99c+zZ3BgO/b/i2jyxwrduQWDcXvbnWrU/r9rsGb651Gybr5mI317r1bN2ul412+2sLuGdGrmfi +f5UK7lBVCV0l6kOJjN+zEvVMvKtErhLdVKKNwx/3jzaO9n7a7W9N4iC2pf2O3hymiZzWc3Mde9TN +Pvrrrp0xTHZQ6n3vjMHflObTR9yWpld63E1pBmJTGomTyrLISRr8LXLwfxl+hn/L8AX3mzfDujvw +uDvwdKGnR/s/7NvvnO0fn37JSrgbvfzsRi+3TNvhydv9g8OTL77s+7oB+bi/dz7bh+O+dsawbGQz +KFDqHr5M8naj5NtuAe7j9fHDslygH5p+pwsGhqNyM+irwL9kuYazzNaX+gy47W6dHn88/QRgYf3i +C4brVzBzd2QaGm0ah9Uu9IkWBt0q7J0dnr8/3j/v3dINk3X4Go0aJitx7zYN7Dnd++ELNdVrxOCh +A0zIF+bwOiHSHRDSs4h96N3UfbgLS9c7IV/o4btOiHJPXOnwlD++yvy5qxC/4jnc+vOvX3/ub8dF +t/7s1p8HzgDfq/qz+1KUIaw/k15iBVoWy33pqFtzdmvObs35K0yJW3N2a85uzdmtOXcnya05D1mW +1a05D5pVuE9lzLeHBwcXvb/VZFiUpk+yBn1725530/t0cXYAgeRWf7t23zhpcHP9TJr6o+3GObdO +2k/7R0enP/RK39Hhu/fn8D3fwr18eyax87TBnUBbKxunJxDUnvRuRhznDVUKzn0vsZuCu9MUHLNC +5Xdn+/snZQAv+2UIOw/fnZY/H54e7Z+Xz/bflk/P9k6+VEVyc3MO3+Lm5n4ls9K753MTdG6C7vZo +cxN0XZ54cEJxvedy0v4R/NJXLuvaGbcPqc2eCdv74+HxxfkX3qZ4XZ3ax99Z9mf2kGB8E43+HffO +zLLIomn7n+FTAKn31MDH/RZY0bO5Hz+Cve4j+nKeePvq0LM2tB+27xjTeeJgZ3oHPK/YZudtrI4Y +XJUbwmwcBIO3nq9ykzluMsdN5vQckGDqhiVz7MwO5XTcZE6nN3GTOW4yx03muMkcN5kzHLHs0ZcT +AsNTsnczU25m6q95lC07gB7e1NS9XIJ/Pzfm+IpsjZuAcrfnuL3+vIG3C/d7a457+X6Mo8Pzjb3D +L5UIhi8/fW+25eh9E4gB35aj9xkZ8G05eifkd7gtx+ADHNeN3q0b7dfjDIsHdXe2GlQX6u5sNWgu +1N3Z6q9i+aB4375Nn7ur1Vc8x90+w33a1Wrr/d7b0x/cVypt/zVbWg2PebqHGxf0vBubu3HBYKWp +3cX+g6JCpwcHn/bPcR7O9t/2ZRyGJXDr+eWtb3t+dzAdOsCEfMEBXifkxzu0Auske7+rGOHr1e0e +BwuDMjm3U9Iannlxg7ihCeLcfYmHaF9iXtKSvVLXuyv/ccAp6R1d3QW4khSxZ0re7/fTDHh5+O3T +pPZO0w+Hb/toy7SPdtMfdxq76W76w01/uOkPN/3xSxSa9yX90TshbvpjUJ2wm/4YYLvupj/c9MfQ +pT/O9/poDHSTH0NdwW79dp01t/3ikbO91vne0drpYe8LXtjJPVLVvtPAbsp0cnG8Diz43McuE9dP +uXXKWj1nWIclMOidokFfV31yunV+eN76QvrqejoEj358eNSH8N045/Z7doWeN5h6s/dpf/5s//uL +/ZNW7xFdx1nD5BXc7Zd6Jsrdfum3IO2+bkLUhyUZ9j17RKHndyCdn/YOwk4H21UcnJ0e9x410MF3 +YDfc3ZTc3ZSGfDel3yST9Pji7M3FEdjmoU01uvvADMEC1T7CxCFJBX/F6jQ3DfvLadgrW7T7hSWK +bjLWAULusBOt9/6gwe5D652OAe9CE+9hF1ofNN37LrTzHkHbcKX9e27NGLasP07Xfcv7/x6y5eLg +pcvdGNCNAYc1BuzHDLpRYF/PcU+jwJ7trxsFulGgGwW6UeDvKgq8r+1fPe9Q4MaBbhx4G3FgzwLp +hoFuGOiGgW4Y6IaBf30Y+PT09O27s73edcCNAe8+BuSl+xIF9kPJgMeB2j2MA/ug6d7HgffyHSo9 +Y253V4rBCAT72s+h36VAdwTr3B02BsUc3P8dNk572MdheBbTudul/hIh92K/kNvuIO7nnd/DovR9 +ETXoOn9wBCE7ezd76c3RXutDmWNDpx/3WofnP5X6yKR+Ov/pqPdChX30nenUPJI5fCr11+yj4+ZO +72QZRV/2wsV0d2zeP9G2uo3f1MgPT8Z7UMzefYqL+nzd8bAoTr9vcR5wZNRzH9uni7ODvdb+Vmuv +H/Rz46Tbz8X2J3z90XbjnFsn7Yf3faxBPsJcOHzP9+Ckr1HYedrgzp+tlI3Tk0/ne1961+j1cLfz +vGFKrtP03Js9jvSed9baP4Jf+sqpXzvj9mVY6dnE7v3x8Piij4LQ5fF3BrVmD0lvmv2U5n6j3QJm +mSo3bZs1fNiv963l2m/Bnvvx4+nJfh/mznni4Jr09rP2bdOdJw52wWnAYfxXvHJ9WKD8vca+dwMQ +hww9ueDJBU8ueDrY37KN/PCiJ7fLemgqBV+BKFyQdOev9BnirHq/KduBtwt7Z4fn74/3+3gxwDDZ +h3vZNHp0eL6xd/ilMHb4YqiegeeHLzRYXCMGDx3cxMSHLxx5nRBpoGekdzP34S6sXO+EfGFLvuuE +KK4LvTXM5rrRu3Sj/Xoc14O6HvSWCBlwD9o7FBhwD9o7Ib9DDzo8qWr3pZIDjIx+czc7PFPy2z3H +8InFPXwb+33d1On+vtOv121zhg803/+9ndwtfofAyvevYINu5I/34FI9bwMzDOZ9AU799OXOneGz +gRIn2v91++lypFey6aferWP78DuMBY9Oz1Z7ENdBNBz3EB7e621RbnUp4B0p1HBvKXIr6ZFbpmn9 +3i9D5XsGuYO+GwfvbscxIJbg67Vm8EuW97MjsG+IPuiGG+sUKICPb2Nb7XtQixmC6Rl0kZN6fy32 +MALw61PW85rXYVOp4Ubg99KK7xzsn80fnv32yaPhKUef773pfY6HIUMocz1XgIj2J/1lym6cc3cb +gV2ctDaHz6jcO2ETDE7kfh/ituCK292Lm/R7MW4zd9yoQvEQ7qrw+Gzv5NNB72+7GBzp/8qVN27S +5C6SJl+DTocBcTMhHBDM7WZObk4QdePVj44GYGoGhSVfJ7NuG+hXPMfdPsPXvMIqWV+SxN25k7eX +r7LCIQ1HdtdOTzbgErSBCs+GZ/bfHZ5c/2Jk7SNdQ2Vfbf10/Ob0aCSzsH/2BhxPdkTk6vD/zg/4 +w/7IxchVB8jOT/DLMvzwHQz9wKncKvfilci9xcM3R3hZFixTUjlZEURLMrnjEfzJ1A== + + + rcuR5uUIDz9IqqnC0OV53cauzjy5ep71EVEQJUuUZEOxTFMyDYUTBcMwRUM2DFWVRFk1YUSXFFPT +JFORZFVTZaRBsGRNhTMtXTRMVQHKBMW4MYQjmm7qsqFqomWKisXt7I3wkiYYEvzM6wIMGwZQx8ui +IGuGyfGGoMuaBT/IkiCrosyOkiyNe0ZH6YpucLwmqJYhwg+SJeiGCT+ogiGaogQjpqBpookjommY +FteAO+qCJGscrwiWrplwTUkRFFE1cERXDLyOJKiaJOOAYimaRmcB4yQdL6QoCj6SpAqqAk+Ct0dG +OSlpjBxczYskSIZu6Dh5ogCsVHFINxRT4SRDMDT81bA0i3syAg9oENXAVZNuJuFV2IgiSoYGI6Ig +6SqyWZJ1S1PgZvCEuj0EZIlwXQ0GZIlD3iF/4D70r4yTzE4BhqFgAL0iToisCrKs6ngfUddgzhyP +jzShkJi6pIuiBrKhSDi1miVZBsy4BNIlqhaOyIqha5Yswf+GZAuJKsFl4CE005QVjY6SrgkFh6yB +C15KjoQyYggiih4ejXMoAQ9hSFN1vI1uifCc8LtNu2EplqrhgKHIKgyYlqHCdRpwDvIFn0Kz8MpN +GFGJfDhLMgwDL2OKpsaeXlPgTqYgWZaMJylXlzGJq/CoiqnCNBuCpqsqEqMCwTpeRREVA4/QgFDN +opM6SGjafLxVZUNBw5vzIAEwJRYwEhTEAh7gEPAdfpBxplEJQN6BPpA0C74Rmb5YkowsAAGFyddJ +9FUTuAy6IMoi6YKsyZaCQiwzdtNpCmgOSKyqKXRzy5B1GmBaLgumpqrIJpBzFUSIHaMAK+FOlgHH +wgCorOP5URpNAR4FJhHUTgXWKSQdMkojPo4uSYoC3IabKTJIKpkU4Dkqh4iiywN5IvAMLy5ZpJY4 +LyqKOjAHpo1GgAYZWWGYGrMYsgYTC+fIqBwyKCw9DlxVRjXBISIOjjRVjdkUQwQBeoJEgsBoNKRI +wCy0PzqSBQMiGDwwbg6iLuXFBJMn491Aj1BeYGrB6Mig1zARBgkYCBXMuwxiY+IxJC83NI9k17rS +PBIg0sjL48g244zBrzJZVgnYBrwFhYJD0ewCraYqmnR5mbEF5lzVUBNAV0RLReaiCiAvrx0Fl0XR +hkkBjUGlQsItYBL9LSqMv7Kmg6VS2ISDgMkmCD9wGG4qofmFiaRHA65oQDxKBWirKJMlVW1RA7p0 +FS0dHGYaYBtoDHSc60Lcs7vQSdAPuJmqEo2SpaL84phGJAGPwc6SFsFlSNZ0UDXmviRbXsFdMNMM +Y6puki8B7ugauT0YMckRoqriiAXiobARXSGPiO6SdAFOM1EiYQT00GRsBlWjEfA3qPNwOwUMP7td +x6PfiZTCE1qkYfDwhors08nvSTSkaTJBBFFH64aSBWBBQvahxbfV3SIRBbMCaogKb4CvNywDARPi +JPQWIMom88o4OYqtroaCM4B8kOyrK7opM960pQtEV0GegiUAr8wmVTZxdh08bY105bxzdjrmEM4D +ZdTR1KF8q5KBlsMEBiuEnUhj0NvJpkXyjmatgazT2qwDdupIr2FrLPEO9ISGwKRb2rUH6GD53SgO +UMH0Hr2QoiC0gjFDJosCGE836ZkRMiE94EkkJhRgCkSRoUuwVsQINNOWrNOXcCeNIUcdXZqE3NaY +MIEfU8nMiaLaxpIWOSw4D8CPQVMpSTL5FQ3hHRh8EgG4gIlSLzLDb0qShk8giaADJFwIYJAWE2SJ +EKeDvjvRLqDHNIhtID7oVIHLKC74kDBmwnSrxC1FZaiBUfSMQg3gt0VGSCNJBC7rqFZwlGGaooUs +gYuLhC8tcq1Et45e+wqSIHMRjCJQAP5pPwPQHSjegfM7g4EWPSRdGv0LPZEM3FYMdhqTF0REzKsA +wiQ7AQpk6x8JC7u07dyA96bJ7n6Tb3eBnHnCWPStruuiZOsIw18wxuIE1BoRLo8jAIdBZmFEVUHE +aIRcKc0L6LVC58H0yGxeAPUR0EWcy4yphqEPPA1ySCVudT7DnWDfrqxwPG6TAj1TtvC6okWCAOZa +wQGEEIjT1K6T200EHGLSIUoof0rblAoaQVpeRixt0VkSyTGcpGg05SAQYMiZAEIYiFNhAAiSGCyA +GQMsKUgmxj/M6iiaQSGQZlMiX54mg3nknDxBISUYijqMcTUC/mN7CEQFhpgKEVSF+2joWyzt+oBi +wJTaITPBO4iLbTSjwn0sCwYsFjHrDPiSolp0joyxGERQBnpd0kZdBbsMsscws4wPAtdCrw1Rln2K +iXYZuG0inwj1IUJF9qsKsQL4ZeIRsoqhCJlyPMIUDBvA6OTUYUAj5jeIfbpiYnjHrC+Rg8+q6DSn +HUxq3JFxvvHYzDZ3kNZBewd3UAYlJigSRbnIQLTiYFUp7kEzi6YchJuTUJIV3eY6CTfKlEYRD9ht +xPyIijCWZmzXFTCqeB0I8chMSugTLYIbWje+34lpAJSNeSPSGJCyY9JmxQJohlKAyJYUDJE0ZllU +it4UMhrENU1uuyAQQDakoivCAYzecEAhe6GwqIXCUYXcHfCWzAvBC4vdyUJYgvkkU5aJkfijRBkd +2WKYUpNEemDwEW2MIaJmIhRXNPveqDJ4S1NkA6RUFLzqpi3jCmWKwNkpmPfp5MSzu5BqgO8ymhDT +VnqYDpNyB8RITTUsUj8ZgQPG2VJ32hz0OzjUwcUWKRRlbDDDoVnMsSN44eBfg8AMBfR4J0DFwCK6 +k0QGjvJtdCewVrIKMwfHGhqG/PD8IPYySY+o6BRhaKRJaIFxkpFoW28Z7GgQH5DryAcw6Qp3nTGG +nQ29yam7UR84U6EHRK8EVyX9AXODwNhsm3rQDPSY8LtsGuQ5GY/g0dGeUvSlUVoSswhoJBDIgQum +CQM2EJCkpCT5Op3O0Rg+wcyMaciE+0XCNJjnFhUG7Ay0MGjCdNWOki0Ns6lg9zRdIqjHYjUMnQyY +lCcUvjE/AxCdOVjQQCRAQkfN0AA51TbNjS58OMIEMBCuyGTgMG99PAIBnkmioLILQXgnkd1ksRR8 +TREF2k7iC+JRdG+IHUBJ4UqyhYYIXSOKMfwugk7h94pIaQCIXhUFhdhkwmbYYSZaD8yJPoFrSiKo +IRkztG6gNRKGhhCzgOBwsp02A60jpNhAKgjgwYgpgaDJDPHh7+T9Oqi8C2doIXtQo4APIFmY25RY +9C9hBI15cHDgBqgs8gWeCYwbJe5UxikyH/A7cgj9lISGHF2+TN/DY1NKUEV4ruL0gH2kDCCoDckS +QjHksSLiPcGxiQZLaeo68V4yVXo6zDlz7Qyi1ZYGeGqTsiqddNxVppiyHviYWJQ4xswmiRtaYFBl +SlqiRAABlLN8QrlPYpaE2XMVWUDgGq0gsd9AVaRksamRsUIniwaOsqYQo2N+VZaJiRjdcJ1PcRch +lKMCgOnljipBlzrCzVJDC4sPikSHYPmNChTwqPSsmF2QEGeKlJYAXCnpTI1ZKC3ZAPTqd5aIwpoH +orR2mIw3EcnIYkwL0TRgVQtmFI8AUybT7+RFwVlCAGyxTL4ky1dGqMmKT/A7S4AhKJEJ5UoMIhos +na0xFExTSKGNRhCSUuRkAjFmwqlEq4WmFWYYtBVvKcsMAqlkoOkMsvIyKRDCHcxqaSqSobIKREfd +6vOIo7LlKH05y2OWnRQWyQiS5zHIM4j0qMDyLsWegxFHleKYhlSVyhCmatiVDDQbOED5kGcj4KIk +ltoDD2VQak1v56ZEOyEB06FQWIin20IhKpirA8lC9KkwKaA0Lw5RPg+0iGqBMAByAijAUW5CQXCU +pDqKVg5aWyMOfjg45uBqa6RLZdJZvbxR32yNtIUIMQDhGDKiMssCXSq+XZVCD0aCBkOiSDwGFTed +taDPIx3FIkctyVlvYuYEfpEleHpwaTpjo2SIIO9wG5EVGeEAsAoyGBBTJdNB5uSaXVWYL7thPuwJ +ueao0J4AZCMHgKUy4vIxemNyt5ghNkE0QFYwX43OHocorocB2bAHqFwF6sMylgrVnhhS0ChKwNIA +JTYBDJFA8KhJItzLIZWNEYfsNrvL9w3OfR5xVvMc9b7OmiBNPAvrQWQVtHUy2W6WiGDYvJ1HxADJ +pGQHTjyWTlmyQrachTqyBx3FvM5yn6MkSNZSpggZC/iY9dKBA5QYRmOGZDrm6i4cEEy0QckarFhg +tq2rwDgetdmthuioNDa7ViNvViw/I+ixp0ChtDq5cpbrgvtKOnnwy8wYWTISLNNEGC9pLJakpHE7 +nQssBEsPkRilbrDqQSaxifCYlQ5VW2zANbF7oTxhc4KDIXeBNmXM+5uM3wrq4fEI4y3Jk0hJDXg+ +ZrJUO93hIBfNewdTmghbKTODmQERgZTZLmdiAhvx+ROcbg2hGk8VaA1TaoAKRZatJJXCYxgaoMAX +4wBMhCPfsEzKPG4HDXch3s5aMdaYdcRGMtWsCCSIFPQYZE2YvXmGTwqehymwJYsWsA4OYyEzDhGA +wdkEH6uwEbR9iJMJwmOthbAKGCawFmQ5sfxCsAV0h6pgGismyAR+6RyFChYYEhnMv2i2AQbjCEie +YlAZUTnCLAD3FLe3b4TGmmqHFntklRKvsp2tkTF92i7Yaqz8RwGg3XWAsFJFX6CT70Z5oBvBQ7E7 +IxpT2DmSXY+R2DmOSjpodWe1vbMc7yzZN7pMV/MuvKiz5GpXzTsLs53FW0eJt0WJB6YoRrtoCNxi +RSB0mCJlTW2doYyDXQUC2TRJ1ACkAr7gRcpuy0z6bOTUIaLIwE5JbnaV9042fx7p1mfR2YvRpauh +W++Do0Hi8wglZDCCxTFWNMeMCSI6KikrJvFFp+oCXpwsEaVtrEvrpOrMLnd0Jnwe6dq/4Oxx6Ggn +aLF5ZmV6sF6yYVw/SkEQo3Upv7fuotSGSSS7HZFcKwkkBmwkDwoVXpCBbTFSLWoClFlFyLYzxE+F +QBeaESIOO/OoemxXUR2dC1T97+xvcPZAdBTtG90L+zer/58xdSlSTocaElRWxrarvximy6Ql1mVV +CKGGnby0WNkE2zQR4+l2Jg4LvBIGI0/wuWWqPMKNTWaBVRvB4eHsK4XKOxLjoqbbKTyDOlrxAhS4 +YrJQsu08i7QdE0K1LfhWxcCKp4y3Ru2mMCYrdoebzDCUJGqslGxJWLDCS1DFGEdIQalrxvbBqsDC +I+rnoPq2arcl4lNRfvKyZYOe3eYMXtTurDM0ibWSSqxQ6KCZOkM6OePknoPHLZxAW+ZINjTbPtpV +a8oDEK6jlCvG+0wMUQdZnQM7S6h8LrHQnnyVSjUHSbDnWGHghUYk+1YmKwJZl+0rEgqXxXozSOG1 +tvdzzMqdhGYo2ZrdhXGZyAbZZuZasTPZwA4q8vDkNYGeZ9R8o2E+Fc2cZvsEXVRYlxZhuOsjooqo +kGWvWW8K2K22L8Goh4kza3jW7HYShPoqmxqUV2qaaAsjybx9IebVnBxtjXThu3NuOg== + + + J7BFZVwEzMwEqwprgMFmI9tQ2y3U1BtAIxrruMPUAHETgw0mHZ2dN59HuvTnOHt4HJ0wJNVmG9fZ +ttVsF43Rn9CVHPN5Jz0Yjh6XY7S8LDNHHTSKSNiDNQYYZGMxV0Q1K9BdVthBKMJ6M2Ty61T9sX0q +ABgGc7oLWRdRdEjrTZFudJF7BzPJN1jU/4uWiJAoBuC6wVCxxiCNo7WpNdKlAcrRItXZRtWimqzN +FZGhqctaNgWvmsbathjQw6o3dmE0qCROyQ7kOtl3R6f+55Eu7fyOhv/OpqPWiLMzydm81KXF6WDE +McEkE9clwCkhjgu1Rrp0VHXpuurszWp07eDqbGn5PNK188XRHdPZQsO40tEX5Owd6tZhZNrIBsZk +E6vvMCIjDqYRgwEUCxOXlwOEYmAyTbqSHbQZqJhUEtE0qspQwsmi9Ptlf4dBSVdqBMZsF+M5SzBj +6pJdoYsi3kmHq2JZlBCXKaFAwqLSOgeYP8IH1wYUJomsDwTvQdUKmhgcU2myDFYCpREMHWHE7h81 +bBckssmwgSK7ODYOUT4ZR6huhe2STL0NuyR4OXl0HosXfnb6yIZ0TLFTChyy0hrp2rPW2dfmaG9i +3qyjB8rZJtXRS8VMD5arOawYM4XHmArDanYI9dAgZ69ZUBlbeeEO6MGxh4kCK8xuq3be5QnpIbBT +o9SMYjLThhl7KtFQ8s6wgaN8GXdiNt2inARVBFgvASsEqZLEkp435eWuWg8pKsOWFctkTRwWBdPA +cBYwo8ggolWoCo1lE5QrFX9U2tNj2IUlxMgik1jK8eAAFbWYKlPOE4ZUargDt2KiO8ALk38yaAEc +XlanYIidRHKnsOfDG5GJwnUvsk6xuEK9Z+1aN+uXpq4gLIfbXpvidKqYk5PtmC5mDG/OqGPOO+WC +taWKYKCxu4w8Frapst/t9gmUP5RaXaCCEes/BEdPIywW6OyuY07uZgOeo0Ovo4uPPX+7oqcxV43e +QKSsk32jmzNt+zdWcWhfiJC0QT2EKrZaa2RbLXLaIA/MZxt2WwJgXVpyRByXNITwGBCRO8XyF6I8 +hVWTHOLArFynyDiE6qbgNboIZwdVDKqacLDW7gBELyFRByCrjnS2BDJrc71n0NFS2NH+xixNR4uc +o4muo9GuRY12mt2/YLc2WQKVWxG7i4bd+2ywdj1qoGqQd6enwVYqk9J+MrYTYU8CQZAnDN6I1ObB +WlFNu7sGcBMtv0MARcizXVUh4Mh0RGMtISgJBj7KZetop2jcTazXrefP0Q3X0VX2eaSz78zRl9bZ +kUVhF+Jv6nRiC+l0O4ECAywjo9viaDInzLgoUhoP7YmdZdYow2MwhUfETSVYvZ1YxKjOQi+p2wBW +t9dEgrKjTcIBhdKAGiuns5iCHCtcXCK3rlN3C8o4dkbJzgmmyKtDCDqlpEOOmBoQFXbWmzLOEpNp ++5SOZkrWitfRcOloyeyYwjtxcwCzKctk2MbsmJbwUOhkXCV/TKrmY6WeONZt8m5Or2P+O2WEBEuj +cNq0AyuSNMz0XEYKnU2FZBw7Gg8drYkd3Yts+pjxMNmicdQU8hvYKMzmRmQTTAUIyQbzTMrRDVE7 +PJYKMTTEmAWNFKX/AJgi0pJINJFT1FKD3coEo6johwJpXvaPEMcxLQ3ixgAjDoDh5bDdjQBR55yQ +R1JsA4/5TJEBEsxnqNRSx1Y7U6xLvwNg00zn3SkL1/GEDho66WQpOMqI04JSlakMFRhkWWBQFVwC +AXLsn7HsAJxVHHCFrqQ5mh8pp97RH+nooOzaZGnbnnZ0zxKGqFtEcieb7iLgwSY1AvcA/MmvYUkQ +wYaM/ZYsrkbxZb9LtIge2xhIuSy7h4bqHuBU4IFxjDVCoJmWLXYUYeYubZyOTk9HL2hnv2jrKvuP +GmGxNghW/JPt3jW8LIOK8A0rnYjkXUSmNQZ15+jMLmCXoYk9dSJLPqjMb1N01R4QKSLlHLy6Cyvo +aHIFwdMwg962VriWhbUyM8yL024Aqch3wG+MGwpLYlssg4iEETMsBsAchLZGujGjk103OYqlXpYk +oP5t3HzBLpxjaUxTGI7EJ8ZVkxatklQF1niFpVTU544O3c8jzg7eGw2+P9Mbe6twx9kca9mmDUGr +SRaCYC9iXNQek9UyGWcpmNdRNlTq4KZ+ZM3GrAhmsdah2nVA/bK7SrVrd+ByKBmp2BlM9CKy0a3N +uKMPubNNubORuQVUyG3WG7QgH2YNO8kINEumo4G3NdKtxbezBfh6k3DD0UbcycvPd6Bw2NJDPGcp +7+PLZg+tzTmWfdVp25Ruk9M5fZ3T2ykA2B/I2hUlypTQiiJq/ZNwUZskOVqZWyOdzc6dvdA3e6Vb +2MBnkvYa1NPO2gBFajdSFLb9A6IOWmdBmkRVSuo+AsY6GoypI/BmC3Jni3JHEzOJBwXNpu0XEe/j +vyh6dhRGxkBH6yGjlzGZemtoDEQEfayLg9Actg8gE1W766DROXF3saS3swsYhcfE7hAMh0UE8thd +hKlcrGciFmi3Dap2Oq8xcm3EYtKjUt2pTWgn4dhtd40vHTzrZGqLGvpQtsx2G7Fst92LBI9o1S5O +kqEzp43WGvM7up0f6ehT/jziaGS+2ebc0QbdcDDpTrrw0exRa4VmJyWOseuI9TrAkN3Yw7r1sAKD +jrRLU1dn35ejMczRPNYC82D3QkoUPnJauwGKCjOSQg3drBkF16ZRVUGzxYUuw6xQRzMT+sqOhqfO +jqguTVMya3yhAJasF9BMHc9YUqLajINR5GRxW6vcxYjEzWKHDaAyEYwAGHVLI7yoGwikMRGmwWNS +vhmCJRGUBUs4gAJwehXwO7olQ5BjUMONdHPicKTTXEsdk/2zOxgpJqW9cd2vaXHt5n2RwmrTdDaD +t0acHeNdmso7WnzxrI42YEejsKOZuIVtpyytrtjpZtWuOuGA3c3Y0YeJJzl6NR3dnB0tkNQTd7NN +0tFI6ZBplIlOsXfoRYdI4Dk6JcyovxfRKQyQDPK2mXB0+eE5NxsBHZ2C3doJuzUdOhsTO1rDWiNd +GsicTWadjWjUv2bX1OwhGrAZyLZCuNlkRKd09iE5e5U6+2dYlMMkSbPryxSDUi1Zo15srUvLCwXN +nY0xzuYZR4sNa2uiBBnuzmGxdhhJtCvVLKXi6I+gs5xNFM5Gi45KOeuP6Kind6u536wHUkbFUTXs +Wlu8WYG089TIO4SKVHgybLHDohrhEmcxzi7iOUt2zrKes/jnqBA6aog360bsZsRn2U7W0jNSqYmK +xI4iCTuls5DSWWm5WYyhc4AQg1qmUXTpGIq1lfYy9s7aAM1XR/2gS4XhZqqZTmL2UbMVC3wKLTXR +bBzcmSWlUzoSqZ2Z1o50Hgl8R8avS07wZo6KtMuiTLlhr0+l/BRaAYMWjWnO5IzdIHkjgdOZ4enI +AWE6z7kW9+ZiXcdC1tZIZ57kaKRrLqUj3+JIyqBtlJnhxCG0Spcx+7WBm7kBDNpvpg860wsdITaa +bcf61I71qzdDT/RCN4PTzuC1M4JCiHQzxuoIwTqQfougP4o7CyM1rt1brNpFyk6U3Rpx4vBOnH4T +pBJAuLHir3NFYLc1g52rCjtXHd5YlkjLZgg8gECw9WLXBhSjy86LdIpjd8bO7Rtv4iPs4M1tt3cm +lbj6R/gZYRwEM3BxHaI44IBOIY8EIE0DQcElKhatsLSA4wA3NRxjvSoKeBQVG+HAu1I4dS3kxuCI +YFgnIpcQh1+hOxY7sRyVZPsRXItjUfcyiqBMi2ww302dABbVfXExF2mixhIKuMSFpWk1XO1KDeCK +3XarUwEKd4dsL6sy7Lonbpanm2hOzfbGrZe9NHAMRbNNynhi+Qk5qpEyNalPXabKgiUB0KVNYEEr +0CAbdiajSUl16oRqOxwaMlTUHZ0t/8MhEG0To2Ms/WJfTXPkshlVtZdiNq/ssmLHzDRk2j4BO5YV +NqRTFN9mJTuKrKZI8mzaZ9pwBBcyoPrQY+isP1cW2HpbGmM/4h54bDEI0sSKWO1d8Ih0hhupq0uU +GH/Yijoy2jrxGhueWJqfwI9E03bFXDxSRSOBsyJRny2iHdp9BqcOfLfCrsem4LIvQbXnEGXAxrj4 +uGiEUUxYRpvAmUEM1+2lnZg8JuBLC71YN5dILpgYgjOkKxTTyPYy3k5BxfgV9Unkdt6O6Fwmy+08 +tXf8Be5iwAFYHs5G/QHnD8JjoHVTDFJsCIjAfgIS0ABBmzQ/EogXeB7ThiLm9RQVbQqp30hUKpSc +uHkMLW5jxWKJlb2OLwfQ06F0gKiqiIh1Wz6vJqE9QmjWoGzB5UEgunRM+yqXA/Z9yEOzEXR+Cm2T +Z18EMSKD+Ffz3R5Cx8Ke53Ko/cDt63RQxJYiQMQMVhd4COzQaamug+ngG8ClyWCWTIVcJzL1ekKA +FusaVxxFRtKMX0vviLq9No0tyWwztT2g2GYXd6jCsFlt9yFcUqpeNdjiRpsK5UjsgxTbDrSvcjlw +xdT2CE8JDoaT2VV4yV7efY2r7SH07+yBLofaT3x5oQ6aWiy+/3jn4sva2XATUoaFaH8PsvtoQyh6 +aV4dhhUlZjch/mDA8GpIt2HytRMvj7q8frPLPVG3FcpqY8KtvYgO0Tb61LbxaV4eg7xUaQNk1S5V +Xo1oNkC4Oqt9jHq53qvzXiw3BgeZJC4SdUIdo72UWQyu0HZICvks+zCZ1UbQgIrUVnxtQLt2Qvvr +9mWbzjvh7TF0ltjCLmrSsXS2bVnbA2C4duki20diqteUdHvdIMsEXB+jYEK6fvLVcZd3aXa9Nz2T +3DYN1BxPu2jgailqJCRsj6ivee04TD+yVbB4T3tfwmtDrDhy/dT2Ye07NLvctcnWvWh29xn4a1Vi +y14sZsokO5HTvHaYbHcFkBvVZdLlG2OSYenWjXMvj7Nv0XTe1X4UhbbPkG0y6FHYAhhspxQJEV0e +hZuX2rBFpXUIyvUhxWbntRPbR8lXXOq8o/0YbH/rdraJOtQUE9ME8pW0tI+S2MyyISwUSteHVDuc +uHEiO6p9+abzjvQYWC1kiWm2VJH6RyyioN153rw6SrG74Yl0jXY7uDFEqa9r57UPal+96bwhPYVE +W5vSEmGq5ZDusLxfO0fYvDqqnQwg2Vc7x0TywvRkl2deHta+QdN5T2ZGaI9aiQpjtFstlv5FWWLb +q0is17h5dRxPBVBGh9ReOXdjzLBYZHF5bvuwy1s0u9y2SVs3sdyNYusglrXb4RVTneblMSiADNkp +Nja+PsLKFFdntY9RLrW7817s/jJ7UQBmpikipsI6A6uSvVK0eXWYbK+XwetLsr05xtWQ1rZm7RMv +j7q8frPLPRlytGzIuD2S3C3Wz85vvKwluVuG/y+PuXqRBnsFRpeXYiwdHV0cH57sne+/5dbP9k7e +7Xd7P8b14G/959+XIYk3X5iB7S/YDYAeUrTfKdEeA/hMC2XxX4xR2Dhcyv6B9evRIg== + + + PHuE7zyVd16f9UixwfbpVz+0vxKvfqTY3mQrVuwhxwW63WbmDfAjs32CLy95y70723t7uH9yzqly +lhhjIY8Yl9p/z7wjhbz+keg9DxIYQtkkn2Lf4toH+8IAdrIHANQqYW6b2zl2XAtMr9HftVQMgsDD +zrS6PBjuNAGYF4JAzKP2+XgzxxjgCDIARgAmmBGwMN/Y61VMTO3o7XvPOGnFjJkGKgHmVgcA1vN1 +DdQzQwPpkeRu1+2fhxZmIE0EYRL4wRmGhmdmfoeSL4mu5NuSj/klLNFR9u3rhR5dkA7IUZZ0pXch +t3ApsA7uTVSN31jIKQ6+8gS/P5k3mcjzvco83xZ6/pdZr1sgTBDpA+t19jBdxZ5vT2Svl5NkBUtC +Jgk+ZcpkGQC5jLFE349EIopZMw2gC1xE7+cauKJLhX8MyRZS+6024C8srQ/+gEk3ZA0QpWmJandX +QWtcVVGSLdSLPi6N0bXaPq2rIvU9AZdm4lKHrkOs3IWdSrF1SqL/sA33JuBiS7V1XbW3t8C0Npbi +2q8cuf7tjV94jdUzMQ908wtb1llMTVtGXX2JJ1HAe/nb1c3YgVR3x4uKnQNsNcTPn8D/wp34X3xE +/mcp43+JH53ca4zMs76US4ugsnz98aVFaj/pja87f/3FYx2PfuNr28DJYpcr0ZEabQ9EFbnOgYZt +0Gzm3vzyl27zy0/4S8Rdv2EHJQ4mNpx8bbKCEqXABf26WN/IiF9VmrhN6veSNAUXk0IYK9NiU1Uz +VBEXDehgTmizRFOWRck0VFnTJcXuy3Mkaa//TtGofL36JJncTv2muskY13Cr99m7fYLZaIdvnfOQ +3O1G+NXol0lP7n4d8XBev+Qnd7+OAcndE/Tv9ZPTk1+KrdtvNIUoWtnYOz/fPzuZ+/Hj6dn5Y/tt +mMldkSvOnJ4e3TzmBF/3vXBx+Ja9e7T/IH3j7LS1/+kTt7nfOocQ/ejnY3Sx7xidXvQAGmFZGm7w +KdOWjaqkYsgG6FNT7PdAmqKoKrgoBxfZOI5hy2D1m1cBeyyqoqyDxVGt7oeArb+6SGPEeQzfeVDz +Zw7qcrMbT8x3e+SbhDsOaYzQMSIM4QZcbGFuxzFNOgYvAvEoLvt1HEGPq3Vc4+bjdj2kgzeOY5yc +6XaI40bXn7XLo94k18mRL8tL82dDxD4jRDTpRJ+s0P6XKu4WIpmWSU2nrEBz8yTctAC0+7p4IOhS +sOmEvjclrRuWlnAxkAmUa7hugJaefe3NVAuXMeAkmOLPhpgyLjNSdQj6sEvzV6OsnXdRwDNqpmFJ +qmxo1ldfHUJS9LK6aMEz07Wx5wzCQFXBZaVY5PwrLq1jF4RuAJd+Brj/alNiYf+BYimSpOJmhFfg +27V9ru27Jdsnu8avbfw6WPYr2r7f7F7mLZioaw/akWPTrkE512S5Jus3MFntlNPM++7Izcpey0ld +GS+QTTRfuBTexNcXGCa23rGonvaTkrCP2VLh+XDZE+gRagPoCwTo8ChtxeqeT3ZF3RX124pM9L4z ++Z3+me/N9MOhtFOHKLLWLYfp7+qgeYej+drbSfh2TPDQGu4lbKrdXTRuHmko+Ew6zAY18/5K1P1s +hl7VdDxKg8ubf8XtTFwP1b6f9TO3+9WY6cAgP5vWFwwwkKpJvaEWbamn4SoGQ9ZMSaUdn5k5VaQb +/fCY5+xoK8VuuGv9kLLuKBDYqnKZ/MYlRIpl1wquf3nzu2Zbgf5/9t6EQY7iSBv+/oD+Q3vX2NKC +RpVXZRX4QAfCgGS0CDBe7OVtzbSkNjPT4+4ZsPzrv3ieyMzKqu45hAHBWj5gJiYrz8i4MyJbai/5 +883p3y8Y90Gysk+b4EVHmdqO/qu/J+ra9m3tH6gasBBmN/rc84VLDijc+nM1QaUe1d93LX7852nn +9dS2Zzbe1+qPd6dHMloz+63cAaM/c0rDh/WEJn8arbT+265DHP1x0mk38nJMZ3Pe2d696OArh0Am +vdvugM+mBs2pkRp2T5hf78FOy8HSwmmtzieQQA9q0M0Blj/cARogxVQ8MzH8JM3FnyyfPFkdX2Yj +hlvlFb7Fvr3bRI1EobNvZ35ipCYdZNUlOFCjlm/slPEKCC+u8SowHWjHiD88StOsucgx4Jn8AL7g +2OoDe7oBLOJ6GbOHqo4ieFg84kGmebydD8ye4ZDaNBWsV9kDT/hcKrCAcFMAPB9BNZqiZp/12GyH +2EuFOLwsaJnkj89zLVNvIxEGUl/hQYNHIu3IexQbelIsguSRVAqBiMh2goICSOMlkhK9PZYPnFhe +UlMqNAEZGQ3jG/noVZOZcdc6r29y9dkrQAiaxbshlCRjjg/fWU3yjTQpkOrTw0vmag2MjWHSYQQy +xK5htUWNgsS22VYrBqY0+W64cyljAeqnOoRoamglAcwT1jBxqo85ubTRtx7pRbPDy8ROc6Inghrx +UCDlSWj1EaoF60+1NZC7hz4gZ23KkoZH8LI0fQjFnHbw/9Ez55zNSfijvhUPyBuhyOa4jxPsg89s +552//tGN2a3Hp+vl8bPZ9cfP5yeLO4eL4wO52s+HW3/99oMHO5s9nJ/uP/90dWfxdLXObe+c2+EH +91ITvGTGgVct79y5vb9/dvTJ6nSO6VV0xOyJiM0iH+k52hFfMrFmq4BEzOhYD68xWoWAST97ZHdJ +OSZSBgQkdgpWE4brTUIRCuaYQBKXPiK8SPZaawKnR79AiS6liEctOFbzbdGLIBiDp5EeswOTxJNT +ltRAtsGOwdRaXMQis7lmFAJJmlk+THNMOtMyzYJl/RkWakW5FaaOMYFFmxm3j4RDqFeCmlmeT7KR +pB+bwlxETJDkGhGVcUmiZuTc65FvGAAmfdOX0jL1CJAWvkAsiHfMfsP6r8jfx6dtSJODGsZ6kUQV +Zko/reWAXSMdQHIto4EkMRX/iiFdI2kamQcoNOkasVshanwFzZSiTAiLt822TbfIOc1WF1BwTXru +WWSE10LuDMZCYkeGMOO9NN//QDb29NFavGgwWjRAOLeWtjF90PQl3qZbFEPKDyCXn6AOtQ00+wDJ +FZBKTpYvvsaIh0uEPFOOlFTf7As2dgiLhqLpNGkOXlVqSWFkJfJJ9XNWC9YI1uAAWTlJKyMwKQqQ +wuNFvkHdOZBbpKNPmXZFQwiKjEKNrGYbxwtwgy3WJ1IN9wybaCKeK2iKLhbOEyKJhCr61Jg4DuKJ +l8EduEmP7GbEYj5/Nkh44FkFOQYmezTBskI1U6fhWTBwBScg+gczdzSs5UIm1uIiBFQLAJqhgB43 +lhmInRYs1ayGooQQoqkt8gEBwfVU8PTKM2On8Ckls8zAwBSFvTGKDQ5MjamcjKKi0G86zHtNJ++4 +MSAPnWIEbq+h2aZLeQ6R4j7wPmvQ+j5Ta2tmCxaNYPWiDiWHNA+vcCzDa6Bpm6Ge9k4JumG3zLms +tVRoV0ioyHfMuISaDsLwEGPKcaGYh75Cp9kXVWJ1hvlVZ1toB1xE6UIbFfFESwtaYNRE1rpkXl/D +7GytUdQ3OWWv0RLm1nK9SFrb+BTUgOcUltXCNPkOwx1wE5vQDusRXETG4pRN1qasZwEvZRuinhLG +JuijP6s5XnBQoMVtSsSMYLTQk8y1yMZqUYkHFrF+Dw/xgI2NsnFB0wZvvFiawbFSaINE2Ex2Qgww +SnxsInvcyZbhbaotKCHsNUsJ34s5LcCQSjFYPPLp+RyLAkU0UYdRguL7qHUpXaqeALtgy9Sd1Ntv +cs8c7wmFExyA6TzvPh/1KzaaNjAtdJPoolYpabR4j1ZcMKbVWlVdehqJbUspk12Lv2HfbF8JEyCC +IuNq9mYmSdqn/qeFgGA9wKtDWZZtbaJLxmnRHzmIhI08Rb7ENIns4mowLWCTEqWgVAbz903wDsgI +B4HBGy4HS0R0WkW7d5G3h6U5WM+jlH/qNduoFpFBYQxmmdVsi7rpfL5uWdDVp6uHuOIeL9dI1QML +mxIZrUlPopk6gQXF+N6r0ZS1EZmC8PBPE8BqQdEWORqQB5g8WXihLxVCUQsDj0mN1rcjUxf6ydrp +zEDXIcFQRxTB630kDhEeT6HUB6YuMMiaEZkekNmsrabtASJqPVakMujlXLBh+LdyW8uAZ8jrUTOm +C/Z6oJU3ziQRMSWWtum5LZK4OmbPS6XCkBlEBG4WYuqUGLSuHfJIKy6Kloh3RPrMi8jIgNBU9o+V +vTp9Em3wqiyhovSoudNT0RBe5lTjqw1aRsRBywI5FJHIJ+aOJ8oUwylGwdbOF4E3mWjPaxafGNuU +5R7v3/g8W7eIFeJoT8Dtiir49cxZNcE6oCITELLUghBB5xn4hjR+GNfi4AzV48hXiH4vBSL2nW5v +SiyjlcVVhxIS1JMha4pqi/B2GRCCFzLHpBRWjs/D9Mkoa1qxSHngey617kalMznhEdMWtoaikmHG +LWAXyDf4FFRFGDesLNOmpKT8IiKpL/adaTxaS6wVrNGUN61mKI2KtqqaaXlcTeeObEdI7AwCzlwD +LHtjSeRbTXR5M8lytksZkpA7T7MF55JfrWG+S1SN4AeBz26Zji+S+qHgjicv9i6fT9fxwjE5qqIg +cyjnoqUm5fZjyiQTVJoXlNKaVExbosm9o1eJXLkIWXEfuyRWkjnjJlBItyi4Y9J3InxEYqws3Kn4 +y1exhklFNPtzUAIVswJwE+Ylvr1g91bzzllrFAmblO6yxjagICS+jmpmn2v6GaYFSjHYzCOK1Ay+ +T6zY8U6LnKy10KJR8S0gUYsqgiw8hEFikxwskHZck9SakIRCIiIyytPMAZEGzBA6SyraRL1DEyMw ++TWRykDi7VNKCrmlBglRBP24UhQJAFEmJ2mtzst0hi8zmIEHWpZRzFNERrSMlvvNMh+LgydJwaf0 +ZRr7CJmm6VOx0IDHvH3m52QVWIxlyivdG9WRIMD2io5MPYXMnH3C33YvpVvVHGa9ZpnHnWeBI7J+ +lshAWreEi0FtRTYlScMsITgjzVfXJoIouMyYzqbpXBpIk673mpqABM70qcAUeKuyZCb4t04LTKX7 +EkIKx++YbkoW3KSai6l2odD9VmXWRi0GLMGpScBRmc9rNr5WGXHXaTGBMdoRFy3UO5WPA4L5j64x +hTHfPyAnuGVRgqgSHl57OquZwdOZQAFWWuW1coFB9ieV3lvWdtDcJLgPTZMLdDIPm2O2M1xxi3Ke +EG9Cx5QvTP1imHWIWX2YJ5uIFW1LsQm+VqS8RmZkyzQmZOxCVqKy4TZJrzIWlfeg1c071yvLp6CM +CYAo8BL4lJ9CX4FTZNUCRJ76gWNpHyXympoHGoWKRdgyyIQWufOjaqUd0vZgAqySSVtTyyy3sesy +0YmyMuSEJdfBQbGGbpdKnVOe750tyaMVF3O1Lt+pGQmMxGnqr6BveFOeW9a+a/NNKWUzZTGeCCfI +pZy4tZ1KnByeNNOm75zqREAPVlBgFTxWA2IWXfp3QVtMUpes1cLHJvQJP/EIAumAHQ== + + + Y6O5i6qHjfGOyAjSElSlYiZ0QcZeZRxMShPVu4x7SN+odpBkqYG9UrERWfHaZMQQtkGrBnkFUgHh +cqnAz6QCQTERRs1kyWM6faZq0/xlOCjHXGhaM1X5f9SEv0grChYsbF6zsjMVMTMO98QHETLVVNvz +dSeye8eBGXeaWBpKhlZWSXyO8k0AJcEWss5TnyrUgkA5q7lOKbvbdHAqSyG7C65AZ5PwnO2vqQpV +yAbYnqmtFXsdFKeYC/PirkKRjbn8ntPKvjObKpgqImpuFdT4jDYpuzHlNjLE+ZY2bK0j6mMWBliU +iGJDy4NlsSvVU0wbkv2GairMmrY8HSBBl/0jDIJnscPKjdWU+6msKg0WnhqfdU2v7BkvZZFcWsbS +uwYf7WwL5YCHyTKaHJaQRI+uqWG+1SxNUbV0GDU0F2hKK6OmebUI0qmqKzZN22fmlG3zvZqd9S7T +zKzcP6dVVOu8EgFmJ1fzfDY0a14mketip1vfaTVOGujTaTAJDS30umBW7qSJ3qmNmwVQqEhzXjTZ +K3UPWZqFu5w2+o7l9gzziFLjgZpHezs3iFb6Lg5FbocttFoZhLes80zzFXiPaEqJMNBarYzQqhDU +lzSEpJodpUmmiVMDvaOfgyyNxm1KGqhVgi+Y8bgntYaRG9Z5r6ZZPlqjcZ4VfbO5fl8rXtiGslAk +x6Vp3lH4SEUatXINB3JZgw6yjJka6rNZPihls5BU1SoPc7Oml9frKXI2VqxpwpJNHmp/qoK5hXnn +G+cvsbvffnq6WCeb+tXs+Jfb5qGmiqLbXck2n72cJj2onX277Qf9XrI+fLpeHs0eztdfb2Z/uf7t +8vT5rL/5+HC5v/jLjW23YXqKddWcD00z61k7RUs5Vb8+0F/5jwfXJj8OjY5TOrQo7MaKZif/9sI3 +6ZzsjSi3wnPkHtLP2Ip6JzQGRWL6wDyGIjjLvRZygZy5Jk/6+pefyPo3p2tu+V9vcJO/+Oe1mxQ9 +mJvrphas75BRU70WDX5UFW34kRn/kB9F6BcmCA+j65lKTKQ3YdQQJGxIz81EkmllXqIYibrMso1I +Sd7DPYmXePHc6e2ZNEEtqsoJ5vHHs2KD6scyQahRSK7VybXWZH6iaDtcMNSq73TKIp/LVEQqE8mm +1byPDvWNgqyjt5r+bPcEbZogX1vpBPP441mxQfXjMEGm1xZBPyJHtabWd6LzybCxb5lCDHuHJJPC +W8GMtPSIsHtRRAwl7HOn59L0qGro9PLo4zmxQfVjmR6S7gj/wEsKpIJjIK7BZQY7dpq/LKA4IGbj +4V0g7cZLY5kkCnwzXue8Cfo0QWfKBPP441k5M/5xmKDMJgi+C5L5hinv5cC9l8mIbGORY3YXRGZs +kSkqNI23+k5y9wRDmqAZrogbrkg1K9OPfywTFCHMIKIPLv/I9G6i0CNNKBK8toqTcuCmQ3gBMpgx +mgCcDPpOROTZ+Rd4r81XuEzPDBekmlMc/VQm50QTsghsEH3Gs4CL9b5hsEsT21YhAWq4yFZGy5Y2 +588m6myGyzDchTKBUP9QJiIkTWhcgOG7gcgIA1ljRGJHpk5RTxg+EWRCInuICK5Vf8+fSKcTMWVb +CtaX4U0c/VRmIjsiew+DkuyMmqpF9BYxUJqwsgIhEfaBXmRz1ui7YCa9zsQW/DFlT4YZ2H70U56L +phSUre87kdPklEIguhiPlDJMjedCCYxHnu46Ts5oDtxRUAprDTrEeGpWLdoZDHEFPwpFPUwNqh/7 +lA2L0TI/PEP6H9xq4frfcaKbKo/Aj8VBDacLYwyrZXeBOVM5cetSfUAAVd8FiNY/gLy+IEctGpc+ +1UIECqStHcA2f2kTgLW/AKGltYDSh4FlAsbtEB6jfbUJQpUqzyJ/SWMAZ2vTmNoo9F07+t2nkqwF +4kP6wEOd6sKey4ujqNvBS9WWKXr6JwFM9hGAWgWZbvgyg/phWwaguhU4ba9jqg4JiElbwMiEPFGq +wIiQ1ahzblXUdppwVbeU9UUTKJ9FiHbSjnnWOYQG1AADmHIfqzK+fBoZfACgp4gPEDU/gNomZlCn ++2hzIVUAUTmHe+nzcdASRFDfewV1IeETrd/pUxZHBIyWUULyltO8ICC/B1tBgfBD5E4O02Y8SfZP +VRLVpKPRNVElSV8GpDjV1Sva+eT+xLYF1oIdQJ5VSfOnBdiGPARyOBCUIpk8kwwTkqK/0tysfmlb +m0bQIg4AaZa57OwtoPQp8yPW7ZAn2+oQeQnYyATR5Oy6463RuWlNB4JoM+A8XD7SQKz0e7lgI4EM +0MMimnwTtXwBQBqrR3RrE0iNEgqk7wTArs+XsWt0XVowgCAooQVUMN/baTvWI0ZvrBquNyttnMvJ +F1w+aZ8j2ACigxogtwVpYtmkAkylmdlZ3t5g+zymTydju4EMmTZtJkmqXlSvn5pC07TiRKdWnbJJ +fdpfptnULW9Tb0npxmkx8zZA2aGIk2ZID1/o2IS/+lPHzDwJL+laLaCMhYaoVLcL6WRYbUiRnEVJ +RkuFAywhiVYmNbSoRD2G5KqsQbTfpk8TMNCwnTpzSgc1maIO6vPl7ct0IZormVd3nE0nR1Dv/Jg6 +tL3zw51xftQMFZ2sDtoWuk2/tDKgpmB+59rUjrSUJxNzb85n+jZiojn5PkrftFEwW5Qib6lZ9sih +LLJRj+eWKpg1PrYNnhPgbpnZznJXM8ZGjgoXFrmIFchGMgbr38YiY1Q/5kJcr0QueumJvkK5yCf+ +GK2e7VGNDXg+goDdwwRkiCXflJSbymI5Md92ZYEQAACy/UBXSXajyxWaSWrhOwJIQ2EoesUKVAiV +6wdgmoqnP230sQZMcAiX6K8yYU6lK1NB2YI05Uz46DbkumI/gYS+UMwCs5lns2QyQU2ig8iYSghL +k+UVwB9AYMwCEMUxQDS+kQS/rUCZ0iJspgDz2skH5MDoRc7AdhvEqKMM1AlrrSCUJM/yoDpxACq8 +12l1cwAZcq4gclCAMmMcINVBF2Cj3iLN6KaDavQyQS5BgiusQZ1RALrO5FNIfXEbdE3BDaCMXP0A +yqhKg/jo0w5iybh/xkrrPEw3iGZRYW3IJNTGBFJXcQ2q1z4A25Clk7RDdIfokDadVGPLdqsveHQs +6a7Vh8do3gLKaydBnpy8SjHRqbP+MPGGNAaZSoaZhDchhsxAGZMBkGadt3RC6mZSQs+shocJoFHd +w6cISYKaxCyNT8slKH3KsmbjdtZM+rK6BFt8Zyo69pOp0c2sC2jTAmDKHBaahd+Q6E+9I/pedLR3 +Xi/uFpCe1uo0IJe1IZ2ZL4J4ulxNJXqEggLKfv1w44zWNxyBbCU7Z2BGO/TWtCPkxKDGTHA4SysV +rnsNaa5vhNdgvvFl8uqHGl8nP2Dt8HG5JmUEETnaya326aEHL38WtBijzWVlpSND6tUXWJs2XB9/ +VDQJ6SHbKe3yGv9fX6Ysio2OLzGu+jL5Pa0LMzl7Fg0f02DUH2ziFpBRjzVVRzSzjyPSnzxyYxYh +QAbHDZykbPnAbmpQ4Uo1MDEvdJbYUuZwGLTPTLmSUFH7tuaYXp+TVGwVG5VWMPDkcnNqnuw1im/8 +sWr+FdvXnPIT8cAjDGgkRXhVlmtZwzMx/Nbyx9LLgyKQCmtuW9c28G7l2qrOdfAB9hHSlFc/1nad +7EHgbGOR45LExgjoUIS36sc2vkKB86Un+koNcXzR3CLWzMYsb6p8mIEK0kipphBYx+eACqqYZ9s1 ++unAZFvGDADUbkEqSbAAm67LSmvujM7i8aDUT4vVKE2OZXEVxAB0gGyXRQ4WMM2gjOtt3S7fHVu3 +VBCe3dRDaGH68Uz8nhbSrWbsk9pYrasCmer+D8A2f5k7y3vpWTZ7vOU+RaFXR+P12UJ9gLjC0Q2g +moVn2OEYJug3EFjKNS0e3ntTgBY8dAokzcpApVkUXwHKZI2sFIDYDpSTwjCAfebDSibb9ApjAqr4 +6wBMZozMNwXUmsyelPgDZItBQZ8nAkbJSClsmpxalJW9YOYZtD/ZEgLT6rWCyxSICpnjHlk/XUGZ +1uPldJregBOWFYm4jEzEWZFdF5s5zACqNmUAls1j6NR4i9X2MTmKlMZ1ODAVm0aHyrp/BVQYR7uN +JsYqKvKAs0jcZZQoDbOWOwWiJH09dDY9lemhrE7jJ4twWoG+XixAsRttSQ2qdY4CLJRI35nwILI9 +pidPbPlkq1I6uvHBVivIx+9S6NgIobKmPsIdGCg7vwWkZW7UoRYdHg2rOjnxadCJ8JRNV+FGKlyF +TjWo2pMBWPYudzZscBmzPogyt3xcvp+QCKfx9WNsqtZeYxOfLpM8wTA2BQ50bMLYiijSCyNFHYjO +5CKTfYvUGj0ej1nX6KtsD899g4QzrbdqLeuNgzPR93ibuV1kEo7Z6Sv2aWnKIsqEUCSEJAvgR++K +WFD9GMIrFGVeeqKv1HbW4jXyTd9XPkXUrY8KSy5Fnyt09cWl6Fk/XEHFpYiyWNDlAMy+HY25BSRm +pw0fvBVQ5sh8VzVu1+S5ZQ1Kjfl5GpmCokyRTtdmQZu6iu+LW7EGFc9iBfShfGkU4vI6+UIfkMG9 +mF1FACb3Iose62wHPXkA9cMWDcDkXsQQUVdgiuRBMz8gxb2YdREBZvcidq3RXWuKkqF+rQwq59L3 +k3Zt2tzsXfTJeIlFFe8iCvZaPazsXQSo18ll7yI4e5rv4F1EIGnUIbJ3MWudACXvot/TGnE4Az+4 +ATotEtcX9yJKhqQtz37D7PTLIH4aNOh93E6riHII9f7BW5EQenAwwuns+rQBioPwSxvtLTsYC6ir +HIwVMDsY2RshySmEMbmVXeVfTM+QAMz+xeTcJSj5DYOaRgoo2wn6cTOt26yg4iHt6MsDyFaCo9OJ +ZPciZFCIUpyGy2dKWRWg4l7MIpzvinvRJyUEIFucQnymBFAYpD/K/oAl76JPzxCwRU2+CoGqQgYV +xG+7STtVwtFbX/TyNm1b8S76fMxd8S5CCfe6Ic5tQYp3sQJm76Lf82V3Q/bfqSrE3e0qgtSndk0W +/fDwkyAzUDcK3gAV76JPb64F2BSxnM9ICCqOapYtJsi21ZVxOuHBu8gH8Td9LF7DkHSsDMpXhj7/ +UTsfc2/J6hWSD3201iAXOqa9S+7FkELwBZTdixVocC8WYJ/diyE5Un1f3IshyY68un2Zr1qnQPGT +iB+SzRSg5DesqEPtX2QdwLqdZwVnBRXCzdBvZUbNYGyiY4AML+Zb43NvLquRY4ZaF/cWBq+ynE14 +WrurlAqDalXuKqM73lfuKn1ByKVncRQBkgqqpNb0PrCv3FUNzXCcv+4an5BWIH6KTAB5d4tpzKaI +ktHHmS9m+dmywnmaST5mZOMI+bBM+jKzniw/V5BiGKtgyXyIrmKm9yaPGF3iE92wAJPIeDZZWshU +Ckl2TZt01gxKX6ranYF56VTPiffZpprTJUyAGhuQgQoKLlPkkEZWqWpEy2HqT4Qq2w== + + + hlFf0ynBTAbkGlJOugJmfxVAfaIPMR8WX3YTVEzbNp0cgMkEbpPo1xUzuc3cvhs5rJpCgAaPFV+/ +19/iFU7TjwZw+lpdJzJoStbkdsVlpc8Muazssiqg2mU1ALOljIVZASjWNNZj1x0frG4mk9rBZWUG +CpdVQm5XAaV94wvR8eG7FO1D0WZQO8k6KRaYwfXraLkHgUw+K7grvW5ydgy5QTAYfFaoptqmdibH +yykDJCjHenlEwhdQ1ikzRR/a4cnLpDc+GNZRXRk1SzLD5DQCkEto0xI0QU5eavqyy5JXvSmaa2ay +fTFmplkDiwhSDiQJqV1tVM08uHitYK4P6aqUoJE242f2WtWgCqMKcMA8JaIj/EQJ7i08Zm6gMb7H +gsflVmhUyuhG+aQNjK6U1yej9ce+uirFbcWMD+O77ZO4XjHwZKXkurLbKkNqt1WBZflOw90q0oQR +0x2rxVEmgqgvlOezzNH5wcVqqyNNn+ocR4cPC4W1E2LsB75WA03jw4i8w6vSxREP8IzwnvAKr9m4 +KpZS9ryv3FYDqPbbFGAxKprMnwa3lWHg7Ygl5iQXFetMFr+Kvfp0SiPeXK5OPwol4Zu6+uOUDWzM +/jVXxURMiJRkR+IE33OOhY5os+5cBZOMxZjBb9XgpYENIm1g52E9wjsDua2i5DZ8sd5HpkN0vWhq +eDHOTLBdJ5842/Yd7Un9kJEVqVphK2r62n7ESHVTJ3MdbEXeFRNMMrZorrlid6l+9O4V2opeeqKv +0FaU80e5thJcs1TsYiW4Ik4QVwLAYm7g20iABg9pZOoogCryI1wqtSsOVy3mDFC5HMwZVEBFZWNa +tDjy6aIg2+RjR+syhyixEJqdL46uqaN3mVPO15n5hXRh+dIPoIo4DMBCRDRyCaBMaRgc5OKIHjl9 +CRwrupXykcSKumncQwYVLdkOsLx66sRyZONYEBCbCdBBkM4whYCBAFLIuTMJAUZkv9cPK+5AWwJA +hYUUSM1oMjALrl4T9AESh7DRVuda8zbNJglg4YHCs1O7wildJBK2IzarIUgZWMIe+My1/rhjLNdo +CI1x4lQqPxqNGQCWeBbNlcV15aiXAhrFhxRgdl521KEBKc5LjbXglg/ey472tNHRpBtXnx8TQRRQ +NjCQ303OXo06Lo5iizTtkWtH4VZIW0tgFl3DHvPcEJSkw5CCeF1bia54kexTuyRshpR6h6AmGQ+M +CRUofcq30ZN2XcLhoTe1tnBUN5g2NPFNPTs1enENbVqDGnTyWrNJjx7t0a7gSXQz3T/YI5p+G8go +nupEgkjvCb+z7ArzXxvT+Q72GNUGiAcqvIbh6mXhtQbZypyYgRn5Qnr5XaEoRnXdBJUxO+NGKI83 +IDGMLgae4VgzuVUw5YTqqqUNKKg7fDzcljJEr0me6gsuQGtSf8X61CsVbIv0WoHqDRiAbdp19X1W +FErmQevziJAJMHb96FZlE9XoDBMfq2+VAMPW8WsWhRE5Dvr8fwtI+0JF32VcE/2IC2AqiaUO3CLs +aSXGgaeUTR8YTw0qDKoGJkYWUjRBxe6QTNFkDl3Z7TSV3sA+QwqxqphsSJFoIw5dbk/NoUN6KDL6 +WB0ilRAAvAuZQw+HrQFVlVCBrHOZQRezO43Gk/WPZZkHO8x0xlaHelRb1Sp8cCmtSIU1MA9YO8Eu +JCdNhGgw8PSZbBQDzwCpDDwFmH03VWdNq/tTDcpY12ymyZNrGNmmS0gErLLSmKZif0UziFW7omk0 +bvJxBwv/eIhykeqppBQnw5RdinOsFlaBRlHJBZgDt0tnQ3R3Zkx1ELg+XKvOJj+jGp1g9MZObnQy +eYyu9ACjRTPB+oS7RM+so2rmpAmQ5pEMJMiYhJjKP1RtTReON6CYBlxqVx7/qFoJnC4y1gAKQ7DS +AOxywLEaGkZSrSrLE+nXaC7cWkpWv+NIlm5oCBpd82FTaiW1RRLKLSD9RFWHeB3putHVd4lPj66+ +0xzo9dV3icVzsTkGZQCVTamBBaH0mWa1xfnp2+goXDK2VkeWLU3VwbpBniKoXKgJTiAaRG9nh9xo +2Yw4wpNiWs3MpAYyCH00sMoVo+kxrfJ0GTYR/2G1tjVxsicDqNq7AVjubBKecBJd7s1l4u8qIy+t +CKOTLUsYzj9lbh0jlLo4Rshjka3UbQGZhqvqEKb/wq4yrVRnBqfXFDIbm7wK9e5ky3eFTzWo7EkN +LIQ8d5Y3uBpzOIdqbvm84G2Y0AmbpZAanarV1yjhaAkCiYIXegqsadmIuxXjTWc7ES9kuc4hHAMh +md7KWnrUaXBNpwW/HfKy2Ni1npCmQQ0ExDjFjkkymJaltta4HXV3irHGDW/w3fAG3wwP76sf3atM +FvDSE/0JBPbYsB3YY8NWYI8NW4E9ts4VkAN7bJgG9tiwFdhjw47AnnG7Js9tHNhjw47AHhu2Ants +2ArssWFHYI8N08AeG6aBPdD++iFQRgN77JA3IAfs2LAV2GPDjsAeG7YCe2yYBvZQ0a0eIzCwx4at +wB4btgJ7bNgR2DNq16bNnQb2MLIkTAJ7bNgK7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK +7LFhR2DPqJ0G9tiwFdhjw47AHhu2Ants2ArssX5HYI8dMgekwB7rp4E91u8I7LF+K7DH+q3AngzK +lqF+3CwH9li/Fdhj68QBKbDH+q3AHuu3Anus3xHYUyxuikjELb8V2GP9dmCP9VuBPdZvBfZkUEH8 +tpu008CeYgkdjJjWbwf2WL8V2GP9NLDH+h2BPdZvBfZYvxXYY8dv6TWwx/qtwB6Iy7E8JGDojvU7 +Anus3wrssX4rsMf6HYE91m8F9li3Fdhj3Y7AnlE7dQNbvxXYM1prDuyxfiuwx/qtwB7rdwT22DAN +7LFhK7DHhh2BPTZsBfbYsBXYY8OOwB4btgJ7bNgK7LFhR2CPHRIH5MAeG7YCe2w4P7CHMpX1OywG +GXhzUMp5l8cWgxEVyEq+9VsWA+p17RSyZTGwOZfEqLOpxcD6HRYDACcWAyLl2GKQQSOLQQaOLAaj +j9ViMBpCLQaTqaiSX005WwKqhVWgbYvBsE9VZxOLwWjPs8WgOptsMRidoFoMMqi2GGTY4RhG3Kkt +BtmgNbIYTIEx88+JxcCGLYtBtpmNLAYATiwG4F4TiwHNclOLAYATiwFv5dhiANCWxYBC3NhiwKs1 +thhk0P54U7YtBlOgMqCwZTHgsGOLAac3tRhwGWOLARc7thiMNqUGTiwG1RZni8HoKLLFoDqybDGo +DjZbDDKoshiMcCJZDECytiwGk4Yq/E2BsY+TgZNIErYsBpNl0GIwWq1aAkZ7MoC2LAbc47HFgCcx +thhk1WRkMRidbFnC1GIwQSi1GIyQJ+vME2BMMu/UYlANm7V3Tm9iMSisbLAEVPhUg7YsBtXeDZ1N +LQajc6jmNrUYVKdqBw68bTGYoIQaB7J4OwVuWQwyrFgMInLidN70VpinR1RG65ldUuQi0ximpAzC +aJAYvkF9ociko4j9iCISolKOYR7IUSiH2w2ZFOotJgQzpKsxQ7qaKkVNraK/OgPCS07zlcZ6sGwf +MrUP5oOg5VYITPaDsKe6jSvmA4hHXfqymA9CotHGZfMBUldTHnD6ZlZB6hRMoPwlYxRH7TT6gZ0l +/5NK63kaWZgMLnWXzAchCfoogNBnr/EAKuaDCuhD+VLzxWbzQdJqARnMB1kTZK0jE3M7o6DBmTuA ++mGLBmAyH2AF1OJcNh+ElErIuMp8kL1lxhXzgVYgVVBxg4W0gMF6gLOyYdJM87obV8wHIQXbYFHF +fACgfpmtB8W+44r1IGiZJ4KK9SCkKHFWx8vnon5R44r1QEB9q70N1oOQnigD2MXsF847nq0CbX6B +7irrQfEU1e00RxCHUDbUKn/FPIrxoM002hXdu00v27FvyXhQQLYyHlTAbDxoy1vQbD1o9U0oMrQX +40ELayn3oRgPhliAYhVoU0S/sSM3dh919ysjQ6+3tbJ+KC8AqBgP4MXV+1SsByGlGNQSUulMY6N/ +rKwHISlHLKCR72R+Hl6sByE9zgeoWA9CEqQATOYDRF5ooEIxCwChu24AFcTXMJmqXeaBxXwQ9lIp +bTuYD0I6Z1usByEVmwLIbUGK9aACZusB+kq7m4wHGDHNq1aoU1VDW4wHYU8bmYEABqVKleUARFej +o4rlIKSiQKyzma9t1D2uDAe5rh+ATZ6ZpqBB4Y8kZrQ5OYOpDAdtvsJ1O1ZlZW/JcNAm29honSg2 +kfAjGw7avY6yA0qVJbWtAg2GgwJ02XDQJhsJ7l4yHLRZjHRKHdOX3qfbnQ0HbT4OVwwCFWEYDAey +JTTbVu0Qk9IpwWsLydZ0XGRDTcF6ta0ZVwwHIddqcMVwMGWl24YDn8JsjB0FVqZqnW4UWNnojrsq +dWOKlXPpCYkZDErjDDWska08sqjTWsSzzkHX6/vycQK7VLJ9nMBOZdjRxy2Fc1MnsNPEw2acwC49 +wq8T2BW2M7ypH0BV1PEALDnsUs3eKoddm+ts1Tns2i5xLLWAcV02kfshiZ3G5mdQXn9CwjqHHQvV +KO7X7xUyBa2AavozdSK0NpHGwcrQNr6i7lntTCp4ZbTIMWuDZWOA1LpuBg5J7BIHqnLYtU2j06iT +2LUmf1meMCSxr05Fl305o9jKJrRVuxKbnzjZEFtpEnZUsZUm71EdW6nPdkydK0xfD5k6o1gB1bGV +AzDHVqriaGwVW6kPAowdxVaaTG6H2MpmIHPFrsHYQGNHFqA+YdHo9Pt0FevQSs35ZsaZ7DJDqTLZ +2T6dfygW4iIY1JnsUu32Ovuclik2dYY63/QVqNjR0x5U7WI6xqE3zedqxrnsiiQzzE59faZOZpfj +LkfJ7LosedW7oslmzCR3WbDbsCKBlPNIImqdyy5RinEyu2xwqHx5bUZQfawyBlUoVYAD6mXFv0LQ +TPZHiNyG4CYI3xZELtdCbc6jO1Uch6PAShPSQQ6BlcNVKYGV1C3GtzsUpK6s/1lTqQIrC6gOrByA +WcLLe10FVprEQ0cSqYm2H10p+Cbd+EohGLg+6vRp492UygZmFpnQ4zCwtxEwJgY3hFYak0qQZTaQ +StaP2UVg1c+aq5Rtd1Vo5QCqQwsLsIRWmtCMGV5QEW/MGINWs64ZKFzCXdK5S3Rk0xYNu7pSenvG +Ce30kWv1MTIEmsTLh/cVaTtHzzBsKq44SBWqV9Sih2aoHy1/KsxsR1baQWAufhKbPLkVQtiU8KlC +GwjdGUcqPwmrJNZoCFE8oU0xrw2Qyk9SgIOfpHQ2+EnKoINzoppcdmLYFFRdXUubkumOrnT2p4zu +dPaojHisSamKKj+JaROhr/0kWjKxmrJjSbTRwipQLSYMwCxNlM4GkcNkmaaSTIzP4kqRYPRl+kjM +aTI7qB/Paqz46EpXwNpTot5LSvqVwdIk/B0Bldu5yrCdVMKcfZkgvljj1R8M24kBug== + + + yrJdDEeDZXsAVZbtAdjld7GaMW4k2Xqmt5pIwKk29ijVMwvxjeTpVEB2LIyXXamN2H02AY2ANhlk +BtO2Jtasbr/NWmJ9/S1q4o2vf7Ypc7XZtj2AKtv2ACyXrwtJaB+M212m1pVtu+uzhJ6OzCYXbnWw +VmvnFlC+U36CE8gCQIQaPCV2giYJ6Pk8YAqMya45jJvqmNazS4xgvIpU8LZerNYWGG3JAKq2bgAW +eqRZvngQXe6tKHLFVQJZzU4PtqxhOH7NSDZCKMuCX1u4o09uJsCiFpcOM1srgzYm22aLowRGhLwG +lZdM8j1XyFSDyo7UwLRzQ2fD9pYx62PIGFEOa5AFypEaNQy7kZukrLzGhyI3Dm6SClhTshFzK24S +pOBsYsN3r6FjpTgU5XR4TyWyQUvbPSp2oU6X0A4t7RxdL+ShFywLkYW7zKTiUsPC46MEamZSkGAo +PjCk9M++B0RNIBFdcjtMfr35KhPCfrfZvtKIS6XpdFPBTJ3MOGpkLtCiAUKqK1CFMWG4piTNsXGk +TY0Wny5KjL48byodxjDHSqNlkN0EhgJf1Xt3hTZ9iYM0nVaqbdoSt6im4wZKTBwiBpWxMzVxU7Kc +o0D4TVZ9tX1SIB2LuxZYlihpLCvQ8vTShOn3nQvTYfQ5ZkNdxgzvIEnPUXDP2hzUgNrfXF8JVE2Q +8T5kYLVhubdhWzV7xXT7O2fM9Jxir9tQn6c+by6wvA1Umqb40OrydgCRyhHC3mH9+RRID3AG6iTV +6A76V8q+sCYNE02GIWBQuT8TUrpqvzRp5QRCzlNvIFJg+hz0p/uH8uVFQdZjM8w+M3zpFKaZLwck +MOQreUPVtJpAWbUgYmVgvkrEwNHHSQIlWxphNDN7dpWBKWh/pqSy1fvBNKZ53wqoXn4BDtE0ijbk +Szkxh9rpyZfKIiwfuI9OxvIF4Oj8kuiXQPs1hZkcfiY7XU8DQo67UnWwburSC78pkBG5E2AqzD7M +CNatthvN26XXwFgfVKRsBVQ5CSlLTbaWqaVoL6Rdq0H1phagxoNpb+l0TbFQ9wkzhpN0Wf4dThyW +7HTiGS9SzbIRThXBosYpl4OT629TvMWAti57iWvshriv29QO2WNUJBiuygAZFj/ABp1DFQdUS8kV +qXwwdoJQJTF/fTAh7Vp1fBqbP0Iol5M/jxFKn2Ajr7x1Q37vxiWoTSZybjHJY6e5e4hMKOMqoNij +LH0eRssKIFgkCdF0HwTyRaw3p+Oh72FMMPMBjWmj03z7Nb3FfhmFmZCjinyTWGpTF8zT+jlMEV6w +RYtQMJF4k/XFAqs4xwAtHAYdKpse+FCybE44liuXdeBtOVtTzQJdekswZqFQC/p2ykKdhmCMP1cH +S8rKm0DMVwQQgyNTjxpUgXzsQ3Et/QnygAav0rHR6NE0HdeVvo7TjYhpLvXO6hvlRpQvCzdSvrCN +Mluv9ySTnVanE1qtWaGmduWNrc8GUgRRN0YRirJ/Md0ru0ZutiZTZVpBG2aKLoIWI9IaVjPzYUxc +8XSJLoAJdU2IVsxZP55M7Gbfzvzs4bVU2Tv4XPQ7lXJ9fI1Agkp4EYt+p7/UtcLlj0MZ8Mfajwkg +qliCaZDYOfcvMo/CRT+kRxRfVJMYzaGawmgG4wlMxz9n+HNHz6Vwz9kzo3tmRCZIddOpReLUU52G +7NHqQhj/lBrxp31qFFna4J8yjUnN9Ve9lxqRUppXP7ncp6uckNX3ZrY1jjS/K1qMwNth1nqFYzox +7TEZTmONBQyEySstmR5yjE15q1NWmu5xN8S9z1SVqprrr2ml/HloXn7KjfhTMmWPvvezrXHSSn+s +W2RVtfx3QYYfX/39uaHefSXiVyIoBX3yaEfVkuuDaIaDkD+Twumn5fyPro3RJ525HEFsNIcPzr7C +vtRSGghb9uolR4MaeQu6oHmNSDs+ltErPNwxPBqM0LjMHchY8A8LaYcdqDBxhIjVlo3PNx2K6YGd +XaqaMavQI7WMMnfnQlLJZ2PsKoeA5vVJ7/hYRq8QZcfwaDDCszL3H51Q/duiy49Lt/6PIOd3IGUV +wS4dVefSlHMZk7GETG0S2ORQEEyUmGnCgBG22tSyFU0s6DBTYM1gtz8geuV+iYyTwRPXTWM2irrB +jrC6SZ/03tk+YeEWtGbKuz4xu8bYtR2FZ+/cKNNtwwsL2RJ6EzsxLqQvAhyGfhD4dh+GzxjcKgrl +5EgJL/v8iQm9K/sxgdYMescnxNitMQjddUJNwnrsJrC+taMLkVWAro1Bw87jNrRm77s+8TvH2LFH +r0bwfH1vfhr35hXIxq9v6Xe6pd9VRj9/u89FoOlEMwJNt3Qi0+8Yqb56W/LS9KLuvthbctj2ZwPZ +2HmXVLLbunjbHU8v7DlXfHshWx/uIiY7tyjLhTv3bsftz3LJjkt+7h0/Bwt23octaWvr0M+5eVty +3I4Pd9zxnZioMuLWzdgxxARRz7mDOxY1/XDXbd+5b69E/Xl9s36aN+vH19Be3+Pv7R5/R03x3BM4 +D5+2uem5zPSza298dev2+vTech/jz9cvZm8LKMxufXB8Ort++wPjHs1PTxfr43qan744WdyYvSUN +TR/hYvJ9aBojG2udzN80CMPrWGhArvUsRi711ieL+eHD+el6+Q/5ctR5//hwub94vD8/XB4/e3+9 +PPho8UIHkM/urFaHbB0eLf+xOHy0WD9d7J8+fnH0ZHX43vH8yeHi69zabM/7vX+crNan1YyrDksb +9vL+2fJgsdFW78j/r/Wz6zdmX/zp2hvStPnqveMDHZO/+6/uyIYcJ8j1z2VGq/VMpn60uIEwKPn/ +F99qPNTZOCxq9uwaK4fzv1+8kF8+lB/+JiB6mmZf/rWZHcj1++ITyN3pjWTXwoemluZGX0R1pbpG +SFmVOhQsTMH0dA7nr+5CnEoPSgTW+/R8SP2TAnEaNTod7e61pzKRe/xaTbhtpzV5qRPs2Qg3YRsR +TypqT88y9EYhGqHdaNx6C1JmYC25iVp+dEO3LfL+y4wiH18btrId63jvqRO55UsafoZnYEhVBFjv +mPJqz6XRcqY3BPHp85k2VX65i5IY9JlzPB+EWNoULiSTpFsaubzguWxRMs3iG+awgvoUG0wkzphz +DW2i0VeveA/cwVkqANaGvnutRcwlNjgGTeOD2BgGAsQWaZS6GZ7Y0zMae1Xx7l6zrJeMw6QTWMiJ +7KnlWbq9ptW4HKtpcTqvYaY4TKZUC2yVXmrLpjCndJfeicv29PpyihDb501k2vuOtXCRgxL7hL3r +mOFOmrOuNcIIqvGQpI8u8Q5FyxB/EGWNfJEjkMDcVx0zEJnReH2BIXMlHfsmvfyQPdDKCjlY9Wbs +FA3vErV6rk+2ThMAGbwNhJMz4jkUv8ObIDwDi/DXB/0OeI8YDTkWZ116ZMx4g9gkV/gWKgPJPd5M +IWQrRmH0HbygPqRCXjIHltNmdUYecKex0qiIaIEVnUwXHP4uPuqYAl62hS/nvU2xYB1ChOTMfX73 +MCwXg/NVfOz0bZrPVcoiSh5F9jKeHuYM1NOqzEC4iJerAPUsXo1MzK1QXpvmDAAKAw8fCfbLdbp7 +TTZGI3gJkZm1uUwpfsCTXfwhsr52L2fNB85tSKWq8LXMp3X6LZoIyrQ2pcXBriPETa6HSfnb2l4z +nqFIPB8a45M+9LPQ7ekYXS/Cyd1roUtZ1WR83OWQq5PI70hXI7/3Fpje4skt+GsAuWBhba/7Bt+2 +UXIgwpXF7wyRUPLATxA+AmxvrYICsD7qN03vCLCs3YNFiYilHzH2FZWeOTObXpm2QDvhxAAwjhmL +9F6nhsDjmwFEW84qpESRodVC3QFVEKQHLApPIuSLqOGnAVEUQfqMIvZhkGA184B0pYQsGI2K4Tf6 +piQ0eAiEXjWoC2Uem3rPPA9Qz0VTFnirJZ9aPN7HpgUEp3mgg5Y94rgYBZeLoWzSvbdCp6NPef/l +yLxzRLvYsz42UuY4opnTd57Y14BHNjHnAmzTyy8ADKLLW6+PwfmRxra3TF3JjvWZTYuwvRE+p0uA +m8GySJq8qNesB8KuAqpbM9V/k4rFhfw+VyBaninkUu3OaGoG0D6X8vBbFOFFp6Eh8VNIz7JO0/F4 +P9sUZSU0k7mp5H6WxM26P0IU9Kk/0jlgDwhgcRnEAPJMhVBqNlJke0HhL/TLB214YNZJm62BuAcO +IbCCaEZD8WQHkLAdkZYCirk2BB6KBuSdY2b5qIGPAY9XoiXH6BhfBpBjsuhe3/8FxA4xLzwqWgmF +SrRCPvGIXRMkxKZ0rI3ZKOZi3zgwaCCYHCt8kgjd9HgNpf1oLirv9LhY0Iw11xD1KTfVR31chI+i +Phdg6VQgtYgd4KteiJ3Ws+tJKXzQguz4pNeUJR6ZBzAOJoVoNt/qxQOAD/OlswY0FyiQ0gH4XC0i +pHSz0ptG8MrF46NaLX9L3hc6pcWBqSNIG2JoScZMBx4FmQgsAkjXUD8AlWZ+tpDLQYBQiZghv7uO +ApHTd25CNlgHAt/IFYMYFlKh7lYTdQrlEY3H6W3CHcK9Do1+gnjERkA+PWlDH8BDGV+kGUcAq6VA +AII6iY8aZT2REpXSNhIKyES8tyBIQN6IVz3Wp03gk1jwIRKIVulPtOmJlgACsu9FljkjKgStNBCR +pJbXNGqZuIgCJhiYAEGJGJVx4Bsk6pB9kasQQqd01CMej73wnK02jkxbqwM1mohFPvIMvwZyIOBM +OlZcEKRguGU1km819TKFOlbIo5aOflvWvAu6Y9U4wFyIsxGZOFkW0Ct+slvH+9DF8SiJQAx33WlF +G1BELS9KM2h0vJa4qL2+LgOEFUmFkni5/6DNWpui066i17KtermZRYa0uZ8Nv+fTKd8In1MMZckf +ubrgCk0qk4PgxMiEabLxieyAUPcdsY0QEfhjk8iUa/XRU2yGIkwoxiV9epX/nFdhqUUKd/baat7K +NmUAycOAJ4OW4xunmWLAgxum1uySoOGUM9wUfZl1WNEihvQN0z216ZmlS1W0A6oO2WE1mYiCsJIC +QlzBOA7GGtlqSBUQLmBWISlrKQQwuYtvVRmCUKAMFFIiiqCBJYkY4VPYMfCxEfo4HYHkvEweeQl6 +2tSZekBB0TDjplHVCLxQc/j0msUbilWkHHLTNgzebZkw1DGlHB81tEi1yVThk4E4OrAbT+YTvsng +gpkcC4eo4jzFiGhToS5wMqdsvu01D1TXaGICfIo7CukWChK5oqNwywhUcLxInQqyPZNYdSxbGCn+ +NxDPcJfQhd0zyJgRUzYRfJKeDAOpmWcoIvFN5NSEznYEML0u6ZThfYtIUuzYhkoybg1IApbDcnWT +DSAitJqZBVI7pW8gKfIvyWQN3qZ5yAn6O/PngDGCDeF30ZCACI2m6YmQH/qZoB/q58hvLd6OTQbA +mMhng1wDXYdk8lBT+PZeZJAusYwcstthotB2rYpZHZCsp86ZNMsupZG2ibFC6ccz6A== + + + 6Rh3+QqNdozQpXRJQHlQuaMKZJTtP7gmBFzDwqG2IG49FCpmFaMHMdRkJAuIcu5UNoDIHPCUFZqt +3g7ewVTc22ZkDiYlD/CNyqihyWXIhDz5jkyczBEtWNZL9rwdaobILB3ua+ATb5dSEAPAusOuZK8A +iO+BYC6G9ZEiBZMUd0zt4nNWahs139PdaxCdtNIHtAG5n0iBBAMDrxiQyfTpqQBIFTVt2+TiYEaz +FliTnjc7JHaTAXmeLA0XVCPmgWq2DZbnkgUAJ7pcAhLx9LZUiulVd7h7zfSZGksbTkXzj8nAVDUN +bDEkvQ01E/nCpbev2BaR5WfGaOYBADiVnsH0lmSzaxoca5/q0rpeE+iD/2dsMUIskcZCj9DzUbJs +tUxZyxun1XjyYJ/EOyDsXp+qLkcU3uMWULbSNqTglsWpFMC3EIa0xbPbzpKqGmAc5UavkhieK2t9 +bFiUupnNT5OAyImbNbipNERBrKVJotWshN4py4PRq2FWtbSmu7TZaeU2sHrsugimNJLwSlBn7VOt +zHy11GanKSQElWTbHI0e+nJQ9o8y1k2DGsuNSuaQQ/BZn5L6SyPjmIo49Yk5uo7Jo0uNemh5Ohyz +jDQqw6Ts6NASO5WMiJaCqJrYK2AfSMMAc6nYMZN1yA3INYZp6EA+PRoD887vp6Gg/EFc6lPKeX0P +xg3BRgxTBPHX5Ae4DlqMps+JGgWPO6O8G3lNCUkF0dq99CC5T9zDpaT7N/lQPqocYVKeV6IJcLlL +YjKuMosg8xmFXhWrqZJbKj3EEybp79TupNqP5g2yNBvly5Ay6XZcGS63pjN3UCySJEIeaPEntilJ +z2DUVXKlRknTalZ2FfpSqrhWNXFA1EpgupR3LitbN03Um41J2vxGKeTK300q0WFwWo0qdr0mwBRJ +FmKJSrIpI52nXYO3S3MwdunlPaQcTaMyDBdyyl1MCocWIHdFBRgIG4BYTY0iHQUdLbikAZherQjo +KCUu7ZO0UoazjRZiVnVNc2FBHuJDlxBy5mKnCe/RhhKmliRRI2dUuQ0n5x2NMX16ji6YoCkyYL7h +0xqn7jQqRiYl8cOxEpehGVl+12Ncq7YjLYLRZyEQsJ56kwNX9Gra1usmvev7elHIeq14g9dq3BWa +6TqFaeIj2MM4HEg1lCja32nDgcvH0pxE0zXfY8HaQVG9KG4WWhrNi04L+Fn0qOolBB8uRU4qGDWH +psoUPfJDGMp+mrelugaxT2IBqAGLmEBhUg6ZhOwiU1U8kwZfzUbvkoIuUqGWUrWNEuFhPPhNkVIB +38X0vBAIiS0QQEqhCoWsMYN4CSsxU6Po6hKS80o6bkHPTF3CKQ03I7qUxwU6SPQ2bWbP5DIQJmj6 +oiMAVEfQvmU2Gdg+mS4MTDg6Pbw+lYptkTKSxq4u0Xio/swKBT8EsAEWQ6v3vA2pnG6bnQGCdB3r +I7fM+27V9qa+lmGagtL6Kg04YxptpYVGOyZF8IPpQhZsnDJGqOA69Z6PaA1vkBr+e74ZU+Ofcoue +r4Vdunnp7VejRku0UkMxfEvUw/PFgyegUdSEMUnT70IDIi9xOYunSXJWIUcda5Rk45S+lEVlXEqc +Akk5sPa0UGr6CtIGxCkl0NRgLZK5dWr4pCvDwH6CI/Epx1T9USpHbfiQz5Dy05bVkCOAPmfFv+FW +mzZbGIDqMAszczhs2MK3Z55kr7J/9LB19222f6C8Lnxn9IaFpC6anI8EAChZxqtwmHYedlADzxsu +AoYW4XtG9oEjyTZKIYoiTqmVARZ2ORzohERG+DyQcQbyAisbJQZnQSmaNm0f8RyyayqzZ/HSXgZu +c3VKvGY1KVUOjsmkBblUrdqoEEoWFZVGwEeHPmMX2iRUMB1pySQH2gayhz/QQGqoOzun9bTxSa8O +BfxFzbOdOvik++CwkTZqPQDmRvIk+sxUCgkZMrrRHPAkfTbfZ5uKZ1R7YNVeYnO+O7SFsRayudb+ +MHwFOcsvqFVyYXpKSj4qgfRIao3fGxMHcQczwrGrIEfXJQWHlJ6IRnTIZcZVzjMH74pSULkx1G6d +VY8ipEheNAeHS1QfHOUaADrdOxi8ICE5m4q6RniiREPz0LowXziFaOGENJOmZ9Tm69UTq95eDt1p +Ou/io8NFxS2GLAYdV/ZKbqZw1F7lG+AaOtbnsrDhCboDO0PydzpNz+HBkFv1K9NTFuAvhdjREQ2s +WocdbQcsStOoqVpJNKprACAcpWt0vpw4DJch7x2k8rZJ9bLBKoxRa2pMyeFEGIqwIQmtyJPjPGHg +TQkJe7wdp2clJe0jqYVR1esdl4E6vM2Ebcr6XskqPMwt3PTwDiKrhOxGa/WRMJiA5higYSbS74MU +FfJDy1TGTNIMu03MSgdzWwv9aqE96BkaesVhvHNu2DQIAr5Vg8teYIllMioQ1sbDRCe/qnMb3ksa +UxoNPsBtYBEUGgk1AxqSCne0peiVyq/xByMNcuvQ+Rm9+twt/SJeXRky1ewqB3+GARDudRdhRIHx +qIcvvWfWA8gCMtosn22E+7Cl4tmQg9CxLlex29M31ipOdKCuHqFktPXSe0wRQOYbO5XLDN9bw3AS +YUfKmeBgSLGqDjNrnvzOJIFIuUczZwe1EIFB+ui7GqBVLg47L8JkolYKiklSBxVG4oPhA8i00Kdj +p7cSvyNUAYsG1oMktZW5zCJlghwsVoBoC0hMcCzDgISNT+2H/q06zwBhe6uyD+MT7IxJB/k1nWLS +HqV0cLIgqPIXmhVgSGvJC3L7VFb97jUIyT75BzvSZdh3gY4IAYBtlaiWygnSYsIthLdPjsqT4lpg +tJHThl2GsiG8FKrq+lSmA95t2tfy362RZcPmA0UQESOedxWaJNxs8A93dKtTd2xT6mAYJXhzy0WF +HQlWNYGIhAN1Cx23yWLkIDc3Tk2ljDZxrTqP2pTe18HQ5fhF70GnhZ+GWN1qpzNpYa2Xs3FB9wjO +HFEFYAIk7YZwJ0KkjkCdBCJaKz27VJALUoORuTsU1xY9OrCeGD4IyaZtVVhiDXMRWAJMWjJp6JVI +oEAbt0VAHtVc9fEpc4FvWvYfxBasPi0Cfw42L4I+NBgqA1eJFMue29OVg4ZZIeo2Wc19AZlJ9Hlw +Ipa9hBWtJ6fqELQB6yCt7jQxNHrCQijUkiYo5pExosOvSBvvoEaQjCETOLRgxzgdWjihf8LPYMFi +kVNbbhq2BuMQs1V2gKG8JeNm8hyXkiJkA5pz6sSj0Y1jBkUdiEO9rtUijKdTy+cgnpjIUB9AmKcb +v0PhdYn/G4hejdfzpOcZYV0Q6LHdMGB5tZg5lheM/B3kYzwEijQ6RIFEkgfEGGCzcUvLGoxuOldN +zRVyEdDRprz9TJNjuQsMjrCNugf5BWQj/A564dXhB8olSAsbCixB+JXRMDmnPkNqHUUbB5eoTIye +dIyLHHDyO7Prk2J4FNfT1LtEPSbuZ7pboF6viACJUbgdvog0T1qVqCEeuk4PzHkM3dOuApuJoanf +RlYVgeEDnJ4dqSmWSoFiEswSLWU9qKbgaiaoDAmlF6dggjJuBAo0ZA59q1bfXmmiobt0Rt8fXm9E +TWeVrdgwrzoiEuIL4GptUygYqyeLYChToDnCJROLSSxyHyRA365bZKQxvAaUWW9yMg0lsp6GFlgW +OoYRQMthZhmGu1kSrxx70NFYkAeqFE+QM6wWIXoOWSTh7Weu40gXHn1XqsgMahnsopr836jZ30Pu +568dyYDXABBIh41qgN6pWkR7FK+5WnxNSmmcKTnUe4rrXA+VapqCKPn5lC2TErzX+IOQRO3k/gfJ +YiYjmwLFgsmGkpSdEfFA1J9giAs5qihJ9XDgwWZdzKPQEeDfEH7IjOSW4YH4pk8J75leSpqAB5lO +zYIegVeQ/Hwy41irIk62iuHGwn8HVz4fEsGDAJ9tm7CaZstA81ORMhktDtZjsmG/17qlW04bdejc +E5Gqg0xViNrRNZi5YGx0rPvSzXryYZAsuRu95pcZiKbQOJ4aqCw8z3BEOTagPDPtnv6rTrNt5Qt2 +dM2mKCaBRNBB/N4pEYmgxEIRWDkOKSQDeTKtTBRmWqEuMxbCkLkaunza2XQIDPtZCeXVaNaslnAp ++j4paoZKYLxt1NrEDJTg+TFZZhlRQKbUhKSfUU0AVSIWgcyAHLg42ElHI6krV4VXKgxwjhwRlJ3X +qcigYe58BmP11XRaGO+CmqfhvpQNAIgRMiwcAmmoSQ6t6UB3NX3OzojvZoicbmb7q6OT1dnxwWzz +fH6ymB2tDhZVWPS/GjMOro087Xhq4RsPc7nQaMdXFYI6TaevQYQ5wuwCmeWnEz3efC/R4wG/fvXH +1fGj9fL4VCZ986aCGVNe/+HaH0/wl07/8ujwTP758ZO/yQquXb99sHqymN1Zn22ezx7Oj+fPFuvZ +x+uDxfrGxX+b6R/vzg8Pl8/W85Pny/3U8lNZ2q1ZmJ2c7s0+AQLc2m57Y3bz2vXxB+biL8aN3eyE +XcgHH38zP7y0vfY9bcouLmh//3B+eknX7OKW/Hi2/3xHm/y1IPrHx3LSz0ej3H0+X++v2MX8cHZz +dn8hLRbriz+6t/xGcKQ0OsDf2MW42cPVSW6SMGxXX4vj5dHs8WJ+dOvGbE9xRJBqhCHfM6Yd6PjV +Dl67LnOVfzYzlhVEzlz8wzn9SUSWWTu7/cFXd9ZCBg4X/PLB8olQjK/uPpaW4SvgDLfg4Kv78+Mf +ayW7jkeWoYdan6cA7ezW7LPj4/nR4mDW3prl/wpJusWnUrdmfLJjZsOjDlN+ari2mbloYS8/z4RH +k8lpE2k9M5Np4ky6lKDYMTXxjIoTJweezjU0O9YAUyP+d+ECvs+TOQ/hseqC8ecu3FqzGxzG4HTp +9G/pUEXSrg5012akn3+srTiPbF27XtNb/AoCjP8hb1uTZ8z/f0e8O39oV6gxB5ZNEwFsBu8Jp5C2 +7HsfdiDqHDYApeW/Pf9XrtoPMmhZKwY1HPBmC70948UPNO5wujrwcLY/1HrP44ScRDPDS8RqFvby +Wbz0bej1L0L2Hp++OFxsrt366Hj17TF/ERnz+u3jlfCIW3+Uiyxy1q3bIn9+s8h/vXU3Sa33l4dC +Q9BeCPryeKYNFHpDZcnU5C3RB259vtwsRX5Dh9s9PD6d73/9Ej3cmW+W+9UEVscHZ8vTq3z6zrXZ +rUfz9emOXh6frldfL64+C8s/HH68Th9Kj7WsLhu4Ov1ksb8SefAAf9RmaR9nml0T8reDHUC0Dssa +wV60vQaPmtquwVsf+Dat6MqiA4ZWBHrMaC8nvtdM+XiGXP/e0GGaiwqzmHA3++L27veQFkkky3vI +Bu8h0eqLA1nN4unsndm12fVq5pC835lxobN6L/91rJichl6jtLUfP326WZze4PzP+T5NUlvuzZci +/t7SmyLtFwmXr4/6mz0QvJ699xSairT+dHn6Xc61vHStJ/DB8Wap2tz1/CPOX+7gTA== + + + 5IrNyeH8hf564xzMqFiiOffszF73/ZzeZO/vHC5EK7360V2I9uxsWJvg6u5HuchkWq9jWMDQwznz +/0EREbjwfe0F+hq24uPzXyhPN4PZAg6u3Xki2Hk9y1jCPg6WC1GlO53SzX6QofI/7+AZ9J071W6W +OWAzi6L92Wbx3jeL448PDl45joB6xR8UR35+J2yaG1kU+9FO+GewLd7+8NvyiujkFffnpW7AtVvv +/WOxf4Y58A/8dpf0NzMx/DtIgP++UktzidTy8dnpdxFb8I7S+c7E1ke4lBBM6gPE0s4IuHeK1QgK +lBZFQoXcm0VV/oGFoYYCT8xgsUsKMnItNIeLaG8/JzEok6vXQtD3xiLb11LQaySpkCTrUHee78aX +/kalZA3YAgv7zxRfwg8hNPyc5UNrXovNu1D/tdT8g0jNITaV1Px4eXRyWKRmPb6RVWf+0ucpk1oe +n54/izuLbxaCfKunpz8r6f3HtrxeedP/ZRHyJfSSC5fwo5hcfwaUK4B04ek9jIiGMVCN7dvQ9QhC +QpQcYvh+HEKvut79s3/+88Xs4Xzz9cWKHtup1naunpfd4YNWd7HlOYXrzK5/IttztnkVMp9uQtJM +4U2+eBe0Idqduwmjvq62ETHvw+rp5vSGEgiGGP3t+PQEv/vc4OhwefR/h48Hn1QerxfhR2Hn/26c +/d56dTJ7/Hx+sPr2NVP9uTHVV3K/v+tOfP+itlLnEQZfRJ3RUNudS53Ht+FqbKrNAZ+cjfLA2Xv/ +OJkLsbizeLpaL2afL9abJaIOiIdKq5+v1v8EwGXAk8OzNbcGUW+Z4p/M92/oQjjG/mbN37dJ7qst +T//Skn7Bis3+4TqtUBHibLN49PjBnbQZBXwyXxIQilRwMF9/Xe/Nk8Pjg9EOf7NYn75yw8WrJO1n +kNpe0/SfL03/v64DXWLD9NSG8CwB7/Y1WA5PHPsfVwf6dD0/3ggdP7qYvZRm53KXqqOr8ZYy89P8 +ZQpt3YzWtdmfHy4eLI8XY/B68fRQeNGfE5FUosi2n391f45U8/xL00z+9mix3pftT30lzWL1zeIP +Xz063Wx39oeqs+nYXyT1hAT6ZHn8aLUsHaeGwiZXR8t/LkbDrVen89PFV/cWz9aLsip2cnx2dHd1 +sizAUXsoivPjzdbMPy8znyz2D/ViXyPEa4T4bgjxCq0k9mpWkh83Bi76H0Dmec0WM1s0N1CmgoxR +/u1QXAK7jlfUrxnjazr4mjG+RoifCEK8Ssb4E+OL7gcxBPx7MUWDqjmdiX3wnUGmYXMejwzKIpGo +7SYyZ0erymPf/cgOtNck8TVJ/MFpi+HLqtfk5QcMp+uSzI0MipC5WfoSuXo795qgvCYo/xcJyuv4 +3B+SoPiRhOJQexUExSFf1M8+vJtxxvYHxZ8f9fT/1cDG1/GmL+e6vL86XM6fLb56//FrB+bP2YH5 +I17SjDM3ylVtyn+/pFEadBY87aYNyPnasTp6h2KQof3r7OTHv9U/Kg1DGam+R3n73jL9JUvw2dA2 +rneiTVukZ+j7GDrUdhd25DvFMFQnrP6DHXxNAn94Esh3kJ+o4Dr74jUZfE0Gf4axea+V1Ssrq2aX +suq+D2XV/B9XVl8hkX4kpHN+sDpbv5ZUf+Yk+mdljhjwbqe0W5kPvke51vwE7QzmB7n6r0hAb1GY +qY38B/J+N0jPbWPsbR+8R9gjl8r8zCN5HAU1xunRuhKvLdK9td+jwH51LPh34wXMtTi7u1ofL9ab +mZ2d/KCvVHeKW6MpXCxysem54tako5f0uK8v9Lj/7HnZJ6/2tcV52fJ2IPn3kCXmp67xvLbO/viU +7kuBzs8OT//6sukAfk43Z3dGAuaXfe/4YMgue2mK2keiLInmyf149IRJpPpojZdl974nn29Rx9Oj +lE/rtfxjGxuPCgY2dH1o8QACFWZCNDDOudbkZVz/si6P8Ncb3O8v/nltCr/2aH/7QK7/6fnydKF/ +e7XvxwQ1hQWkmfDNe2NDY1kdDlZJG1tsWYyh4bCygZin62UaniIQSj508omzshDKQP2QbwuJuDBw +kofSfACpW7jAqdx9+OePZp8sDvJsHOyfrpX+G1SEgQTWO9c1rQt9xMl5vYuoD1bn9Jo1Q3d/Xhwe +rr5NPXa28zLXrnMOFWQbFAeysel7VCxErStmwJWFeFl313pCZFOCjIjKhV1D0ywExnpBbkfisTKB +99eLxXE5aRQa80EahMDPjG+C/FfONrhQ0uyg+FCdtoxrnBxvGeDui3nuvxdkjoIUnZHz6flViyxp +fexgV+bhNM4b2c+mbzxWzwX63jhMxPeh53HVh+WJXP0Ul8JoOm6Yz53Ds0XBJ9k02bvWeG+ZT7iX +WyTzk6vlA0p8cfTYNsji5hrBbj3lCZ7SqTk54zLew/mzxfHpPA2Jgs2t7LL02KFsDjfByDa3cswR +VZ6wHOmllVtjAirLWV4nPzpSLHkrldwYkI7gtybMHv4WNpo//7ZvZh/Jj/nOozS7IK9QliDz4Wrl +zqA+tnNNY2LTJ5yeXtzx8gkZzSbt9m+FdGLMP/+2CzLwMG7se4/cFb6V/e55kZ3gtJAwEDbeG1zb +pjcheCPbGXg2W1tQZ85D6TiUHRgliB6m0XH91TQwgFw223VR0KBjXINQrB7Vd1ohRCRrvVxGlDQI +ch+9TYffjlQoHP02Oo6JXTWPgHngNOr9cILY1olG18S+0WOQX51FqfTYdukYKk1OumVYf41xjgcz +vvfDuELCxsewx2XaFvjocGQcQ2hJwBn2rkGhNMImWLWTfva79h2IV9AuD4u4KCHZnexUh2riPAik +PDQB/+4Cl4qSn8EAGbgh3JJ69dyk0Z3od7AYnYZt0jxG2y6nHeS+ydWzQrATygmNFT4hxNx6E5S/ +NG2wKH3qUCaKF30L6eLWDtn6d2PzfuyeSPTCRXpQsMbnPOey6cJHGjDPjtxz+zrYHYkjay7W8W3k +GEN0HjHsnEfXGpRwbqKcjCf7MW1wprUO9TDl0EishP14oVYxolR4r9PdvgBTS4QO3CkpKiNnUsRq +51EuWwy+MSCoqJNnjAkoMdvrWvooZKP1bSeEueF6bYvVIe9mY9kGd3g7IfwIORMnB07KpShEwZXD +CIIEkKMaufidLm+a25M7MyUCcYR8zOy58zKWzY/1ZYxd7JxsqJxBHxwFkAZl3WXz5bRRLg9FzEUQ +wFK9YAK51ZZoQ9Y/pc1tzRmbfCu6Jp+FH02ksR0qgHpIctw/E+AEFsHGgiCl0C9UCZ3cgnbL+NRN +hIS0ARwY5GiEfLLv8EKLUGl6bl8AykdhiA6ZVHOOQlNn948tt7kGsErQTjJA5CP5rccVTmQbwbMG +zKhVQaYRCUQEMZFWHG9zgwpwnRFqCanOKaVArT5hVbJSpYBbCLF9P8OITOT9wFV4CCz882+Hg6D5 +ErUCHSS70It8TanGyphWuJRphF2oJXAqWwoVHP0H/UxYRz2wSgYWQ9tQKJIQGpG25HLJaShFFhCE +EsFKE1UuErWgFcwQucV0SqKscNMuOCtXB2H1e36HUIJtGG9VdS90MvX5CHbLZQ8oX8fyyaz16UTc +F5rpYqAYIPqP86ACQtBDopZCO2T2aNUpNk3EwV0YHHYysWbnvOT8QZlELBWJDtXmVRyJsn6R3Lzj +jZXb6UDXhQR1NtAeOyFGO5QgN742aRpu2B4XatIptEAwQXhh0wlmEIHlsDyiBXujPQr5EllLiJII +N62irwgzQBz5d6AS0W1RjW2VyO3aHjNsTxgLNXJrrZydXF2R2gOlE+FosiOivNikBlFhmiCrmdwS +zH8XHSm3xtbnYoMVsU5GFsLZc7FWNlaIiKhpco8srwOUHPB60/W8qzOtQDuqLLLNTKe1RpJ0gYOx +mIcf4QcuhVAHBzGXFbFEnRB2LPghfL7hRfWoBWllDOyIUppWVi/yuAjHoSV6bBc4CVOE8RM5SOfl +sT8+5HPJVxs2AmG2HaQ+w1ORb0UHEHYu6NwQGXDTgjBA6Q0TJC2LQPVOlGvfO2VGYwlHL7ubiOjV +FSLlbZuazAShsQY9C36oBB5E8BFWKScNiYBzEUYk6pagtwWh5unJPkgT1yK3tlXxeUICp3JPw9LS +NZdIM8PhtZwZLpUvWCSLjTIBUF6rReeEGQhhE/xrDaXlvdZFwTS5Q7IEb4zSITliIYCdfEwc2mIK +7UhQInJP2ESFVb5MrGBVA74srEcU5o6Clkd5S9kIYZrR4bkvjEhWhIQWxglqayinI22iKCUyBJGq +npUhE524hWAw2KXCuHKUcUSF5Ai9IIeQF5keUVlwSYTXaEWjAdaDxsixtcFAug4ta/7I70I9jSgD +HWgCEGBbx9tmrCO1r68JJI+yGyEZNTqY0Gw5OA+JNsiUEeBGTaKTQVDu2oFEkNYFuVUQhwWjUWl7 +l5hhRwSStHwXheRFbEPWg1yemAgZcstFpLTQ8jGNFjQD4kePW6YyL9QA2R/U3nVKC0U2FxFdqL1T +1dltax9bkkdzPomIgzgeCtMVAiCYHBvpx/D6iIImCmF0VFEj0Qzz7p0QBCOyj905/elJbZvVwCN3 +EfdQpsbTjDozTQdI2+RbMzUMVpbL4tquIuPHjYc+Pl7Pj58JPJnfLutl0nzo5/78AEUCHn/94tI+ +qqbp+2x21YcAj89OFmvmsNXZzj5fPjuGffjSns//EgNdGP46CQgobfnhS8USVK2H7fnj4tvZ+/lh +w+Nv56f7z2f7q5MXM3vpoi74VAXk6/LXF/RlPnr2yq3UKo5kIVGuU7aoygX2HhZNGHZZsUwINwih +qHp9Z5L5KIrAKLPFtfOkNcLbGoHZNsl0OyxuWybe3SyunldfpuVQWTyCocvtJecNIrcbVNwWtdsS +Ijyk8Q1sy51TrhqDiGiiksmF77pd/H4XL3ZjeX/HtLpCd9QALpqYERLNnRDe1UJ+iwZGb0BaOSpR +aT0YDoUGmGYNNDOZmX5UczeK3SP1p1FpbGxO2p5VLLMStUa0UwfBzBl+bGGnFMlNOEZU06GIUK2c +nuAaOqUoBy4nkmYHgyLVv0ldD4peExl7Itxtz6ot5iuR5ERcE2QWIYTallMTsug1LVUSHAYKXws+ +4GyV2spHojlC7ISFg4rRln62ZWgMO8179bTCoBdB/QR+YWZk1yKlwXZpYc22RF0RLzsY+0SuMzlF +ybbZYktIaXdysXoagwAnWNJC8GjghqFW3MOn5kVL9DClESK/Ap2ClRsZVA3Yuv7bhvc4URy3p1Gs +SZCF4JESLh6Tcm4b0Qs8XHhCBxQi9z7CXyVyY6+70W2pid0WTncTnN6ehi06YifSjJA+kWpxG2c0 +/vZy8YPIjUGlGUA8REbIkcnivIWw/cj6QsP9RE3aRQzzLGSXRZGIIvS3asKU32H0l6vciWDIeYlQ +IT0KVojMmDZj2+6/5U/bguzA0Mw27qyXz56fDozjVTsVfzto0GN7LFwwUaToNtAFQQ== + + + XBS1C5RRiDeH6CHHYhNls9ShJhNzDi4s34Fi7twst1VGc2oyGiYWw/a8DJBJsBWWYVK/BtbLRgRt +D78n9xAYL/+TZkKKYvKDdpPanNBNdhmoi2ly5LCREWW5ogRKp41XzUaGlIPphV/2pGa9HF4bBZek +nUumIDk80TjgU6VTh3LAlB2MD29kMjTbJ9MLT5JLHGAHp9rSodBTlGvtYDsngrhGblcHtUMuvLo5 +jFy/Dp41b9RdsYUy20x9qjCObIZbxjJhR5gCogNFZcDE4G+NgsheLp9RB8a2K8FvaTJTB8Z5PKDd +MY9Hd0roQ45weJmyvA+Wm9M6kmSce3dnNN3Wm5hRRYiU73T0dnASoL0VvcFJfJcaw6bRPz1+cfRk +dYhu/j8Za73aX2w2MsH9U1EkDkW+vv75AvH9IuIuj/DrB4eHZ0fL4/np4mCm2gZKJssfZw/n6683 +s79c/3Z5+nzW33x8uNxf/OUGNmL55MnqWH54f7F+sljPb6TxZcb16OevIm38vdX+2ZFI2ffmp/Nr +b3x1K/8+e5u/VXFH8nsJ9b9zuFgcPFg8Pf18Dof67C00/uLhgz+uDhY7v3xndv0fR4fH8ueb89PT +9fLJ2ak+OJCmt9ciy+tXP3AX30P/Vav958vDg/XiWNvk7Pv5r/jH6YuTtDnXf3W8+eqb+XrzTlVc +rm76zbCRhG/OaYf34toszWQz+u1nujvHq+PFFTbmcLX/9eLgKjuTW35PiPld1/VkeQy931xhbYIc +jxenf+QiLl9f3fp7Ov5/cSfMhTtxpfUv508OF1dB/EtP9ed00d/+5spXHU1fMUZjeftnm9PV0aul +ZD8cHr69mSNmFQxRrthV0fEHvxePUVT1JzOV/wu3dPP0258wN37F12ADSfNnfsrlUdJ5i3yyOhVC +Bjn24/VShOGrnPL2N6+WIneiv2Wx/FwUvhL6vuqVWN/H5rKlvLjKUl686qXcdDa27WVreb6AMeoq +C8otfw6r+nZ5wCJmly4qNfwJ8HwSu8ers/X+4g4MDK+c6QtretVTOFqczg9EBvpX59H/i/P4z4Nk +kbgKSlWNAcn5+G5/YMysWDZEfDk7mT2YHz87mz9bzB6tTs5OtH2Lhw7lm342X58+Wc3XB7P91eFq +PTOzJ2VelzZdZ/UzWG+781vaoeWlfT7jc40xb+PaHq0Xm8X6m8Xs08U/TmfvHSxP50+Wh8vTRAhN +6zpXOs4bcXd+/M188zhlihh26+56dXJ7vZjr49RtqWVCcspMPtjcThNO5rtBPe0aZ/bCLP2LBISJ +K4AB1z85O1ysa2aaJ3JvuTk5nL94mCo6CTLkAVDM99Znx8t9QYCMFMNoJZvGo9ufJLrWRhn3pv5r +GP6TxeGnq090aE7l0WqzxNr4V5uoXrDyEf9x1S/N5GbkaXMTt88vzh6fnZysYSRkxMLs428W65P1 +MqNx6PouX+dHi/XmZMGTeX+9PPgKgsidgpUg0PGclvcPV6v1JxnX7FAxa9rwD6v18p+r4z9UPMeE +8xrfXRwe3hWamad6bq8c/uOT+X7BSl+h+v1DpGE5xkH+99kcmDt7ACPu9mY1s6fadrGerc5OD5fH +i9mG71czw5jKnyMG8nhx+If5qVwBGXqx/uDepjqTc1o+WO3PD4Fdddu6wadQijBqwlLj95q9pqJX +X9/+4P7Z4WG+eKnum/y14HtZXlstb358upzJZszTyty5m4tTGF3kC7frVIjEmElIQ/vV45PV6V1Q +modyqy47TgrAo9M8F0U+AR7dn+8vbtP6fSmisv37A6k7fxJsOZrFpRdguCuhu3Bx7/3jdIuP7Bz/ +zk6esLPpcPvOafVppbuYKZ2cNn6MfDtlgpVh/g5VlMo0f8FSOa96rf78tp8vF98KPgtZPp0f72fS +Dtdjh+dyl033dF4I5MXbKoT9dNjRCwjfsJ+tNf6ChhU2nY+naDhBUx+6eF6/RKeq40soHwv8JgLx +5cPFwfLsaPbJYrM6PEtPdKf8bJfQcr/cZXL801nF9IZrAoL6cLF5PvtkvhEit/wnN74aLZOT0Rcf +n52enJ1e8k0zEjuytDVbSqu5MK4neEous99NicvHR6z8UObA7T04We6N+YJIPYlAuqJ0nMwPDiY8 +YSNkazI5oZmDIeb2B7PbZ6ersrDFlPRNBa0LV/r18Wr/ayGkIoutsthYNe1nJ3PE422WR2eH82Hf +LhUCK9Hu0raDFGqrZsxodjIXwXv/hXS3PJBJ/HMnffh0dVIRh/HfSA9q0pH/+v7h6sn88JPFydnh +pixrh/pZHIryl1vv/eNktT4Fe7y9EXTdfLR4cfHVxx18dDg/XjD5AUVY0I3FxV/xhp3/WddGIVGg +U5eQqLT44+XmuSDxFShVJbp+cHyw+Mf95Xpz+pJ0kYNy8kq3q2FjH6QPZ9rL+ijbBkGgpuZXnkXp +YWsSV13748X+6vigGjb2L7N4Qcp65dFc7cjUCb19YleeQVn4eALniZwnWdNaZRl9k+1w7mpnNSx5 +elhxUP5GY65JuW5+o0EDcgsH7nveNPcPlydCL+DI+IcomM/kjm7ycd4MmfBfMMkFqNc3C96sl7oR +ZXU7r+I7GLikLpkQkGlmk5dX4C/pLtP8W4OR6dbfVk/2eI7zw8NMaTfjNU6bb75enjyRJX49tWFs +9SvT03COC/tbi6az3iwwz/WNK0304v6ETxyWHb++LVlM2+dlV1N9pxgWkOjkw9WTD46frmaDjnPF +c5uO9GR5ejTHFZoKFcpj6uYnz46+3nsClrR6+nRPre5JKDy3+RGiZabNd+3luPOzzUJwi+xvc/43 ++0d7R0Ux2rXAk83eocGdm6dNcuc0GhTbXd08PT7d25w92ZxeeXPWlaK+o8PN6eHegVpkiD8ZyUYJ +ey5AEaDTgqc9SJuXYBWGPDk5wH4dHtd2mQsnd3Jw9c51IccvMyF1W5dRdh7hyTo1S6hm7M7tl2aV +9XonhkmTtK7My8/tqrbuh96f12x5JOSkPuwYzu1S29bX4Loctij/B7MnL2b31kKu1xfvGHoZtncn +Fu5P9uH8RvUKTXfxpA+FIV/a36pSpy6Y26TZ9p1GKwrOY3l6J919klwDFxG4g8Vm+ey4EvyvQH6r +C3LJ1pyuTi5Yy+F6rwglT/R91EVtRVqT1qdQny5ZFHtcPV1mrTjanX2uD/ZWa7zYmY9I+87BL6ak +6OqpSDDPV+t/XmFq843ylaKx7OzwJFloL0IaLuHZXr7XzbmtmOt470K8T319c8W+vrl4Ozb7J4f7 +Ly6gXOAIi2OoWgeXzUqO/XB+ctGI7G2TU8Jdoa/nV8J2divHdoq8kVf/QinygH8IlT6XKwrRhZFz +TJZ2bumpCKfZVHHuJlDnfjJfX3BFtN36orvJJusq9dolTcnaL2kD4XIpUtmVhaJLCOtYpiik5god +X0iWIM4cHJ6sn66KqnSFLi8RabTTERG5bEGj1e8Sy44Xz+aDw2snT9+IAAuR98J+hK6eMpz1wjZH +9PcUTNgpcPLa7x9vpuph3egfJ3sjhfCcAYULQjk8ljErc+Gu3p5NpXOzc283e5P+dveWmQwdNOfP +cGi57ZuYtjtcnkxth5Mm6x0Kxq528K/QvXIhGZCGq5P91SUNDs4uabBZVLPeuaGb53NRALMba7dW +KUraZiSh7hqPjUa8YOcZslk2GeRzvJpterK6K4vhHHJ+fLy64CrqtM6O91OPn+093pv9afFkdnfF +BxJ/uf74Tx8/+suN2Tf2Er3lSMSDSmzZJdzJ5DfJ9/otXK+Zkp2jAGbrz/7Ri4ukq6HhSmsTnze8 +tIQeU6wqY7X7dm5YKd55Yg/mm9PsVv7g3ne2fsDx9+jefThnjg+kqwvIKSaGpuXtx/k7JU09mmat ++vytyuN/up6fnFzSkKPTQXmn8ONzRmfTiRf9oqa6puXxBYeam96XjRdshC8sIeinz+WsZ/P1YiaH +PUtK30woLh7bbGbfPl8czzbzb4Cf8+MZ3vpQClitZ8DN2XwDsGbqlgGKq2Fv9tmGXco/x529WJ3N +ToTmz1bHM7ms+AuH1u6eIWP4cjTQWzMZrHx6LGudna7Qxf5itjxF4/nscP4Cbg05hsPlvjp/Nmf7 +zzG9D47vUa0ZutHRjgVFzmR2q6fD8MvN7Oz4a+QF3rv4duaTl67318uTSyTz0UF9crFwMKCKMlm5 +Jpcf6yeLZ3xrddU53KlU68tbf3qRhJRbPhKB7oMi0F3U8tP18qia7fUva6T67kadXfaqejMFK0ZR +RRc0R3qGe4IEGkv/0TI7BsxOnp2/enz2RDD9vghQnwADE90M7SUDfSqItx3GtAvZ5EaRtH56iehf +Lrtyx08r19oV1g4LvLCqT5+fHT05ni8PB7H3wmXcHYTCYcPOmd1FYSIX4pjazYA8dazB+TtGenuX +stmG3nuhDi8uEOML8aXl5f56dSTX79vV+uuBY1wiI+SRU6bqF1c2OlYU5XSpNpg/Xmh73PFBvb4r +Dqd+cyTEr80L56io0xv8p8ow5neK5PmLh6vj1XCjPoA96PaT1UXqyohl7ryM4RzKdaXwgZeXFCe3 +Cg4lRjEMp3TRFUmYuOOO7NZldpOi6SrO2bir+dK+G4Z8cCDcffl0mQXDl7tHV2Z+491KUXWJpNpd +quTuDZtimr8ER/efy1wXu8/pQsKkAvPt/fXqyfz0wfzFYn2RueDc/Sms9uJFTi7FdJUvdbIyiJzo +I9U1rkZyUuMPjveFcU/ozhVQcmfg4zmX4OIIwIu5K3dpzF5f7jTuXOKIO4f/jbD1HI35yjFLF407 +YOy5BPKqKPQyw2Zsr+S291SQvzs/0dDt5WJTLf+lFjCdyU7D0UvFGJyLx+dcgBqdRaeVlkrp7xap +c4yy0ygCDT1nGEFSbe8ss1p7+/HdDz7owr0FLif+6H//8a++fPM3f/rtr9+Zf/HWh+5XH9+88+76 +/aPnbz87/sWH93/x1vVf313O9za/bD/7w3vtf7797mfv/+6h//3bD/7y64fvrs/24/337MPuDeP9 +fzbN5t7f7j17q/nlu+/8795/vfubt042724+sreuvfHuOw9+sS6Nzt79zeHqq3t78deLN++s+v99 +8zefHzwY+vnd8Rtv/b83f9f+59n9e/6Xf7rzt8NfPxQp4/e+e/z3o49uf/rh2Zuj/j48vfPsD//9 +QEb5jf/7/7z7m6/v//Xdtzd7R2/ee+uNs/vX3z94yvXd++ijx3+++/zL3/6iP7y/enpOZ//vV/fm +x+//6f7dpx9+uWvQa2/saPnVe/N5eHJvb+/Xz6Y79svYP317effe8/v3wv/Y2P336tGdwzfefePN +9z7/4g+3P3h8+lxW+stf37/39a/+fv/unf5X3Pdrb9z/xX+99cbd55uPOfnrdw7jH/5+78Pr1+/3 +j9549oXOwTS35u3nn/3187eX//vhgXT7+1/fXD8/PLv17M3w1rt//MsvP3/3N7//9Q== + + + 12/e/eWnXzR/tG989Paz3/3FNQfX/3SyZ/7wuZy+jH3jb3cXv3r4+P2zWx//x+3j/V8fvfnbj+b/ ++e5vlqf7777z6d+Wb/7u0X/fYHNt/NQ9WQ7j7f3iV/3nbfvh8ln76c0//4997xc379x6fnww19V/ +Mf/64bU37j1dvPfk3c9/ff139542f4Y+/Nbp+yf/8eT2u7+5Gf/j3oe/vruPRd648/Hpl8/b/2mf +/UWO6Td/f/fvv99fcKX4q5dv3/w7ut3k1f95de/p45v2nSdvP4/X3rjjv/jw/rvr9fPP/NsP//R7 +INWXXViu2/fe6v/rrQHRpLP3PkI/LX79axpA/tA8+Y8PvDb53cd3An9SXERX77z527Prci73Ds2d +ZvEo/v/svdd28kq3IPoEvMOHyVkBRM45GAMGG7AxJjlhG0zo3X3Tz35mlbKQhAhr9M3Z/9jfAktU +mDVzqBklamXikx0nxUxXAKzdDeDJbi+OSDqTnRA3YikR5KfP1YTpX7iX+xsz+ls3+Of/zOJzcVvy +n8nUCHb9ShRng02oUN71d+hAfxHs0iVnddIs25blXaRrd9wWPc3VLnu/7z5irJWBqDhH9BAvvY7v +lnBqP/bia9hpQfTCDRaMzX+Wr+yRDZn5sDgmPQ8InrmizzuNBm47z1l8QhKKuGswuVKi+OwXTsgf +n381X/If4SGZCudXLLTRXnhgyrc+OoTTIigMFg73Rot64a297QY+vWSEqBX/8uwx0dTNUyEwSdhL +Zs9wg8eDWSTAVJylBPL8wee9RTjVxy9aBU6pwrvPlWaPs02nXrPd2ztH/sMzyJtsgc9UMsYtRQmO +ynOhnmMcgG2uacXSScYJKl128CTOHucM84jwQ/vpOdvN/lbCD9+NbvauV68UFu7COz4Bk012Bou7 +QilbWAhjd7JdauLidiVfQ6vy/RCvbldv+c/tJ1N48z21VNeK3jPZpG+ChACSy8OwzO2rCkwaAIS5 +BxAoFS3kGoMlUXrO0MKufrLdR6u/UPNYnlgm9OvtsotDtO+oANGEqH3+49kci7bsuUH+dVmeUrbo +TwQPAWfZ9JZcO+88T/Z+tojzRWDSxy8eId+fi1MiEeIlUqdUGrvMH+yuEHmYbMUZqDyY6Se8g3Q5 +G34xb7NEah8W3yxOA0/WbMubfkLgv5ULB/6p7/s24bV89rPdrt0rkQskMd3DLI7f1pMAkx/lELPQ +70JbEAw77om24CEjrx44kLcZ2svMEsqR+++n7P1rLc89j2ZfM4lK3g8vvT5ku4WGPUcO92NE8UHx +qfDyT2Yzi9mxzPGkHyZ/PJ8KDBLpu/yvyRbuvL07yelLL0vbzdYi5bK+5MlyvpFBn1LA28gksZjG +0qTXmU8Lf0vJf8G+h/+GvuaoQvo9j3+GvwIm3zeoNnqeZH/NT5BHf8uxg2UTvlI45Ct0qPFwXUSv +JPDL6GtBmCqHXmmKo7CzoPlMNvkQGWHxKeE3cfwKWk0LL0nYbpZdCNoku120pHCrcttFf4vjoaSz +4CGUIOKXrJwUfxVGvJeDEv8ijp7ibaTxACab5HW0PLx15vc93haAcI/hKcySUDm6lO7BpmCWqxwE ++wsELHFsvA0MJZNNDo4k3pX4FQ8mzFxWWUNGE+XwkeCXWRxTHAm7ZPxJGJGdVP7VMFpIzoVFDPR6 +Q9iViCwnASvJ7hRTDksvElLh57tTgJVFKjmlCgBMqmwSQySmPJe0fD158df4qWJS/LJId5Kzkp1p +SsRZDscQJLIqpBIX1tgS2AeLpvgBhiIeVh/QQJVqDEIXYzDQMRSFsVNq7A9vDZMmQOz4sAo0ZI9E +pCF+hR0mQrru8CcW+MJOgSfDf4aYhYfMucIYSRV3tvtQ/y1lHItuoTp/oyTWFnD53yxw8Ubp9XYQ +A6np/0C7ivCy2WdNeNaFZebR0nvPf76MM8XZ8s9usrHiaN+JLkpO+9qV/wjtWqJuohRbkvcYz6OW +ceWW6EytqusZ5P40uLjPBYc+b/Zn1djyahBhQXZANP+x7wzBIPvLSTeUGy+ynd/CXeb+ZTPNfWd+ +SJmVxP62jDTdOVawTDbF2Lnv70mWeXwaxQq1pNmq2Es4Put1suFnb0W2XYk64SlUn7p/2bv3WaO8 +K3yN8PpB55eucfoOqlqxA4pHbao+xKzTygUfqTirg6YYBkzhpd+DzRRNIwXk/vXMFE0jBVniVzNT ++K2xGCExL2AvyMBQMy/Cm0/rK68xu+ulgmtel8GJHSyVW7oYH+ebQHsmR5bbq+j86D1qQFUzm32f +8KTKdReiz7BgdyQURgw7S+N0I0YgYZ+oE8qoqTNEWq27sNhsvIgnt5Jx4bTkcNK3LCRgy7DW3XBu +ceXfP4pbDuOH1CNeCJyLsJToclEPSaiWP40Wh+c9ZFliEkAWSHlpW4AB0U4AVX7TxFvscaVcpmB8 +mGw6RoVk2F2r5Gp9x1kdNVV+9XGvvN98oEnrhUC/koYHbS9tbz62uacrOxFe7qdIijXq07XoAFCj +rDiRjr/mvn8fQCmd2Arc6e8HtuzdOlfJBfc5gvT2tmaeQEZ+OJenl2w0XvfhByy3FNA99RoOd90L +OKZlUOQhzG7tb8u07G44E68PbgD33/8EzIoh2+gue1+ef4HdnNxQmZ45ipdpsiW81sBT0rmnFrlK +1/7GPkp/bPcYypFv/6aCJF8Uwzu0/e3kTp8ZuKXK3CfNrGX5h0svI7elVPzdv8K5YPkjjB0Jzxq1 +XLuVAeE4+GlKzqDdvH/AKMc9EMxxyhdb5auF7z7gRtuX7eZ7veLk9d0jyhxElY9JOpOYvvxmHtse +e+zDc/8J4i/KGo0SQ+uAzVR8hdrG/arKZihzMcW+h0DAyUrZYFJazLUzT+5c2zbaIUbiERkJQTFZ +OycB+7VGOTuukZh7JXyvpRWsoe4vVL/CE7wJZCPzskTfMyBZyKGp3xFMfVocD1F5HtvuIMWw9V4e +hN9g10WKoMrBW+WwbbPrWaRzUF/q3/iVGBkxN0uuQWuXrQ/IOYttyXpzXpj/RL08HjhvsL2fJgr5 +ioXlm76VOeVnvYeczyUZzHY/+u5wfNgogYnunLGDiYKefy8UW7zaFxw8K61A7tvfIWH6+1/EYXih +Hmv2IqPi+MX2BNt8N2f+ci9Owfv0IbCCBvKyIpdHtAr49PIO9v7wU64fYH7+hO10DAygl27j/SP8 +eLu+R+Z6FOtP4pvhBF1cFF/upmPQD+JRmODNVZx5iOds0BltA+o+RtgNcdPTSCD27IXqz+dTLvTQ +92fb7tY7zNLpekplW3kUzi3J+UaqWLHiJhkAtaThBs0l0sGvAC0m7tUWH+narfelscU+QNz3O/cd +sXoLNafLKfXAcwL13bYE3InexN+s9x8qkwZBLnS2RY+beZMqJehM1+PcS+bButsJMzcAGd6BWzK7 +RqmTC3X9Ptkjh5moPpUT3BCcEsEuOXb79fYW+3S0b0H182ZLhUHFrbY18T0Esd+QJz5aPT1rvgSv +PLjDzVn8TvFKfPHiWmLhGGu+xz+L3tWQBGYWIrP3odKo/LNzO9B7XyYby/QPsMiyzNI7dwEmuC0U +p2/jpEQHFV8BFLgD2US0i7PHTEQJfGLrHWJEM9miXxtHXxURb0q3dsSk8oWa+Y1QnSU03N9pD5Dq +BYvZUPqtAbTvrJejolMW/fMsrgeOO12VHFgqydDicQv8vCGqUKLvrTibDBcgC9MR7LWu+5kh8zXL +dgtfHuBK5qXwOlgyt1tfoVrtWzFyFhaJFzAW2sNmtv6Yu5WiZjT7g8jHilUDIdYwzN5P12+8B55K +LnKSvUrNmeSQScXuQgfKObcQL5x+yZe93ztvYGzve7bbtT1KjpiVyNyj3hfSBd175IjuRJeZr0Zp +vLO8iZqLuG5O4eNnKbx1n1/ht5U1tnMOzy+0AW4JzGBbyi9yP8Bcvhmw5GzRwzcTzszGF91n72KJ +Tv523rDkm/kHUpOiI9FVYFacrio+/J4O7QO/eByBaK3e5H48dlJ75la62Ycz/ZRE+xRDYYjhg5LF +trhxyjtEKt8g19x/QG3Vpnh0LP7a9+sF1seIGujQEqsFv/LjjKyA/Re/Tbbc11crA6Zwe4ejYYlK +YVzNPHSrk1L2e4LRxl3c2atmfubavuDvzH2ZWPNrKSeALlDYbz7buLf/SXnbxjLHkZGgF/jzeFbK +z35IKTOr7XfazGw+n3VjzZfpvvT6Qv2U8m9pWoG/Ivay2gX3Q+TaZiFhI5ZPQBF9Z+HNvrYwu/ou +WRp/+wOSl1nULGzd4diL5z73HW57lOdCu35pYB5B4DDZoMOxipKP9UA2Ut7ucr7Ilw8Fj/qZrat/ +U6jXRn8sLUoP7DVYymff1sDlngNMbHpn1/8tuhNf+uso0pQqQCojH/ZdZDvfa7dEfvIKJiNRXjEd +4wBzctZ/AsWpAFy8m/kTsUmwxRjLFljO7TYTK9kmTJrplxGmpw8E9OfsSTDHdwdU8GIxYxZdctbS +jWjlubTDjIKfBUW0gMXVmXjdmn0rvFtGwXBs7c+DjfHpPhjsbbECii88JVxW2xix7QRSMdaaUhr4 +GMjpeyT8n4svX7sZiiNHDikQUU7O7YzdeugnFJUwn8S2hb3I+L3gLUATVCxw0qP3Uj5TBX3b2w0B +ig9rEuJbZovdbDjaeY8GX3M/sMkcoXgFpJjwUvxt35ogt5SLiwJxoKSz3Yf0MpNIrR/BICPsKrMs +ckvHrpYLDm56leRz0KHYqYReZHuVUSA3jtP/nPteVptAG8WV5JgoJrNCtFjjw1K0BWhtGJXuRVXX +5RQZucLLrswJmv7d8l3JSFavHyFW8T0UnSGwxD3N1VfhLVr7Lkzdn7Zo43WTABb2e4M1XKVeg9hD +rJkPgPFRTwRYI5xq3/tKRfLNWYplOzf8cT46wW7uBphkKZsCbsnY1qFCdfJ9IAOo75YLoDNCjqyh +v1Cv3uQV5JPw7luDUobYjeHMf6coLAcyh+ihX0QpoBz6lZP7Ur7jdrpY1T7cDb9IRMKhghkHRvKT +jX48Ny2lQuv2vmRbB98yscfFe4bODYOi0MaCFWEyd9JFzGaJpbk0BkSr72VOwNYw3B1XGJxKIPdR +MswfGS2BRCbemdSfu1aY5SfLgvszMBOJS9iLQFkCoglq0LMsSQXN92rZIOsOmMIL8cr8EdvP/FfG +L9H6CKoFCJ8tzpnitJt9BLn/Hhwti7PQLiPxLbIv3TlGRR8T/gQou29Y5whPKkWpfBntP0AMVh0I +GZ6z4dHAklsWHF/F4WzK+pDBEpeNuALcqfhK2Y55w+V5yIYF26jeLbld5RomAOXTRcwel8Bu2l90 +QBSnKiZbuTsGC5v3f2Io90GnWHuA6a9i4R6IKOnhvD6SuW8f2S0PI91etrNqvKIRi5xqUJpt1eDO +8rFn+eFweSBU27lDMinB9FrzAEj7nlfukmUyCV/JwmzalTSyTu1IH/sA/GUmmd98+w== + + + tjD6HFgwwXH2PlBbbpZtWZgHEX8jXesvUwgUv2ylYqRTEUgFvVycJzzr+FdpnMqCBvDzXVZzpItC +G8f312x+lcy/3QYeeVtylG0lRwin9SQmb28LuekpGQflEt0rbQNhFDgXW8k3BEUmty+5NtWoFBvb +zxawCHKR7N2aKWdXf9tAtmWd3YmQUEwVq00ebgXYSXRZrPOL6678wOsTON8IGCd8TkBIiuLfO2tx +NvXOkUROc3/7ubEj+2SMOFFCBpFRGEjKt0eWeD48Bit4bgfbwTfJrrKLEmN5mQ9Zgy3FjF/i1btK +h4n1e1P8FNB59Fq2AX1zvKZGvKMUCBegxbNPAgwmZhkx8YdRBmZhyeI2Hgj/PCc/w+HA9o3ObmZV +0rOMkTYyFB17ireeaDbi83gBLbrb4ixVgcF69rU12iv2sc6QtDd7TdGJkoovArCX3cqX+hk/bxFV +tp2foFvGP4DVUxFisctEiFrpwU9nm3SGqFVmqZA57yZBYP7cgDTsTXGWj5X+vymhyI1Ct8r8u8OF +P9t/BXzTMJdtyN5odHB/4C9f4R+OMpKbkuQDiYmqTrGkik0+RJXnK/Y1yd2cByMcJvCiTFPF5UPr +yS9/h8sZV+F8/i6/tzv/TLw3lS/8q/4u/6HOTZKKP0ITIB+r/6l8zhcKuAHmTf7X4nb/vftcfy+y +B1caCfdFhcRNtT7/9+Ibxn9bHMyarVKE3ouyewcBlNmq2Ll18jvnKgn0rh5kf9RAecmwWvwjfI3x +QUKtbCbyX7F1f/JU7K+OzyWFE17eHZc53ZXWJ6u/cq9Iypbc7YruIkTVOllZ1XFYhs3wDpvPHOC6 +hOW0LvzC7+ZRdUKeq07oyKoT1As0ZIgPA+jdKSm7AxFB7uge5a+J0JLDAb1zBBDsQDqQOL49dghj ++4v++12Jd7qhkkhU8YGuDDlgBvweFRfAHQJL+2hIxYGrjIWf3z+UUTUcuoH4MLEcHhZ/pos5CyPF +IuAhuvWyvtgoMRqe9Cfrw9db72/ypGz4W6FbUF3QYe0YGmCzmH1uD0kIHnUXAAThSjJa/A3utyeO +Rkm29jtbiVeJkrLB/vfu7rc1kVy/pMv5st/f9wuUdi6pLxaBhIQEvtx5PVEmvHObZasSdyprAYn0 ++IGqI1Dunvbj2xUq/h1vF++IhyrRRfnaGjYm3F56IE7iQrdCeec+hHRsRz8EHv6ZCdcJSP+imkHv +SYVew570wzRABDy3Pk/6Y0ejT1Qw0Y7RwoO28Ak/iNPp7i4HBmB5iUK6E5QZnRKegs7fYT7Mrte3 +iNlT/gMt2+zL0kOzbUHWzZ6ZP2/21aJ9sye1rPnpRhQ+lM324Ja2tvH0wfTda4qovNbSaHFcluVi +k9sXPbeNRzD2zPf808LSH9iGKtHXbjkJVuljbtHJBLbvidiodRstDAvpj3iajPhzrh/7fX5U/S4U +n149E9KdDf+CluJqc5OesDWAGLs5upI0+wKODtpGwuxqDqNm78cn3rXf7NnH7s3e237B7CNuKSKQ +HDjx1rhJqe0tXjzeKZ1DLVWHzM8Qx9fCjzQxx+fCPScq40V+s0klp1nvulnL1KPbVKSSePSXVsPg +Q3HzPCQKw9KgW0pmkzPl1vI+d56YO57yPFCdP+jpGq8GtDlYWZA9stxq22Q/ceBobDebYOGTCPSX +YeUrCASb58lTEM4vsufOj98VHEmkTO0Hr1P4Wv6GWeb2QUE6bHzb34xchVsiELx3Ss8cdgq/9QyD +N1TMDT8j8V7uJJOOekxBbVKTDU8batPLDZ5WZdLXzehv19OYND9lOhMfpTrpNvJI4knRuRzstRKM +2rJL9UkTN/atw7paq0262b/6rc6ptfOsmJTDMU+CaqjuFSZlLJaHYTOkPmlwMCRKOeZOdac3pa+I +9ZeOt/C5HOyVKL3NKpqT2qngoKg16ZwolzcDxaQwCwvg0l+PynenaNLg6uBUHT8xbtKWw6FAJXrz +gGwQmBSwe1qUn+nTZlR4QHuBaV2HpxocBXf+nk990nWlpjkp0yTiFsWkaBZu2tnmJUL21SdtFt2W +P2Z/qzbp1rLOlbQmraSpX3KIaV9lr0HXwBP/7jXVJgVUSrrcmUf3RG1SohQtphSTchwGn6r1/mET +15h0MCJKo0pHdac3pW3ctgw83KtOWvbum0CV6ntlLI7Fe+ZOfdKEOQDmTsuKJnUfgLddcqfDGTMC +b3iNJzXZJNM2wrkBN+nA51RMytw3lg/spMXnZUm202GGaDwVQ6qT3lT+wPYNLy1tRpxWMumte/Op +OWlmOc5nNSZ9chH3scVWnBTXtAnT1n3P9fnCu1Od9H6cjmtO2nyu1HJak+YBkx8c/Yj6XhuW/f37 +dB5RnfShQa40J+2VA+VvcVLAMdm0deJhTWc0Jk27Hl4eX7Oqkz6mp27NSUEzGmd3jxp7fQ4So7uu +S33S5t37V7+QcKtOOtr52+KkcC7yaX9aHntfa9ISMW7/JdQnvcu4Nk/ZbV5tUjiX4peP0dhrpGJ+ +bBINdtLJza4sJ5r0Zv/4FESTeg6I5s4Sd73sf8YwaXJjsin3+uruWLlJl1G3bNLQh5245SQN5Ug5 +K/JJ/Zvte82CJvUpJjXZgEE0/OZnC1OCaTPbA6n6vIqyk6adRa8CvOZs6c7BTjraxWpyRtjzxCvJ +Gpo0gHBMyQp7pC/csH/BpKW9ctLNZ9rFTRpr++U7rfRyNnsCT0qne42GOKnJBnu1PG1D06cWmpY4 +ZPpR+01/167CpNQBd95kp789j41OqD/NRRyDXuO5hiXy4fP9xJwgqs+encZTR4qcbFsWtadwAiWv +2ZazFtBTNQ5Tmf4y4ZKVRM8P0Oam8rFmfh0MrfH0dxO+G1VCak/R6Vd2uwiZGobVf121mzN3j8W2 +xtNdvF6tWbbqT+vEqOHxhPYsxFSeM+NmJrV3aDytv7Vi4Qef6tNIc0i6nOmnEXrqVYFYg7AKZ6nE +eXjK2HuTp2JK42nC+ZBPPGbUniKINXLuR+vmM6fx64p3nGe6z+pPb7Olr6SLdqk/bXY+vrbjooeF +mMrz/tcPvQ1QGk9//la+5SKi/nQwavG6M/dUDrGR+wnjt/qvx38PPD9UeTrpU8kbb7ikBbFFv1na +3dwt1H/9Row+HF/VG9Wntsf2/MFpbqbVnm42yXGbzrSdThZi/sPnVK561879oKeBQ4of/2zNI0dB +fJpauxJrwQpcYzaTilasX5z9AsZZK48Mtg5wpUZYy/TmjGt3PU6avYXOo9n78AK25njeNTufXHv0 +qYVsUjCy6+OQxHpLJVdLvJf7DJ5RnDtwG/l1gCnY3yOO7gT2+JYQJrUEPpNTF+hoN8VtpBWQc77N +DeVItnysaovsHJk+lrLQiIXXfrAYQZbOUmS40kmDrmftSW9KLz61STkrCVs6Ei4vnRRUW7B0xhqT +Dl50Ji2bQwpMlu4VWzrCpLRs0kgFaf/P/KTlbzl4R9JJg/dWPKnJxgG4nelI9jq32y3ipFj715g0 +9IG0/7X6pMHBAE8q6GP8tDyA3wnNSbH2rzEpY0Ha/1QxKfYqsNNO1PbKA5iIaU6KdQrNSZFG0RP1 +MSWAvTqTlqp2BSqRXtAW8PT4E3cMzf384PTV37yzLIyMeHOXNGu+B6cvvLnZj5c2Cb9Au5Y5xKSE +C7/2OiVuGfiURxpcFYOFhyxH7yZbKlq+6wCUb73cP2miKprrnNco6O1Iqall/5H6jyadHCwztkqt +nfOukjHB9DmTLfCxKOB/LMIEbjXnF6zmqUC6c18l9Aot8z0B00ulijbJP6wji9OY2+j0pZ67Nlro +H/8St2FxyUQtZLPhfxAyyEwFbl13wg4KntSUrnCeqwPIl3st+GpHTo29W7EolSVt9ZcU+LTEvCb2 +PyxEVT2hLNAbe02gCyDH/3SkVjW/P54n4x2myXpDgiKq+8P/TPoF/fOj0w/dW/H8RItPfoLeWw5j +WJtGdX9xt9Hz4z0k2idYvv89DVgqQ8Es3GAP2uh+ErITb46/vgLunB/mZMxakROro3KMcni4o1l0 +IB+4DuVg7+h0ezawFKxn4P1Vsp7ic34NfEwygbD/E0/jpUgWR9uyMACtAKCJB2G5bueUMhXYFZ/v +drqrwTLAi/55krpNVaiyiKzguhrj1qJKl+bWaGu83hC3pkWVR7b2bDkOaDtLQ6ysVFsKsZiMe0d3 +5bLjXakj+8C7FsUECzHlaRnbUMEvw3OBDGV4TixafjvCMam2fic5plT5+e8kwKiC5S3m5D29h4C5 +awtoI0ppj85gef+T5lCsdqE3mILuptRKSXeTm8aRPZsM0t2kJLyiSnfAs4pe9h/urEhJPEuOyVP6 +xsiBon846YPd0Cq4Mbm5JcWhZOeCngc+Vp7k4cpif+oIO6X+qNwwWlPfpDfnxOqXySbXwvSOZBlZ +K44Eftvb6HJalvWwp6/KfITXywgwJQ2F4LjGKEYT4PV5Wc5XDwWT3vlKX15G9gqxJOhjMv3JgPYE +i5+a9YGF9seKQUlcTGVR0RtNWSmuxsCS8Ol/WLQWlRFp1sj5aSl0WOdHbHa8d+ifoHh+CpXOwPkJ +nP/gBDeCsLoYGTboXByT4nUG07Q7BLl/ymAnY7wOxI7pdSdBTM5rLxpMztFOhhjn1+IQjcr1Bz65 +4VpBpFLUtEpMNuPa8S6l5BzaCq0WH3uvGFew1TWFitISv4Aq3yvUaJ+rn2AoB1daOLZL286Ejrga +kUfwGuwZ0Cm3foyaCpp7SW2PMQUjC3kQrKTjS9FcyDEuwC9EW7esHOiWZy2Eg5hR2xDpUS5VqZnr +j4P6qGI6sA3ZsKTg5Jbmc8VwmLsjdWw7CzsDuGiSTiB3awjQqSIDt3zMqSFhHmzCggSAOLsDL6qo +LeNV7WHtJR0yALm9b5gBfFVPYgAmm9oOhf3Zr7M/RC+x9u0lQBfxQFNTMNnUsVZDl6dG2w/y9P1x +ceSDEywP1qf4M7Rs8q8q8UbeDOSWxfnA0pfrppOAFToTGVieLCfx5O6AxMna3oCRpuldknhIakoS +P92XAHqyVW01SLs41aigrTG//bgjQOJlxFEeVVKqKTX4s7bmFGn/mINDSwTVDsSyhnvDZNNzcPzU +iMV2+Xjhhmp7gJiul86A34e2Rv+C+hhoMgiY8eYUz6PSXyNyfoCOjsdGjRXIPA1yVRqlKxOiKs16 +retKZfrYBBqqNLB3yzF6OQ67umZMSl8MqnkU13W5INTACJkmrLW1K9BLXSkBtfDcZNPB9FjbLBd/ +5+B5umdDnl6DHk6ds1KIPC1fn66Hc13H8u4SBsBqF+Zj7kJjuiyCTtgQJhvTZV1Ojzx/A3bVv9ek +OsHiM2rCAhM+nfPJc+HQrhaTsU8fI4xKOzRUwBi9HPe3osGIy3lyHuCZ2V/ii8fngs/NkNDTw3g8 +ijxSKImKnjjOMQpUG0WaocqPc3GkAo8ilXsyu9Kg5JMNJo8Pagwl8VzpucXL979KfQ== + + + E/3NaIRB5JZafi802KXihrcr8WpR2OeUGJ8mKLsKUGqfizTMrcfR3CocrafgaPL8sdM42sPKKEdj +z0VVyiG1MnAdjoZuLd0uSSMC0whH2y6pyzWlPBgI9zeX037vKhytp+Bo2jh2fBzjHE1iiauMczlH +62GOJs8ikIVeiMWuF+CwSF0XkB9YnNC0oJGmJAkdqmspHDJwC3GAAZxyK5K6cOKD5sZPyrnqP5xp +Rstjr3CglwRylUMJTFY3vn9cq0eDKbIf1IYyHVGmUabOEaPRADEj6/W54Ll4HDSKthpnsp0yjuEU +CMUoEj8MHucIEza4GiXlHER4dVVyxWCGvX58/pieNPSqSMPHk6xqLCs1peHz38WeDWRhkccsPsP6 +PQxGG8MxA9IQBjuDfGR1SfhUJzcL66X8/lEhC8+VYo+a+v1pUuzxTP3+cJTnPyO5cMfHGWsmkrCy +0GQzLA0nN7eUJhnqy0KTTU0aoqRwr0IaHuS+nJAEqNSU+nrSUJqHJaZhaO4e1vWyl0cSpSuTKRYi +QWp4LJCpoKpRSm1k49QdcxoiSBXaPvQqwGAhA4MZwBeA2K9NG2InGZd9Azqv6Wj8FIhBz3VtKDNP +9PTiRWmrrAZUTYVY8otiSTLL4EruXmRSKsSSXOvjc9d0MtekRzIQc+n1QSnNUtNGllx/qW8bGc+2 +RYP9GRAt2gn1sqF2tit5SAaG/MlwkqLc18pChLM0lHzLoYWqigF7ecv7A/JsKdVsRjF/7siSVNzC +IiYfJy/OAyRqlGxSuMp80mo5Z8caNtnM3o+ve1Qb1zD7Ir7xmTV0+hV0uFL4CjV03HwaFXQcxC6u +odOvoMN3qlyhhk51UqGCjrf4Lq2h06+g4+9UubSGTnVSoYKOt18uraHTr6DjqwUvraHTr6DTrBY8 +sYZO/z2T7To1dPoVdCqVXGfV0OnnQwvxygtr6BQJyQp5LZfILfvagNkr1eu064Ayf3IpdsKi5Eva +HCt7S06dkiw17Yqp6+SvIm7ZshvJCTVSK+DOtlRzySVRHoNwchzJMxPhJL0fRg1OSkGvTC1CMt5Y +EZ5HEeO7BJ/iXv39mVR3qLo/lco5o/uT+pTQovynA119SbJQDs5PPhfo2g7k4/RirGhOX21WoKtW +tu3Au7nU61cUWasoKw0lgxyewUvRQGzOZMxtPPAZKiXS2hpL+0WjySD6xW6aqSDyTMhjxW5HAv9G +PL3Fa7iqUH2ans5vHDA6AQcNM0Qbk9cGKrS0bRp5ChboY5ObskeuRJSO2eQG2cPkpq/jUzJi9kqW +dLzE1GSwyHRS0otlH3OcKT29Jd3EACOOM7nb0MNxGJn/fl6+XgGRpLBfflfnqXVggGNPO31N8JQ6 +Prm75VAiHWGt0jq+o7rX7Up0WuksaZeuKZYksfeNFBdKlqSdAy8cnXB+R+r4rMdk7gl1fL+aweST +6LOsWRMj1S1PGOzILQjKoYSbWlUHO3ILguF14djrkaz6UzapXjFzJsS0QyFnQOzIVQj665I4fjFP +Dm8OUp12qaP3ixjRZd8r2OerWzEkELvmEMfKFrkBNONi75WjDKdLsv8c4c67tNVkpMTNgLGncO0q +DlGIJnBqgqoqRuUGN3aDpr6GDxYVYhm2WjRgcqxQzmTkkJWREW2LR6PAzRDtH4Nnf6wdYjywKzXB +cZJ4U4tJsBymYoDOjeqR1Gg79cu1yCp747R2XeyBHqld6fOrXQKvxGTd8qNj5XFyriNRIBWx16/q +lcqTYUk2HX3sNIof7ZxGyNV0tL7AWXScCSdFfvJX9UT3zqmVcfLqp6OL4srZTvLIwJKEO7sOFkVf +DCduSco7Vc6H05GiOKXnSrYouUcmTda2Co8MbY2u9dPWlTimVZ5D1i9yW+DCJgSxs8pzDs/gp6bp +kZH7LgyU55B1x+lbU9qVtcs9MqgMTeGROec+JVSGdiSdQ7Eh1YrU2jU8Mqj+jPfIaHnhjAHGaHEO +n6ekWZ4D0GEuSCnhT58n+8z+oA411jYfy5Qzoiyv69eoSUz3SP3MLYvk1iZ9q6V+yb1hCom8rhvI +nT26taRLsTWJR9Eghq7rp98bdngnJDpzndQF43V1QYV2cWZdnfHcdU0rCdXVGSgh0SodlcMGWRaa +TtCjxXWKRD2Y2eJQxFFxv5kjOYrGYmVH6+EM3dd3cT2cLD9ZqIi7dj3cuTh2Wj2cdobqNevhLs9Q +NVIPZ6Ai9Qr1cGK14GWV4LIlHbi9VbmlxmDn18MJVWmnlWqcWA+ndw/J9erh2HNRVsRdux6OnUVZ +EXdmWAd5UlQ50en1YiX9Pat6GVV1y/zBJcPn50TiLInLab9nQH83HQ0dAhu6+BpS7IdB41x6rQUe +RWE8a9SJGxjnrBp7RSUXGsdYKO84R+uJRKh6m9bpGc8eBRlyJWw8EWpnERgiQzgIIxVRpuO1TJdd +BCzxKKLBHsxXIsPi80CZMn26Ng7wPtmMVrmhHaT4FW4DxqPwRHi+9YrH0SLDE+7uYMe58KoLPArK +tb6Kas8uSX7BzOHdgydcMYP251H4sNDfjtYkGjOpUQ3SNSpSn/+uVpEKQ12vIvX57yoVqeSNkaKb +oxWpk5tb78XjoFG0+eYJFakwzrmVpLKKVBjnyIUiBlejvA9AavEZqOVWEIjmpamKJCONag4lGcac +3gMyjDmPCDCj2bbXKoXjpJhYDHdmRo98k0rf6dl3QZ9UCmc6Wuh6jVI4EWK/J/U2OK0UTseu1GBc +55TCaXsVrlkKx+r8kmI4YZajpXBGFcO8X6+2+sQb4VFdnSxBQhEZOb2u7tSIjfa5DK7WeKKP7rc0 +cpGhER1mupVfRK4ZSzLAifP+gGZSreY1wQfV6CjzQFvInCgcUFUdwghJ1s1ZOaicB6jN9oxTRWcx +4w43uQy/Pb2FC8PSw30msMs1ipuX5DjZLSzJfC5QeyxYFrX7Qtpz302uXj0MfCq34D1HvtR/Ls0p +R+qmwAoj7O6V+JMFn5Ks2K2ZllZjKYrdLA+DltR9JSsAS8XyTwO1qjNUYRd09TXrzjb71xipOSlR +Ity3GpMyFmu44xppVtgNdCvs1rT2pGXLsKc2KVdh56hO/e9a1VgunWK3VoiSTCovANs6wvaNRFNS +FruhJpffGnVnLp0Ku5vSxK82qdCPr54QT/Wg2C3YLLxqFbuN9drFWRmZB15RYVduW4Yak0YqtrvP +24nWpB3dfnzN+oMmgIlisVeSn6qVva6A/8RV4u3dyYDaewjHFG/SecLAiMSrO5Y18J4nttoVpff0 +wq4HQaUqKoRwVMRpXi/nXppyq3GXmlyDBaCGXPIYUeGk9Cb9PlZJA1c1H2n6hZfEzqJ3mbjh0p68 +dj6pWs7VZZ3k1LTfg9sbLu4kJzk6QdZrdcozDCf5pWdHc650+qIRWveIq+b16fZ9u0ITOX6og+Rp +pTZuFA9WR5uNSPeHb6DSXNSRXgOGl2Sgz8gxoPNL0kmlPI1eVsfuy1dLdgVlSqb1XaWaTiuacN1q +OjVt22S7djWdmsNLxdN7YTWdWi2d1s2T51fTqSWAqOcoXlJNJz0rPox95K6bM6rpTvZan1VNp43J +16ymU6ulO8yCvrSaTu0EOA5zxWo6NbtZrYL7smo65boQG9WOvZ5bTadWS6dfM3JONZ1CuQlIOuRe +sZpO7XSV9v7l1XQisERa0+qXdH41nYAlklo6iUS+UjWd2vkJOSRXq6ZTq6U70JQurqZTG4rLubpi +NZ12hPea1XRq9TSXQOyYTngSxE6sptOH2LWq6dRq6dBerltNp0ZX0r4816mm08yGumo13bGaketU +06nVfh1YrxdX06nV0qnEki6splM7IUWu9RWq6QzR/sXVdGrAkEfer1FNp1ZLZ+AOIq3wAVqSQQNQ +HhlRFO84Cxtl493R9v2IiqFWRqeSne4smk9hONqFTyK3MKRdnNSvTk3hMaBdnNivTi19QtKP70i/ +OqNwUutsq8iDNQino4qFAgU07iFBrdw0O9GeuiSUQXQ6XqouSVf6mE5Z1DENQHNJMg6DW95pp1Kc +BqfFzjCH6WhZRCqR55+aXCSoxSsNucHObXMnh5hGo7vTVXJFmztjfUYubXOn2y2Lb3R3SdEjJuGL +85MNtbk7mp+MCukuLikz2Qw0ujMGGJ3iBtVOE1ppCme3ueNlZV6v0R1fVHW2V0iq9dHpnsdyITKs +61ers0jH2oaKXwWVG99wqK50w9Zizou3hkWnVq6C8UI6I912juRa10+6hl9zQyjb1lj2rw7hovpC +rbQe41VpCDCXFL9KMyHrBotgDNYTtX5EQ1nsY9X60RR1pwg6VK7mV57kGdnp99fMhrq/XjbUvcFs +qCOZ4a0fzUSo0yofXSeFQhSj8PY+Gufimlp2FBWRJ+eWBsfRpUDDfRJd12k0yQ6FdNXj3NJgYa3K +BcXwt+TmSrcCosHy+sUrNpPhihMYjDLUY0jiLlJ0AJEC82vhNlSjLDEk9TKoQVtzoUiiPIca/nqk +SZPBQoaeqLpfUpnysLpiB8OH1RU7GD6sLr4gAEFbtdHQ6ZWPcffp6u5hj6GDe4rPKh2AUSQh4rMr +uA8vKNYZBdkvOuPICyuMN+I5sCwwgRgtZTBUyOD4cyuIkNXHjhyEQTLU7nB3Un3l2R3u1GvfrtS3 +Wuhwd5k2brTDnYHKxyt0uGM75V2cY3Gkw91pnfKuUpek0uPu9PoQYShSwWFOG+yMDncqWTdG6yfI +G8MA1ONjugkbJ6k5uPZtbKC5qqHC2snNVNVhcFqv58cz76c6qHy8RmEtGkXmzTov5wqNc4pprXVH +Nx7n8sJaNIrevXCn1bc/6gaiM4hbnljf7lMhw76+X8tkM06GMafBkpWDIiY1KTbe6FhbJxYx9bHZ +LjuXsy+eg8F0zXbhVnNDhnv/zCImdYjpW+/Gi5hiTj9HLyeVMSkYF8DzQZsxixhhMrwogxihqhgK +nb5F1TDv9x3UuOb9R3t+6ymG8k5512v3mOt/mLUjI6fWuOb92v1XxYgNlwt3rMY17zdULK6VsyHL +iIDBLnJPSiEmy964sFOesUuqLFy0WkM8oCZ5F7Z7FC0LvKgr1LiK1EsESmOfeg4JX2i2yG82adLG +Ful10+FBYVgadAvD4iaTrTDdWj7nn+XzuUAdpXHer3nBY/uWL47zLqHKKUwvfB+23vr7Sb35W8L8 +pNPmrh1rSbFSVg/nic/ubuWZ9vI+bLaEeaXVcU678m97U5oHFJPi+/mF2r9urq0xKWORVYkpJ33V +a3Pni8o8V8o+bDHPVphUWZoW7H804hqVfzdORWkae+usUOVIqpbhsQBOxH+0O87p9NYLDp5MNr3a +vx/tgkOitOp2NSe1NxYfc3FS2Its2oVOlWOz3deetNh8KmuC12STNS9U7rV9cKpAmtz0+BOH5zH9 +9xAf496MGxox+Nww9p6rxb7H1yZQDUZF7eRJt7T/VopOwU+sxo7UpJ2yo4FcW/Uc3g== + + + L9eyr05Pm1TvYnYsFUbpIdGu/vkTb5+7JJcTlnQ8EdNkOx7qKhhNrTLQmeWpcHFqFQ8nhzIBTScT +Uh9OaqlVZ1alnZRapVuVdixH0zg+rTRR87TcnsIp7Q8kS1KxLNCijGYJH1vSWBFLOh/oBrK0DNKL +LE9LYWazqzm0c5Q3hPhXB+xq4F1fw8f8UlT2TDnDB2v01jgjvZ+KF8etRQ7zUrw4ygNbe77cP/ZS +PNOvJfePwZlfHLJW8ywfcEtjVYAnXkKrJitRFeCVrmxEQ+X9T5p+GMMtuXmlekqtlDWzk5vG37Fo +tSEOM6X217KRL3YGS/z8Jd2sudMcAegSMkrh5z/15iG5T4W9GUKWQFA+9PNfUN2mo7cZuSNC8voy +sru4kIyLIx/cP3ZJjdWh8ibvX6nwxmpXty007zkwpI1LF6Xg91qlgAbOD+WOSvn9BaWcUe3GW8Kd +kIZLAR98pyODRpcZGOxoBy3j65LcRHH5YNrxwTMgptrf51yIHS0MMr4u+poQC+pATByHG0xDP7yk +o56k/uWMKkCjNYAoXnl+FaDRGkCT7ZIqwHP8yadXASpRQKsGULUDu+EqQE07QCsb6qwqQKM1gEKm +yllVgEbhycvK86oAFZSjiW0aNrLBKkCjNYAqNrJ+FSC3moNdKbQneVM+FseqJ91adXpTPlVM1q3a +Oqcpn5plcf2mfDpeOMOFw8eb8mE/vxE4XdSUT9T6/sumfEe8cFdqyqdTM3LFpnyHt5r/F035VO8b +14NTI/ispTv3jN0NdUFfP30rl60auLyv3xXvhtLp63fq3VDn9fVTbu0Kd0Op9PXT9wqp68mn9/VT +P6tr3A0l7eun7y7Tr6803tfvWObwdfr68USq3tVP55bmExy66/oV+osZ6Oun73OQVXJdqxDpoKvf +Wf0rVfr6ne63PKevn2rVneBx0u3OcEJfP33C1c5QPa2vn+YJHeYonnlxNoKOfsWM6Qj9Gu3rp4/n +Cn3s7L5+hqvSLurrJ3lZpaufhp//uN6q6Ot3Lo6d1tdPK2Hq/jo171xfPyP1Ypf39dMfRezHdzEF +6nT1U0aszu3rp5/mpncLzSl9/fQtNc1c6xP7+umVp9z/GuxkdLSvX0q3q5/yXM7t65fS7eqn4ofR +TbheaPT1O70q7Zy+fmrMQ7zw+Yhuabiv3+W0b6Svn8F+fJfXPeh09Tu5H99ZVwqo9OO7vO7hoKuf +IsZ3dl8/tdiVGOE0GdTlj/X1U984T4RCX54L+/oZqEq7Ql8/vn5LvaufHh87pa/f6dr4OX391MoR +RSK8sB/f8ct0DPbju/RmD74f3zX6+un7v4TKlAv7+p1zo87pff30DWrFDYdn9/WT7fmgq5+K9XpW +Xz99Ncd0pb5+x25tuk5fP/2ufqf14zuXbyr78Z1bPysfRWk+nZFzpdLX71gxPNIurtHXTz87h4sm +XNzXT7cYvn/YzeSSmietrn6sFLu8r5++2c7eA395Xz99s521Xy7v68dDTL2r3xl2pWpfP027Uisq +elZfP70lPf8ZvG3ekGKo3dXvSK2o4b5++uWPJhWBck5fP/2CWFV97Iy+flrnwnb1O+5RNNbXT78g +9iQdRqevn35w4fB2oPP6+inpU97VTz/f0nhfP32MUHhHde9KaQT9B8KhEdSp6mblgtAvSfMSUwdt +jS4DCteubgxTNfFe2l9MXriozBKW+7DsMrJ3/kgdXpgxCw1BUJGAWCnciEjd3XJbFFWEmZ1Prr3Z +F3Dc+ulG1Mq/0thuNtQ2a3a/b9oBny1mpx9vQ9kQ49l+VAOr/cRRWUSiJps7/WQd3pirO5c5W+oE +bgYvTMx6/2gp2Ja/9w3H4mPtY+4bf+Pwct54zyxfmx/1xX002nyu/D3ck+v62/1H+/O7Vw7c7h/G +ZZdzPM57XF+D0NfdT8sTf1t7hpmdybax3Tsdmw1tNd+sFquAjbB+xF3DxuzBE/XcOlN/1p8GMbf9 +FjabdKxldo/Kt2Yqd/ftic+CGaJEpFNEqftYIsqWVZMo3zU/NpvPtG+z/0g5tg5vc4o2bub68Xni +qb+iJxlpPqEjMeOyN6L4EB5vtu81CxG4W6jydu5ccHVparsrDEvZRimZTc7EFpC4VNNkczlyfx11 +YH2TwfuPnvVvk/llmubHZt2jvdP9q9/qttv6LWsk/p2zte7LNcfrfTUZjNpvGbEiNfQBB/Vc9IUb +9i9ADE9pe1Oq+sybz1EAFXB2QLTcbeTUlJeSz6vtW+ZZRcoE523NIarkNyfKHykk0mFHzL6igsXH +3N9DJrBzFzzR4DSQK1KVDPzttpZ563Wb2Qrz2vREQ8l0KWrtzPOjmqWCd0rlBp4ip/WxvfBS5Ucn +irA4PQWvbV9yVqpVsvgSS+Q/JwESHc5vcbb8ixKB/tJHjStzLxGY/PmQjLeijAgf+i0IzORqSad7 +N34crBFvnbU4sDFEBEJBF/4KEMus4GvMg78COXf+4GvGx34dbRde/Im2JhKvpbHrqU68vWTeM/GG +eQOrrjs9xYd+JVt/fBwRc6czZrJxC03F3NmfVWOLH0l3kMp4xQcgthop/kHJL3nwYqbHeD7Su86L +85EYLCYbC5hy7g85b5tuCbDKPeeUf73plT54D86FB35cHElWrBkCw46s+Eo0ekBi2JGVdIfG59KW +jj199yBlpO1lX5pZwzEObYABYowhZ74kiV4JoOqnH3KWrkbQV27YWbuHZmmjstSEBUHWg/MuNjb2 +BF2+ILr+o+sTJ6Vc6UwczRJH9912ct/+d3e2NXtrFOpV871o7xP8rYB5ueOI9R5Jogk5ylUpJS4e +UTpeu5HE45lsaMRcaNeyLsqjYeQ9e7+3fhaH8xaBdkUKyPIKVvdLhjv4wQtdKlK3CE7doGTjhXR4 +xh/Yow8DkCq08wF8Lo8B1pCGTzD2dORCn0hOvIcesXRaoU+08CnIDlGM/zDwdciNOJ7hgx8G+N8O +CSEqGhqSkvW8Ui+f/HqGtPRBYWnlqHL5FeL3MuQqcwmXNUJQ3/e2ojfqesnEiQeryEYwVTq5S1XZ +DYn/cMEVTl6nQiO/OCltd90hoI7gn8GjE30ihU+U9L3b9yDeyyiosp526fVhkC94Iq5SqXj7EOFE +9e4nRCymMQZzE4H2h1LFASkEklLj5NqGLAuec2LGdiLfDAUT8ClRywS26zRmnoX9pHWn4JtgWWDO +qWg8zB1e7Ye1xUCyuVjCntzUMKvz8K88/CHE9iMYI2A9b9HTgICazzgRHOX0hkgn5sm4kSh8DbtZ +ljm5uQ/isZFR+McdPLBMXKGOVLEh8IOHDXZBwD/hBCtz3nqxJw2fErDUZ+Xpowek1/ERQGzPJWFC +3ugOucrrHunfGh7EN+osTpPe92SgUEusCMxVTTaRryIN7zv3ffNbIn3W6ofAD10YN1gWVm7c+KmC +78lDBMoZDzq1W9xMmpMV5RIWDi5OVpQbASI0rbP1L02CY59MQxybYv82fbH5DOh/rMaIzkXUYEXX +piTfckJWMo4isMz3oiftiqfRkpOUK8NEEHL2uGGTg3sJNYkOuNRgRAQ+p08VAmQKSZbzpShtfxze +amV2SdyqP0Oq6GaKRG35VDtn5vJ3AJj6GvYCpsaCBoR1pqjCTyWmapJIVFtXJEpn3b4ysVj2COr1 +8bMX+HizJZCwesW4j9dKunPzAot83H19gkMMtvmSorPNdg0lGgfZmYvmROjYzJQ9BMrGT5qcZdIx +tZk5L5xibnFmQPGvAkzfAONk8Ab6yipZoFzfLxMdVRPl5NiLiUbg05JPI5wOg3zJBVYNojZolDhX +K9e+OKgip3Cw44b0fjiAwsh5Fd3pzhiAttBnhKJogDeYbrVBRwJv2v5pnWvCW9xz4HYURtYimYHf +mmM8jj12DOAYYHe50YAfJuD1NBWgYFhPms4m0sxJ2A17AfwOUM73nyLp/YsawTFYfL5AFelunLYn +GNRxLw9U4rQNT8exjyBaBRzjxr04dtJmphb4LHeK6KQjCFUiaME1zrMK58z6kzVP2o5oowCHM4oB +Y+4USG/svaHuaJcTc+HHXaJcHV8NAxrv5RRQAzmT0z/rLb7a0eh2AZPtiVwp8DmAhYJaGVTbsAHE +JmdP0QbyWNBqM6vcDoRBfd2ZUYTX2K6BDh47QEMkvDzeAhlWaThuZy/Nua/0ZuayCEAD/MkSbw9E +E1TonIP0LDug2jd+gkcRO46Yp7lAvTZfk0CG9TtAbE+SqG13AxGxUZ93TRaWn6cAYttbkHw1LzCF +cIbOgppyHMeeETHH6ezr6x3gWASsV8RXMlQhY6YM4Zgl4SCnjU6WGj/5goHbN2cUQL6uIcXhRRPk +XC4cbaejRdhrqUBnb19iJwEdHzex2HUSZPkPqCTXv/cpNi7lY1Jvz0EohPPIKFsoY3UwGfjCTitk +z1eIxU0oIO4F/81kswWbhTbnA0luPFJQ4yES6XvJENVnr18+xEeqN3aj0qzODvl9erL7dlhfkAXf +dBTZs14j+5CqSVCJvVsocScO0T4cYm+RDlCxV0RPGIKIg5OVWH8CJbFJAdNIgdLmrXjQJ7/wt4Dw +N9CovPegZ+2cG1bVJJz+oURn4veM78h65a+CSlJYU7r9xY+cU2vnGfTWYFl5SxRnfKANBV0j7CYS +74vi/UOuAXpg4bxH372mCBZcM2L/4c4l56oLbpnKyH/z1cMeGeTKQeppa4VX43Kmn75l3ryUm4UY +Hb5bcjcdUXsSTXqDH8As6IIw5P644dcjuSzJLQHC04ae8kCIkSIIXPnh/IUHgd8nA0HwD4PAZENj +v0iBQL23BSAMpUCA1Ui9RrvU3zEQTBJNDALAMbQe+umbjCiLyiSTctc9jUQg6ILAL+J+37wKFBEf +Q0DY5AZPxvAA59JjxN6bRRCYg9snuwCCvgIP5De2oQwjHpWetVBJOYRsgMFaDRfh9A1iI3u763lr +4KPVOBp22TamW02SMtmMbePjjNNQUOWzCMyzcLo1/lMfgIcDSy96kGgttke34bZKBkjn/1ayAVZm +fKOOziqOgbK1ueEHGPyIAxCV28FMDrHBs4C/A8nBE6VRRaUJzmU4hvN3L8GxxU5zAAmO6Q7xbb4Y +xx5+L8SxwUp/ABbHdIeYbo4jyFAPQT52Ehw76zRay72BAbB2oTXEYGyAXPXWMJhKpdhZ2xgsNEB5 +eJxCLElxGoOP4xSvv4alBLFZiJ28jd/9SVjJaReyITYX0QYMsL9RrIGHmGHaGFosx9ZAbZ/FAcyO +h497uUSeTi+UAdPFn9oaTDb9VciG+DCMVIo1CNxyutxeRp/T350mKEVuqSuJpn9GSFyXW073ZumI +M8uN7KvdIvvqskq/Lj/+ZF+XG9nX360cYsu/nez5bi/9+m2RLeTbLlvIt0u2kG+vlTViUqGKE2u6 +bDZUVBZgdwfN3vG8b/b+rRtm723/jlVP4TeSUBbyjQcEY6ijFav/MjvW3Rbg2E0+ew== + + + gwKdYSHfoKlqUqIfSkP7YGixvn93NuLgbC3W999aceGB/tKDXwE9uZz7Y2Cc9zs2kpgqD4PIPZlF +EZYAWX7BpgsKGCbX+MLVGPeJjcmUvylHylkRchFiarkIii7MyFQMFj7xKnBAQgxF46wbyvnecYtx +Xdoa3YXRnV1BfhtdvySUQwYs24SnF9+YbLH3X0evlCgGVxwtrnt2s/fjq2u2FiJms/3rh0b26U7M ++OBSq8r9Npd3K/4jZuBSjSiVe3K/4HisyUYVZncUhqMkrH4IiZDoAwGTo+zlIix9wqL0EMjDSFxl +PesNkUSsWjcDEWJ8VOk14kkxlJcIhPz4pO2G/eVspgqOox+O+BBB4H+UTv+6KsMZ9LcHD9z1LEoB +dZFeMh+n7Y8jZOdVvEAqnxT16m7G2TshO9zhWdKOwKe3WqLG3w0ce/YEPlsvZS4HSjH2574iobXU +MrIGnA7/olVP2PgKC8pU0Ml6FcRr3XBwt8SfL84V2+BwVJYqunMMnU04kMvutSUuFLmi+vj6OrBZ +WwyWpCiUwyY+SnMVeGDd/lIF309eOHg2s0JINszR1nixRr02u53AZ6iURgwAZt6MKlThKdGkRjtb +ivRZt1Vy+jLJIR9dhvQs79LIBzvoY9fYM75dhbYn2lVyFjbn8G+owtxaJCvh6B36TRx+0yjS9s/H +CBzyN0w1uEui8NaY5VlCZA9gF3CKIMAxvrAbdrCGsYdPNAq3uSSOLBaTuZDmWuuBVo7MfBX6nqxn +JlukEmee4fPXBD415zH7cgxAF29elwW4FONszSNHgY91lr857pUcOFkGV3zO4mwRt1DDC8NyL5Vj +LjF2R8ztlBeIwVoGsLkBY8p5rxjF40K2/aeNQPEhbKRI3VeTv4gko/sYJ8axdSEIzMVoW29eFkm5 +0P3zlvSOzUHk0gpwCRDpTJydJS5LJZh+5b4jlghCfAvSOCZI3HThn9nQbO9PIma797Mo9TLyV1/z +UVjpP/gQuYwIIjDok3zIHqUSlNuIAbbyYn4Dgp1bFpusOGS+p9oPO4D0F5J6MT7+zVYC4bgu8jHj +Q6ZzEToSmw/TAy6cKmcAZNURxw0kVaIlDWAjZAKlMyQlcbEsZiTsgaqyK8THckO6Ik4fz3UebrEb +T/EgWhnsUa581o2JBjg/IhsgmqRXJBoWyjj3+XZkC2Gq5AVvxEO9Ftsdjn3IJx39jGuSIP7ia+HE +vI3lyUrudhJvI73OlwzlYrY1IJB7v2QNjrS7jFYdxrHXZRSrhuR0TRLoaxh/pVxWPyH0fx4cyPPS +OBD4LFdz8jyIPL75S2R6+IRQZIQ/IxnbcwKnSkRrpPfPXBTZnpzp1Yi68ytHlvP9AqwmnJEyPcqL +JBtdo4qJGYojn8L2zmR6Qr7lEbbX+Uw8lgszpplpF0/ncly2rSafuw6XE3OtEZ9bRt2GElf4dSNX +6h+7BoyVcl886e09JbBGwXXKQ657gip890ghIw859hc5Xtlw1SLtaKRcyrbzTzgFC1abrAAok9NC +2nPfLaSd8yFlWbUjRPXZs1MkaLFVA3kxDKpSbJujXMN7M5epMu0TxGIaZGRxowM4IK4T5G0faoX8 +yfmnoSQLSJ5jzIPI88sbC7UfmUbVGkggJqPjIstQEf9RVKTqpniwnPgeKUQhv3zEtrpCx2t6Ik/G +jwoUzn+Uca8QwpgFwXIOLTaDMVAgpIliUoTJzCCKuaU00AA4jdfN5eQgdRjnUbICU8Yjw1+OSkoo +5LiRKJjpuNdPzjr1JuZjv+QBi7OGaZTiEcaeCO5CDRDgcvEdQqofieo6EpJ0HFxxwKWBOQdYi8bx +SlGPnrWBATZKVNE1idPZZrdKZ1+LFVTPGoOvdIWolcM5vBoQRs36Ef1vun7KwSuzOySRD1hhl5g7 +OwM283SxXTrkWrZbVF55MQGSW1dvk2SpaYWL2WjgLzJDZ2bnPPCMPk3Qp7nZlbh1yNLID3POhRwS +iZ0XZjP/jWepKTOyvIgUUOi+ieJLTTYDFVmv61hAUNC8ekqLYGYa4MScKhIRfBcwGYwY4rS0XH/s +5RKNW59glYbGO25Dgzu/iL9MLxnLZ3v2+C+f9Xi/xiGq0Pd0bsddiTzRYMRMDVvNZ3n/Ss2cSHnx +pCypdIKLHtEKaTEkjWtiBM2L65lylmmKC4gwlRw1TPFepKYpinG6DCdUsWs4apgCjl1qmhowTFFO +rwHTFEc0zudtqKOBuMbWIxX4TOXTdPZhHpWax/3lA3aNocTtEDC4PwY7GNmvjuQ4iD1lWMMTbVZR +mnMxcTWbFSmgD1K2pzwhCdNLkN4Pd4G205WaGtPDEGvWFTq6Qv8D07vboIrmdu9Mpoe0vhPYnkGm +t0YOuBnicmPsfmO18f/QAYfdb9jiO98BlxuQVX0HHM/H/lsHHHa/mWz/sQMOu9+4jDulA04GibO4 +HK5j47kcDzGDDjg0i1vG5fQSKAUuZ7L9xw44zOUED8klDrhd6k/TAYdVW1YbN2KkgjJ1l0A5xMi6 +CwYVGhyqBCGRFy7A8rvpi81/qhcOZfNJDVJZKi3PjtI1dP12jPQ2einS+/JVlnnh6uSWEQ1SWMU6 +R3rX27zUC5chUOJkKAzc8j0PxvMXIZqj1Ovtevb/1Av39Rfx7oszky1m/xmNcRKZTk3XoYnHl7cG +7GxVFscAbn85Pna3cLM6kSN57+Yyu9hxWMQoJ93Em/M9R7z1tnVksLn5NPqqn2XbuCJB8DghXPXp +621SK0lfc7tEbzPZjGpul+htMIue5uY70+0mHiwmCq7O4mS3m+/A7SanIXkyOutVuLrbTeF0A03p +em43wIgBWy0oVuJxlY8sGR4w5pBPS2ckUdZ1HNQl361KSKEMhxMPCOpZhEDNuNhbAoy62MTQUuI4 +O2JQvizKMPaFpP4xniGNdygv94Wo5ycZUNTcFcT2kvCbpxydLRbDtL1Zb4IWEs4Sta9fCmD3WYX3 +rHzZQYh08k7jigvDAfv6WEgE0H1DJCdVujtSKDI9opRJH0ir5CValslmdr0uxmYn8zYwu4r3TgO2 +6OmWKMvHTrNF9SzRzFYRSJDcd/EfBhLUahKvH0gQIolGAglySIDOxPNNco00rm/so5M45eQHy1am +eAWy6MmVjTumvbCmVK2t5iSdJNgOJ9J72lBgLZoFbvF4j9SACBgxHlRlY98MmwK1RdWYFOJezUO3 +m6o/DmFJxSPnFgE2i4BGVFJBZi/1n3A0rh6ZRd3TOVptV0W+qTe1IGkZBHmNxnk6iCf7kkHM0y7g +aIrTCMPMxVuQL6UM4k4x4GPjqhlUw3kxiipzqqiSAuxTJj/iOZqibMgboW1zukR68xOklL2C7Ap1 +SkhZRlUfkzRRd06KXBkAz9GwbsnxtP+Oo/GRRGwl/Wccja0ZOde7ZpSjIao88K1enaPB6csqwf8b +jia9c/i/42hChR0HIt/5HC221eRo2DfO8bT/jqPJ5f5/xdE4H6xCS7s2R8P3W3I87b/jaDi7g+Np +/x1H4yq4FVratTnaYYdclqPR5V+zy539RkGDqdmZ/u6hTw9nprSxGUSn+dRO96iZJD415A4N//9R +0cMsGBmDY7PUjihtbHnO2QwuuWO5pcjiUGLAPEMVftJV5EqOXofBKT1XqkrbxQwOZaroZX9cIfeD +vIvh6tpEQT37o92LAC/6iOA8WMTlaNoas4lMj4Kn870BpsffcaeR/SGtZvZ+ECU6m6CLoIpMQ4gL +Vmj766MW05MWJSMOI2N7tJ2u1+FIwhkUTg1rKnInMT0uG+oS09QA0zshf+y8QAJmeuxNFGcEEk5i +epwP1ijbO5Pp4XvhjLO9M5mevNfAUbZnkOkFFExPktd3nO2hcsSzmB7S+q5rqaoxPb6/2FVS3q4Q +TcBs70ymx1qvhtnemUwPeeFOYHtnMr3/B9ar0/f6ggKmH4jjdc2uzd+n2U04l/BpY72khoG3Xv8z +hY/XYDHvAxBF/xOFj7Mr/2OFj7uf/xoK32Ctz/lMtuO8zyGE5M9I9sWFDLJbzdNUAKWbJZGT20cp +r2UxmC+iFkeVR3j1I6l07k47mnlyLhzu91D7Yd0yfIlQH8GT4QLxCuh0fAkNfTNFkJ5lJo09il+0 +bBX3a1jty0iMOwDy+YM4Kw5dWxcC1jTg037bjbABe1fQlHguiLPrpFxQfruKjAtG6OxjNAcQe+zi +y2bQDY45cgYoJomylt/nCaTBuhM1QO0yJXUDUpEQSoKMU66feuyQjZ6Y9nuK1nckzpqfx3JB7yeO +sjLNvGMWqcRnS/hn9GmyJbvZnyfPlUseFKnApquUPMhp/9Crp27vXydSIXr1TLb/LlIhevXYexQ1 +Sx68EhQ4L/aK9Wku3/KMci6kH8nv0RmR05c7YFH5r7ziUizeb3leRrDRfGCkwxS7t2hEQjUvl0VJ +qWNtIF9Ih2WogphAiYEehWuPiyOf7NyjKBczT1MuH+qYfeDcK4LC5wyy2SSIEeIYX4ASFMIgl04H +X9HNm4Ra/pxHM3sON1iRZs9x8gpVC2KJRRdbgc9pL4OuYWUot7lSgmPcNlldvk72EvAeUxOThnXZ +KPzCeRcnart3/s4uOSO9etKwpNuvfv7cHKUKv6IkugcUzHhGsY3pSUogW/N+kQFsQAk0aRjAkzFz +RSUQZRFcaAAbUAL5rhkXGMCHSmDrR6EECn1GjBvADrZd0ylKIFCloAYivuM0fIXZKUogzPLfJg3j +ZDo2LqabNIxuUrmwIAJpSlzScEDItk0cJA0j5x7KEgb28cBe8IDqvAKo7CvEPtUtksCYLC+TwI03 ++LtKUaRiikpZM6Bsde9RBkqSGlcdRVD46mHQ5egKLK6UBeTrxKhCx5ejc4FRg20+xN7oBaeL6yyE +822OuogBljHLhCP5ApFAVvOYASK6KoLBTbAsE8nKH/4m2qBLIbskLgEEWRxLWivLII4ogSo32+GE +MOZz1GjHh/XUO0M75qPQ92Q+Zj6fhiWT7T9W+LC6x1LlBQqfnM41wrgyD/x/ofBhdc9k+48VPqzu +4Y45qgqf63KFT3AinFW/D792ywvA5CQVYaTXJrI1if+twoeJhvOQnG72qhi9Tk2jF+tjp5m9Hph5 +nmILFA6N3hdcv48uew+iqC5bGgF8DHNB+APDd4E6SDBl+QUwqSBfzMemqN8rg7uo9gtVqTaQGhen +c/b2LfE2tlZwzMJFU873pwJwqm0QWHSzAfrfT4mcVe7GvMNPn2Wi6gmLH0zm8VdCyTKRw89k+4+D +u+q0b3Z9LufIzbdD0Y2Z2dmxvF18VQm+r++/dPNx+hioXY2GcIzatRKXVErgmIWhWolLKiVMfKfA +o7USapUScjhoV0oItwSo1UqUn//OrnbFFxVKKlOw58eb78dJn41A1N0Kozuzs0Bevdx1ElfYTEj9 +EEf5YttW4iEJXM3DFyewYoQNPEkWtMDs5k/4sivkw2O4OjBcNbEmKTjQzvaUsEZd5A== + + + cqrnwoh8Dle4wGr9SeBZj3ENLqe4/lfO5YrpMvJarzIlHDRR43PX4XKHXZmORHPP4nLSyMh/Z8ey +EV5tPncdLidI5AsrwvS5HHvn8OUVYfpc7oK61/J4Y5TLSSK8Ap8bK1KOL+dyklnODOQa4XJcfeVx +H95FXM50hM9dh8uhHEU9PncdLoeq0fX43HW4HEeVZ2hzrB8m+5z1HG+3JfSxOr/hFnG83RbWlC5r +uGWg3Za0/8uZDbcMtNtiefJFDbc8x9ttCTccnt9wy0C7LQmH0W6PxSKQRnusQ6fjYc8tOJfLh+Vb +b2k23sLncq3WWx6txlvi/WNXaL3l0Wq8xfbkulLrLc1iRX4vV2m95dFqvAXW62mtt6hGWOFeN+Ap +4zuzIJ4FfxigrlRBJ3LD+zHjFriug73EfvG18HBMGF3rD6zXw0nSwYrlbZQjYx5xjCnvR61sW6h7 +6WifqAY++zs/i6afXtDJkKTBMXG1Zss4ynPgtHLOe1yZUirsknA0/mawVNIj+evkprqGv+Ux83Si +O/SXbG8r70t4IbAwOKbwQyX/uszOYdJ1jsN9ZbA4Qgo3gvacEUEB5WtB3oN+XulE7Mqa4Ttsle8I +rNDCTt+z/Ng9Ch8Ewd+I1A6u/m/KFCEiwX/4n0Bn/73Y3G0+3z9//3lNcVMgWyXJ3u98VdosFt3F +/94VVrP9z+J39y/2L5C9z1erkVBhMVvNF/+87PUiIjb4ONTh1CxaS99lmUThLVpeViyd5KTwRgxS +Sr3fse7+IRW1YrKZPTO/DTkhn8xeqnRvdla2XvR1wN5/K+rcB85hrB66LYXFJrcvem4bjwomh13H +0dduOWmyFR9zi04msH1PBCrZYb0wLD3cZwI7YsXrVRI/5VoIc2iZIDgMt7ObXYlmEPV8fYB1Lguw +F1C4A2avK5NBf62ZPe2bJtpfEz1Im31Zeo7ura2Y3X+WjbSCGjtZ7RRnm4AGEefOuDQe8yjWWokB +dVBHve/vKY8k5rW88fNWw89OdASjII+T+/S1cHNkhyq2JWSHv8aciHgrPu7SH3yPLteBrhfb8X7/ +KiGSBtgKuygv5+WUJO5AQUzWfJJ/kPfJlIbcsJfmH1UD0m5yIsqn7kjhwQun+ZaTolbyIp25nGeb +gLLl3y/SuVFdPCqTp3L9Zw/rvh9tv/bwoEOydJbumeFrKyOOPYZfBEGvapWw8uTmQ4qFJerJF2GN +nwjuBAsvgREJMtYLE/xZ4WsPD+tmDyfQeqIDt/dLJJe6HonSMLf7QVgMGj5h0ldZ4HIIECsEJgm7 +YPJ9aZh0QpNtvtO2aNLBCn/z4ohq47HuSMMj8mEVWXA141h0C9V50nwYH+hS0garlOt7bOHQazAJ +ClufSNFreofZr5dLZZ32AhzaT/sEOW1UXfDpieTE0PSFSkWrFJzVdIIS6LnP8yAegjvaZQeP6MON +sOFrP8D9evlE8J9eRGybSpXa5ZyWPEBKLewFG8mvt382XlX4YSSG5eLF9Zb/YEp3XPjleICFFWJi +gGXXlzZZnHHIsnshyDKZQdJ2QvKf5pT4Hqf8776CB6sJ7R5KblcqHn7w3dyWXm9tUa4sHzXOCqPk +5xDSLBiFBS/11wtBGUl6g64zBLN/96gEp48EQN/sfXgpAlN87JtdzaGT45v7WAux1Arw0nTX7Pr8 +Tpl9v+1nxEuj8tLNI0qKypW1/4GSgrglr6b8d0oKy8dGHAn8V0oK7EVQU/4bJYVLCNbokb1Wi/4p +wrpsFFQUyxiprMWXkKJtlvwyJmrrkzbOmkXqkgQb/Dfzzil0lti2DjpvBd1lf7CS5RtRJVdurkRH +1iIM3UzBt0minNEBLWsRxljMtpy1wA8xk/WjxwPkApIByFK/TEpcqzmO7Nl8htvfwGeqV8TKAUK0 +FMZz/m8Pf/zfBpvA592vRzT3McrJoiwXNcPALIxtp56kPELPdHfm0T3hm3ORfo/QnMtkU7bnwvao +bnsu3c5ULhFiuDMV7kuFmpQY7kxFntvEQmyHEFnzQMjQEiDgjmkcEIIBEQhoNUtJc65cf+DTBAHf +2CMdW/7yQHDb5EDwCUBQtmkzBoKk2KLmvIYk6VhrZ6BJm8nm0WrThhLpXDwUcWc1NVTS6fPGhvfR +AHD6BrHxYAjyxmN0DVyjtYMhYk7vZdvI+30iSZls52yjFwuc1DLvkCq90Z37EpwmvXmbRzEABzGj +kEAZUT6jbe/EpnfSpqTI10iobsMgKNF91yQeYHtTruT4ARiLyYZaAf5J3izn/lzcm6UvUnwT3Qn2 +KsXzydhxIY7hzOWLcKwR9IsDaOKY7hAvGeJSHHN8OC/DMeLXpYFjhodoeLxHEUQ6AN6EHMdewv5L +TgO3U1cbAHDM6BDlxs1xclUfgEtvRQqfYd6nvoYXvzoo0Rrw1Q9HTwMUzKMUr7cG9sLiy04DabX6 +oMTyRW8bFV/pNNo4WAPTQIGoS2iDLSXVXcMmFSAlErkS3Pl7CckQ0xfbZTJg+u7x8BJZdxU6a1iT +2kilWANH+8pVzKxh30UYMfMl/SIoJdzyiCSSDsHkVUlccw2H3HKWrqalXyt3GenXdi8r/Tp8ykkU +TJfVH5N+9QXjUtqnXEwsIX2eziSlXyullPRru5GWfh12MtKvs35W+vX7JSeU6IRIJ9Z1xSJlDMWI +zzwLFtKecb+wn5Qb+VEtyicMhDKiQ+wZbNv5lo3KCWFWNisfhVnZS+WUgdZrh1nZWZSB1jPCrOIy +QYq9Cg/cUv8YUqKmwiNp7BNUIyH2WfdLH7wn3yRGv/gAFJkPIVrqEq53b9xMhL96pMHVF78QoWv6 +pA/WMRScagpBtSbBRkaBZyGVu8neCoqYx0QMqrU97EtAzgjJ2z7BdLGypT7wNz8XYWXyaJw24Uk7 +CxuE5/grNywgNsn5/wYlj+BK9fIXGAEmC4CR5cwYDtOJrdGVQbpuQF7OeoURCbWsHpONSfWCzWx4 +NHcelJQMnkQP36uIXpRrP18KIVWvNNZaSSL99pG7ta4wrPKBKJTXE2JJoPDdo7hP+6cXtjar6JqM +uU/UO3IHPoa4uOowg0Yc+nHrDqE0w0qN9x12bOrV1f+QhFQpaUg1Pv/iFzoMCnHjqWQvr4/mvIEI +uXZhtk0Rx6Zt+6rgCxsFWDq3U70gGzexx59C3KfC5FN4j+bee/jJShIcufXc5bujUuH7ZpbtdJ8d +xakv84hzXRA34f3JuzUjZrUjMzokuzZX/c5fk/LWXy7dv7T/xpwKOUwIjlM9FidcFdpkjI4EdVBE +Lkuwpb0ethQNB3jImwAq6/XgZHHJRQY+nOgAf837U9HyXV8IUru4cpVQKcDlpcsCADgadJBDhh+k +gpjH+3H2iJDmkorhbTgVqSOsy5JlnqlqgAhN6+kDjgYmHOdlVMaAuFuQcWlu0g2a21eK5WOSy/e4 +pGWf5Mo9lntx7tAFlio4/COOLcaA2BKr9Mf2/6ZMgAAoijou/s6lEVSTzQZ/uV/s9mv0QmicW7x/ +/jYm/2exMRH/SPw/gvtfOPqPpCL/qFAIvoTQXxpTk7PykM3/q/5OZrvP/7Vw/Wv8wu+yRZNtHMhu +doVP+PPqd7L5P/9i6E/920avWvgX+4d/NhZ/Fv/nhOURY/gNvOBCcdwxLHmMBjOR//r/Ax/wP9mF +aQ9/yK7hcwH+/w6+EP4gt8T+/4E/1eDDF6z7f/6RxL/bf08j4t8c/bxjooiInyGC4RBBUQxDRP75 +IoQ/SkUpMhImKJIKMf9+VF4i6bCfjFIESVDBSDAKMGEofzQaDAdDUYYkgzS8EqH8wFUJMhgi6Wgo +AlMz/jBNRkPBIBkMA+gOX5mZQrByJgqjRZhIkKQplZeC/kgoSoYiDEFFg+qrOXzlYFcz0+FLVNDP +MEyQCpOhUJih/h0shoJRgnQoHCaJaJgIUod7OnhjZjoAzcE7h/BVrsTAMc1MuSmcvLP3+zv5Wcz/ +vW8m80+UERANugBEfpoiGIoJBhmaIaNRhK9B2B1FUxQMDmPA2v00QYVBclHhUCgUpTlE5//NvZuo +MOUPU/z/YBQ6QvojJP8/JvyPjMJMkSjsM0rD4CF0OAAiggkBqJhIOIQ2RwT9APYQxVAhOgz046NJ +WEswGgyFIsEIFYz+6/+YgsFIxB8OhqMhgFMoEvoHxxD0U8EwYAFAE07DyFxBhqT8JIVSEpkgTTL/ +fAygCJxHFE4sGqUY2BccEYwUIgG4BOBQJAKgYCLwK8AngEYI4GNoLpKi/XQYDo2GbdEk3inhD4dg +bthyiIr+y11pW2h1QSIcZOAHMA71jwn7aXhEAYpFo0AxaFNvQOG5nAbbUXx3Tj5jseL39+d6C6wn +0Pv9RLkj97vN5+/7P/ywAUzp/mOyXsRilcnv/HuxaQKasWxJORpF0LBFQCFAfZoB9A10FpPvf9JJ +YJTF5/vHjh2A/BfIrVbKN/Lfq9nyfz63C+GlKqCz/J3q7+fuc/Ld3k/mm8kvNxyhOmHrEzY02eyy +v+/fiyMvggQ4+lpntZugXUteBBIISsiSVv1dHohysRnwv4gSEg4S0flFn/2FIeA+fs53H5zMODi/ +1mQz+dmqP5XLmYXJvUf/XZsIQephgfJuIomwP0SEEUMBhgGUD4ya8dMgDkmElvBnEBzoJfhTKArv +0UDwKi+hV0gySgcjQDWRUEj1FQaACmRIACXBX/lXSIJkouEoMDTEzSPAVJkICYSF2CaWLiGgcypC +RcNhJgLsjPITME0YyCQKtMIKjog/xDDhEDC8CBGMIBYYooCPEdEIkG04hPlsKBKBjzAQGabDMBUF +vDnMAP+OolOLBoHOkYgCjhkJR8MRYNn/glE/PIbhyRDipsDAaX80AsQKfJ+EVQfxvkFUBRk4SSIa +ih6+McPgY4BRAgSDkVBYYxQ0KUNGaFgkqfZGxE+EaZgjygAj494A/g6shAbmwWAJxfiJEAV4C3sG +xoTegS3S8PsIwZBoccBFoyCPgFED0waR5YNXwgwRIoggwaD/x6/AgYGgjFKwHoAKyIYwHYlEgJkC +T4tE/uVNBl5q4JdoGjgf8G0mFEFHSUf9cC5AJrBUgCeoGyE/kltwiuFghNFCrCMImgceSYLOxJ4F +UFMwCAoEwyAJTROhMMgMwCSEOj+mEKwzCjCiQF0IBUPBw3dgcBq0jxCwcoBvhMJSPBJEGEJEETSB +1wMGAoSJMPwfEWKiGL0YAjF+CnCADCP0CoGIBWkaBjkIsipMs/wfDgy+IqkFuA2KCRwnHAysBuRC +mNWSaApJNBJETYQjGpgbWEWYVZLgDYaK0lGahkPDCgOmPTh1OgSyGNCbewkoC9AF/sCwUISjAORi +QgQSYeqvhAAKaCLYJaXyCkIx2g+cK4LEF6I+lZewjgObImE5QMKcXgcYGGWQxoJBDkQOCAA/BSGO +lEOEPUCVWDDCfxFxElE/BfQL2Byk2FMAgAI3jgLviIK+BWoNMGngJbAdIHM4TJC4CA== + + + nCEQ2UTk/2PvXXttO48rvV/A/7C/NCAFra15v8ifKLWTVkA73VarrSAIBDZ5IjORSINmx9a/T9Xc +pLTGmOPZZ1M4NBqB1W2bPHrOusw15/vWWzVqVP2mL8/MWhHfuo11kx4vv/W3V67e5vj22h1bPWvL +tq31A9/vh+vp3bcryFm3IdxV77/vfvFtUPe37/756X/5LqD71T9/+s1n//D02Vf/+MenqWK7WqEq +tjzqpqyn4+znd3ha6vE8K2CsW6sC5+la/I66rBUg1MO21sLQt9BZK8GwVeRcK8RcfzLUt95qb9nm +jlf2fmn/o/tfW8bn/qy1zM5TrcdjB13P+1FxSIU603EO40vwWJf3eTiHY+rl96yVqH6Q51646rau +tbLXqoqUl/oJ6grUT36t4fv43CHpWotcPVR9h851Iy3nUFB/v75L6u1qmepIfa1l4woea0Hf6wKM +Y6381yLXV6hu/7F+/wrkj/lN71W36vhci1stSBU6T7Va9e/4vNTjuU91KKhwsuKsf7Xv9fMP9L3G +o9elsTbC+p8Kep/GOgoc43jU6WrqwPwhevyffv2GAPLpp3/71Td/9+6zr77+vA4eV8T0r3hzXfHP +33xaseq/1Ds//egXH//yu0flv/xfX339h5f/6k/hzseff/Xf3v3241+efbL+1Td//P273/75u0j4 +U4fsz/v5m36Q5+92uLqu9/b0ox8//ebvXwTenZaoq13hZ8u8W+5dH+/6twq9f/nl5+/+pf69AsBf +ffPV1398+Pf+ex9/2XHxF5/+U0fwLRn/6ArePv/TO3ybOPhTzmCqvaAPGXPfxb2Kn2ctgltteFPt +eLX5dDx3g6ba9Wq16rW0Y5nevu/QWJt1PTC1oW/DXhv/U91rtatUNNFb/HSdyp6n6/RT2+BS56iX +XWXpyzpUVFe7aEA+++isfXGvc+1Qe8RY7xago56XOuXVnjJ3uHiET3NHbt/qFx8FqDajunP3CjCX +ih23+upnbWn1t2p7qtBu72D2bdD9It6hca+Ho0KQ3g/raLo/1e/ToW3tWHUdK5oqpB70ufAKAvo0 +sYSLeENqJ6sLUrfl2qeWotb0OhXgXjfCPix1g2/h09yRcBHD6wxX/Fe74FBH/3O67p8+Rtc2WMtX +wb2CDbWm1VbaF3CqJ6qhuR6oOqrXkXeutfaC6iPVla5jc+3/dSa+skIdpldMUdt0r7H1qa+VZOnd +tY5nAambd5nrLD0e43Be4X6Arqe7woj6zHO90lN/5LOXzvq+te7396p1ehyGeauVu6K2l/u5HokK +xbZ64WUPSN3PdeE7GqwbbeqbLUB7hR39BWq5H+ou3sOnCcj9WwVorIhxq8i0VtY6KI1PFaDV6lV3 +V51jjut7d6RXx5x6ujroX57q8y4dOdWvUtdzn15+qs5QjdPSv91SP3q4letHr5ipIvpaJSr4i/f7 +Mj2P9TtVGLzWdjsWc38E38KcR+1ttQzV0tyHw3649qO2yL7KPXFyuj71+jz2JjPUPlnXYq/zXO2W +HWqOvb70xemwvL5oHRzqCLkmJFzkO1Tb11rng4pQ60PVNn/UZzmWqf9lOzv4/Env4HVxj85mznUC +S7eOI3WX1uPWS24dQPuQkKCxL1f9W52i61ee06cJSHgg7tDYB8ha7/s614P99HJiGca5DgX128wv +l3jts9i61cudvWC8d8N5Y/Rbi0XH+3Xn1A1V4czwdJxXIPHtf+rWHZ/7AFM39zyP9YFCarODke/+ +cx0dnirAq+tXwcm+1j1et9JeEVr9p+7YvsEr0PvJ418a9rVOJPvw8IsP9TV/Uj9tH+Lrm07zUV+2 +w9OHv1en9oovn46+YvVD1MK09XX7vm82XAfFCvvqutevXSvlUe/Zgdy/3hf7+Q/xxfq4dTxttZes +9Y3qxepJPMeHCPXlmLXva60Ex9hr77ZWRFwbU73SXLH6VIFLLQLb/nJorCeigsY7dNbL1K07nZ2M +Wra6mhU317pff6vesc70S0Lmjv3qvH6udXhfr+XuBo2d766Vpk7ztWVeq93yvOy1ANbGWDvaywpU +54ouENTS24nhl6Ws9rLaCJY6P9aG2Y9ZHUdqNz3ra9Tjs/QK3bmtin/qqFHXqpFa7uoh2/vUXJ8p +IfcnOkAVeNez2UtmLTv1dJ5zve5xrdd7f5PemmoZuPKQ9U16WXo5ztZ5vmL6Ze/j0g3paKPz8cux +1t1wLNeSeHudWk22ucKDipyPl5TgWjdEl0Pqhjg7aT7WSXntY0JdvWO/ciRLLaR1k/Wif8zX0bm3 ++zqzX3mSjriLWa7woza0vZagK1gd6+gz7HWV66HZr3pTrYn1rftQXlFbxaZ91WuP2fdpH8frzh+X +iiPqb3Z+rP5nTd/ckZdgtS730b/4dq7pda7dqzbkrVMk87Xlzkenlc7ac65DUELC7xmgzmMOXYQq +aru27q78jMtwRTV9BetSzEMnrLbOO11PRO3RdZOetU6MVw5pHOo5qqd5rj8ZKtSoizx0Rm8+r2it +Ys2XKKHuzwqvp7UznH2Vb9DtwYnQVJ+5f5p6KOrid8Lkhgx9AqiDVcUbnUR5ui8HN+TlJlyWuY4I +HZvPR3qdO1Lbae+lWx0s6umNSK1tHUDNHY/Vr3vdhA5dWbf+SkMfcutc33fhUX/Utci6C8br1qgr +3ZnqTvL3D/RtXHxUhFRxwHi8pMG7bFZXaB76l+77sG6FekjqZDxP1/H5+t3rsT3nY5srlFsiYvfP +L67ous5lc+cGz5enwqFPElRfo7PPV3xf4dX1ZrUUVjx55ePGlyWsQv169uvQsA0vT3ItyHt9o/qd +9/1lKdymjisrZusk6cuT3Mn1o8uDLx+61tSlntF16BTLdN0/N+j2cyRoO/tCn/XTVjQz1TJ7hXpD +bQkV0RxxP3nDlvPZ20KXCjfrB694d+yE/ZFCl7lTgnW16mvW2WZc/4LQ5Xxa57oJl04lnVeJ0zbd +ek4rEh0eNoGxNwHd4euzeOjSbO3wUx8c6hxaO2XtS9/3zTonfMUuS0ewtdzU9jds25tilw/2zTx2 ++SDf7Kw9frLYpZbwP8cu21WbaXlBxRhzH7278jK01mGr8KHOGhW7dLG3M8gdFuxbn/Nv0CcNdWBw +Hh1azX1GAKhVBbUpnvM4ITRXYD902qKuzIlQrdy1f9c6Nm4TQbXdVOi318Hq6GctQ2v/BlPXS8cp +XYIXqNN9c6+bR+d5MlTRWj0jV7Vsxg++V4hQR6QrsMFLcK1HFZTUkjwSc9Ta2z/L1BeKoNo464ev +cKLuCPxIXaWpK1lnvEuikKA6G1UYUPtwLa0V2xE09k551nGvPhN88IK21p6stX0ME/x053PtD7Xc +bF2KGhjqomAdIKc+TxPUJ9eKh/v8vcHvez7X1Z4qHjzqkg/w+xZU4ULLOIYRkbXPwLWPbyc9BGcn +5wuoc9JO91uvDlOtDvW81Q2Mb7a3bKMiuor5DvxJjnrqt14vlpe0WIb2tZNg09qnFILOpQUptcHU +5ph/3L3Xo/pQ9YfntMFz2dDWKfRa2eqViBnneqd6v2Ha85VspqLodb5uSoY64q4gtMKmDW7cgub6 +Qerx7TI8LHENXWXs+ve6KfNyUlDtDhXgdIC6jniV1rGTPfvYO2u+3g216qtOE1MfIAhqPVFtB53H +GvES1CJRMc/YcTOsJw3tXfidzs72IXR0IFnBda+s+NPVx2ltUy2XXe8kqLVn17WcZ/jgYysm6iXq +UDhv8Ow2VPfSXI9tBfsLQmOtSHVH1ieD57vLVNN+VHzdKo9XoHpM+sjQdTG4TGPtuLW5V/RW6+6K +r7R0AfjoTMM4wmUqqMs2tbkvl4YEoN75626b+s/zOrh3TfBKt/ZSf8KTOV7Hq4p++//P8ByMte5M +59mVwpa1EVSnvYpwe73YZvxMXQMcOvvecStBtXvVHjZ0nm2Be66z8UNvF1sdU+DdiumHZa8Vc2hX +I4BakVC3Qa3fL8WRDNXXr2NRx2ELXIE6ndQVqqNzXag6NRE095Gvop3a7SFEaahjxa667rXaE1SR +/Ni58U4+w7WcWmZYgVWn1ScIURqqz12nm/kKdAlq1UBtQGu9544XswUydXyocxvtmQ3t09nhSW35 +O16Co/6xk9gV0KwI1TGqDla1YB5XFgSgbevlsNbDYYQfeK6FZ6jwa7sEj3CdCjo769Ill2WDH3h+ +7vTP3qe7b9WnEWrlU9f5a/Whda6go9fKqbeyHX7guQVk9ZgvvZsRUs/JUSvl0ZkGuEoFHa0cazln +51AAWusOqcvUDy8tBPMlMDo6bOwcLEL1T3WY7bz7Crfc3JW6rZ6nimhOiFIK6hNBHdbOivonhrZL +E1OH8nmDu2mudWfskLDi3g1vgU4T1DKwrnXMh8u01LpTB5quc60TXculs5JnJ9nqkw3w0xV0dEG/ +pUEjhSlLrTtznQ3Wuc6scJssz/XV6rRT29g6UZRS0FGrUj0B9bgc+Ep9Hr0yGgMGfMtzb04doVyF +cYSu+60uQa0Y8MsttezUgWbo23eGg1hBnf8Zu/g70HNZTJekx7219RSkLLXqzK00r5BooEWuoLN2 +ij7QHgscVQpqhcDRD1wX0TK0Pg/TVvFVb3cHHMQaOoetbrijE9TwmdbOaLfqsPbVgxa59Xm6btwW +PlY0h1BLOyssnnOC4GLmpXa4CuiH7hcgqALwvaP5rjPCLVdQ/ddHVyZqL8fLtPYSOG6tEKCnd60/ +qvi5NpQKIBeGulRf92TFVjt+pr03wmXoKgitcgX1Vr92LnCnIGWtZafPGUsrfOm8sj63NLXlgPOV +5SXo7BLMtg7TQmexronW01L7TpcS4BJste5cS9xZywFFKQXVCXrvlFMt4vDBt9aP1a7aJe2Vziut +gJ3Po27cs25NeFgKaonuVFvYDsf6YjrDW5fqbFk2XoG1ayt1bKtz9I4fae02l7qS3csAF7wrQrXi +1N667ycFKd0lUU/w1nnhnQ5jBbWm7jr3LHQY255bXHapdNeWbxN0zrU/HVPvv/iZOoEw17JaPzCt +c3stPHU7DXVGmhe64gUdW68qdQ+M9GzutfC0qvUqqtM611Wn9ZI01gshsteuO3ewftIqt9e6s1zF +vKWFuwS1MKVWlIqcT3p8C6pgoTuTVjxn7s/dLbTttdB39xRBvQZWVFzn1Y2/XL3JWTvPOtcr4Ufa +50617VcnB0PddXC1Ey2QUG2lzVo//jj2AZFWuf35RYddZ9vephC6CoEVNEwjxUTHpeXv0/bRwi+C +xhYr1mdfO/OE0FEXYDmvABJ+lqOWnbWbAOqn2SBdXNBcd2WLs+aVbt2jm6e63l+HrPWAy3Q8L52w +r0PG0ts0QbWYdGdIRyq0yHXnRzdMdYg102HlaIn61oXdPmnD71tQi+Cu1MZOUcrR7RKdb62IBoOi +47mV7bUGdA2CzrUFHbXv1mmzfjxa5Vp2OK+17yy9Z8Ciej4PnZuvSGav4xhcp4LqQw== + + + Db1ibhMdxc7ncemjWoVY9ZngEpzP1zNwzGMLxhiqYG5piUNdBfiBz+e5NrGplWfd0kDQMtQWVT8J +HQyK2OpAM7aMeKMH86xlZ7pUEUut4vj91y721Jm+bmB6es9ubzhqyVn2LvgT1Pq1sWvj4yU2BKhi +9E4kHec6IVQPyrl3XaF+F/xMXT5duz+iPhNeybOD/S467xTwHcNzV8nGjgiX48x3XEFjhwP1Vvt+ +qTYBann7JTGkk19BUyeU6yBe/zv/vsfVTdE1rFqgTjis3KEXBU2HY/XqtZKmd8uMfWyA9AJkyC5l +gO4/CkD682bIbpQM2S0HkN68GbLHIEP2QAGkj2aG7CEH6GGtyIQtORmyxQsgXQYzZAtqhmxpBkgX ++QTdtosM2cYDkG5hGbLNMEO2rQKkG3SGbKsHSIOGDFn4kSELZACSiCgzFlplyII0gDTcy5AFjgm6 +haAAaTCbIQuLM2QBNkAaqmfIgn6A9PiQITuIZEhPNMDo0ShDdsjKkB3XAHo89mXEjo8ZsoMoQHqk +TdDtcJwhO2YDpAf2DNnRHyBNImTI0hEZssQGQJoiyZAlWzKkWRtgNP2TIUskZchSUgBpcitDliZL +0C3hBpCm7jJkScAMWToRIE1MZshSnABpsjRDlnbNkCVwAdJUcIYsqZwhzU4Do2nuDFnCPEOWegdI +k/gJupUDMmSFBYC0RJEhK3YAJFWTzFj5JUNWyAFIS0IZsuJShqxMBZAWvDKklbPMWAkOIC3mZcjK +ggm6FRgBkkplZqzkCZAWTzNkZdgMWUEXIC0NZ8iKzBmycjVAWvjOkBTQM2KFeIC0pJ8hEwdkyGQG +AKlgIUE36QNAKqLIkMkxMmTCDoBUIpIhE5tkyGQrAKkAJkMmpcmQiXIAUnlPhkwolCGTHAGk4qUM +mQwKINFTJeYmzMqQSbwAUrFYhkx2liETsAGkUrgMmaguQybPA0iFfhkyyWCGTHwIkMoYM6R6yMyY +sBIglWgm6Cb2BEhloxkyAWqGTMoKkIpiM2Ty2gyZUBcglfxmyMTDGTIZMkAqaM6QSaMzZCJrgESt +nRlVfQOj8vEA3YXoGTJJO0Aqjs+QyewzZIJ9gET5nxntIMiMNCIAog0NGbLWiAxZkwVA2q6RIWv8 +AEhbSDJkzSgJurW1AKQNMhmyVpsMac8OMNr8kyFrI8qQNSQBpK1NGbImqQxZuxVA2riVIWsBA0ib +yTJkbWkZsgY3gIZu9N63WiqhbLTtz1cKuL37Tsg33ZhQ77u/GUDv6cv75C0NnktFFRUzbxWG1w11 +nKm/cxs68qjDeh3qKzDcv3d/59k+xNtzdxeO/UbrlYuSxsRe85+29eHq7Jt3QbYhpvV31letz7PX +AbKf9zZ02fd6IL7vm43XaeBo27FadmvT727cN7R3fsAv9vMf4ovVZrtqe+fUwdWf2zu72nt0xXDp +R7tX3Pml675OZR2pXObaDa1jbdvtDdHVohuTysYZqpt23zs2Gbeu3wBUy3pd66GtkfMr7S9+iOOV +amqXO4Jqp+2a4rheBTOAtACdoc4vVTDYqcTzQOgK9DvSb1NkYNpgs5Pu07HnK9BF6vb/rG82t6kc +QlrJztB22Y8O7ZJ64hWoO+Uqu531eONn2tpQp+LKuvFO/Ey1TdQqtA29x+G1tJp4hrpGXUf1ihgX +vJb1HO5tx9lxPH65ZXw5NJ39AAHTdYm1NudeAvBSWnkdoKFLSuO2DjtfyvYVv+pza1vXElSP05Ug +O3vNBaiCrvmKT2tlxitghXqAhsuAsR7Qga/lUCHnXMHCelkUETR3xWWfrlNRho6rWFI399zxEny7 +W8kfoPagaTuG2mLhM9VGvG9tw7Lu3V6P0NwHq44+RrovKz6rk1fbStVTRRfzJh4AqK7A3s4P+6VV +yFAtJfWM129SOwJ+u3pqW/IwtAMNMp1prxer1ZceqJsKAaCprTrm+ZUnqkLGs7fMrl+MzNSjW8tc +nT72FX+ULgR1bN3xB345kzMAVDdTp1i2aeBL2RapW2+5faxHqE7oc+1y83DO+PO2Y1qdQLtaz9fS +lBEALdPcpi5tDoU3yti2TF13O3a+CYb2NOrRDnO7vhI0bUvFrXUE3ehi3jQWAHVSb67L0D5ZCHV4 +fuWrBrqYbSFeH3g7O7FFt0rbBc5d5ag/O3d8JVNrAHTVQda6gY8dv11d7qUe8LEfBWK2ij/aQKWV +H/hCXTGrFWNq/QC/kso+MtR6rVp1l/VyUCJoWrruVmvrpbbKUPtfbT2Qox5j/ExL5/Xmtv5a+Vqa +giRDc/+2W+0/9XKw0hc0V8zQHjYvnn4Zmuqf+8mrmPnEz9RVvLNlPdtVOwfoUYuSkfrZulIwnevG +l7JP4EN7K/VdR1CtABUZj5fZMCwE+1UOrH1nrQVjwR/FVC0J2lqZ2btmrxh0X17u7L3SH72TwY9S +UB9h2ry1Fgv4TFtXFvuBqs33quYDpPqYDNXnndtGcemJJQitXXjapxanwY1S0Nj+VlP9r3adAqhr +lB2FX5UVhFRpk6H1bH/N/ao84CVYLxFkr7+0+bQd5tnl1/2y0yao0+hTTxKoF8RraZIdgDq0rAXj +6FMNQXNnLNc6ZJwjX8uK9Y4KL8daeA78Vbpwurf31zHQ8eim/gFoHNow+FKfwkLQPnpdw+tnYaY4 +ZevMdRvO9QkJL3itSl1K2GrL52tpMiKAKircz/lo1zK4AnXCr7DxKrvMGz11nQZouWQdsuqS8isN +Hci0O/xG1/ImSALoKqj18rvSsX193iu6ahvguTWzCHXtsbMrw0zno/WqCneRpyuHxJiyCaCKsGup +q+PYztey/vlodWbFlxteph4L0UWXzuDzK9V5rX65rurTWfOmkQJo7mWnrcXpdLQ+t99uO4l3FIIv +NLfEaO2476TT0XrVqbfWpnb8SJCKrYBZeq7FWp9p4ktZa+XaPpDDtNPhaO1qQdfNe64UnTTXLni3 +2H3vxDr+KCbbAmjtFXy4Hit+pVoB56NnsAx0LZfnS+HZPnLnQifN5aqd191WB78TvtxN/wVQ3f/X +s1kYfqSj/6S/fUXasDovXcC4JgvVMZJO7QUtPYqkPvg20bV0JVlm6m5rg9MeATHDDV5Qj6Dr2sxJ +kVzPcqtdsPbNdT7pkVuuYv5ZH2i+Jk4QpJK0DC3d7tLbfUWz+EpLHw37der74SvVLz+3C2SdWXd8 +pZYF9BmzgkO8lKZty1CFAu2uWyvORuF8D4LrclKHqgM9cwVVyLh0xvigdXBpecE29l4/XzVKgFQl +l6H6QH20H2pF4UvZpelLOdAG/QgNneCsc1jv0hmaL6XC1qN21onO7K63y0yPDWnxzN4xCkJrKyl7 +XtNK4XxBrVutp2DpMSUEtRV6pwfqU9Mx86bcA2hoP9c60G2XUDBD23ZpIGsbu+SyAE0vKoxWROMl +aPHE0XMezoPuy5sGEKCe21Lr03hstH7N3Y1Vf1Kr/DxQOF9Q35NtXr9vfDFrFRyWWna6KQ+eOlMT +AtLigsus8+RLWT9rRRbL0fMm8LtNPeSuU5gVE+LP23KOPmN0Cgh/FNMlAjT12WGtR33kS1mhZ+uQ +6vy0UaKsoCuk6DFDeByfL2lIZyPGbaX0x03hCNDU9bUef7nQxezJCcfRtcNrouVbobWF3b3GjvUo +wrtFxj72nbl//8jYhYyM/SKJ8Z82MnaPRMZutsT4XRsZu/0T489RZORxjIQ91Ynx5SEyts4kxhes +yNjKFxlbQhPja3FkbFFPjO8OkbFtJjK2XyXGN77I2A4aGduKE2NbekQsNLgz9xgjMhasRMainsR4 ++BQZi8MSY/FcRCwujIwFmInxSDUyGvFGxCLnxHgIHhmL5RPjh4LI2OkiMnZMSYwddyJix6bE2PEr +InaMi4ydBxPjB8vI2Ak1MnbUTYwdmSNiR+87cz/DR8aSAZGxrEJiPD0RGctzJMYTJpGxzEtkNIOT +EM8ERcZSSpGx3FRiLMcVEcuVJcaTbpGx7F1kLA2YGM8nRsYSk4mxBGdELFEaGcu4JsZTt5GxHHBi +PJkcGctKR8bS23fmniePjCXcI2OZ+8RYBSAiVklIjJckImO1jchYkSQxXm2JjJVtEuP1n8hYISky +VpFKjJe2IqMlsohYqS0xXrOLjBX/EuNVxMhYOTIyVtdMjBdII2OV1sR4yTYyVvuNjBWR78y9Gh0Z +K2tHxurjifFCe2SsYp8YLfxHwvQDkTEhQmJc0RAZk0YkxjUWkTGxRmRM9ZEYl49ExnQoiXFBS2RM +GRMZk9gkxqQ6ETHJT2RMO5QYFyFFxtRMiXFZVGRMXxUZE2rdmbviKzImHUuMa9AiY2K2yJgqLjEu +r4uM6fQiY4K/xLhyMDImQUyMaxkjY6LIyKi4MiEu0oyMqT0T47LRyKj8NCImY02M62EjY8LayJhC +NzEu9Y2MaYYT4+LjyJiKOTImh74zd111ZEygnRhXekfGJOORMe15YlzEHhlTwyfGZfWRMX1+ZEzo +nxhrGIiINR5ERhsYEuKNEJGxjorEeGtGZKzHIzLWLJIY7zqJjLWvJMb7YCKj/TQRsb6cxHiDT2Ss +Uygy1nJ0Y0LvUmSsCSox3k0VGe3Kioh1dyWm7tC6R8+rE41e5xpOPi9XZpI+jrmUvom5l8zCm2XI +PnWE3tfc9qYeybm3nfpEyzUWd4zju6VHsre4790j2cNjx/af6SRx5277YKHdfZ0vuQZPf1dR3Cef +cr3tt/Hd0zV5u2+Ty2hja1/T7lv8nm9WN9vaPZJn959XtHS2veBbeiQ/3Bf7+Q/xxfahyx6v9Eje +W22Xo1Ogddis43o9yWscgXmDUtcyQNr/nCHrpAZIe7IzZN3dGbI+cYC04zxD1rueIeuCB0ja6TNj +ffkZsg5/gNQrIEE314EMmX8BQOqEkCHzVABI3RkyZD4PGTLHCIAenScyogYWmVEjDGDUUSND5s2R +IXP5AEj9QjJkziMBunuYACRmKJlRUxVg1J0lQ5P6vGTIHGMAUu+ZDJmLTYbMDwcgddbJkHn0ZMjc +fgBS36AMmQNRhszLCCB1RUrQzV8JIHVqypBaPmXGvKMAUheqDJmfVYbMGQsg9djKkLl1Zch8vwBS +B7EMmRdZhszVDCD1R8uQOa0lyC3bgFHvtwyZixxA6keXIXO2y5B55AGkbnsZMt++DJkDIEDqJZgh +cyXMkPkbAqROiRkyz8UMmXsjQCo3TNDNURIg9abMkCkFM2R+mQCp82aGROSXEXMCBUg9RTNk+rwM +mc8pQOqYmiGT1mXIXFwBUj/YDKkqDhh1qE3Qzes2QyZoA0j9dzOkRr6ZMS0aQOotnCFzKc6Q6cgA +UufkDJkHc4ZUAwaMukJnyPylAVL5VoZO9bxO0M09GyCVXmXIHL0zZN7gAIlqKjPmVp4h8z0HSBVP +GTIv9gyZqztAKlbKkDnNA6Se9RkyoVGGzEcfIHXkT9BNI5QhmxIAkM4byJDpezJkMw== + + + EACSYQqZMWVOhmy+A0A6KSJDpqrJkE2vAEjnYGTIBDEA6WyODNmUjwTdtCwA6eSRDNkMkwyJDAUQ +namSIZvOkiFTkAAkA2MyY5NnMmTaD4B0Gk6GbK4OQKrbyNChs34yZFODAFLJRYJuk4wyZDORAFK1 +RIZsTlOGdOATMKpzyJDNoMqQTbMCSDUKGbIJWwB1NerPs7oyZPqCDNn8MIB0ElmGTBqQoNt0NIB0 +zlqGrKqfIZv9BpBOkcuQFeQz9DjWDgidjpchK6UDpBP7MmSz/zJkVXCAdB5hhmyyYYasgg2QTlsM +0H1uY4as+AyQzpLMkA6lzIzVhN8GdUvbPL5Yt3ZrQHq3yPjHzpBdgAj5pbxD4UfJkP28EfIbJUJ+ +y2XIbt4I+WMQIX+gMmSPZoT8Ic/Q41oRCV9yIuSLV4ZsGYyQL6gR8qU5Q7bIB+i+XUTIN54M2RYW +Id8MI+TbaoZsg46Qb/UZsqAhQh5+RMgDmQxpRBQZD60i5EFahizci5AHjgG6h6AZsmA2Qh4WR8gD +7AxZqB4hD/ozZMeHCPlBJEJ2osmMHY0i5IesCPlxLUNy7IuIHx8j5AfRDNmRNkD3w3GE/JidITuw +R8iP/hmyJEKEPB0RIU9sZMhSJBHyZEuELGuTGUv/RMgTSRHylFSGLLkVIU+TBeiecMuQpe4i5EnA +CHk6MUOWmIyQpzgzZMnSCHnaNUKewM2QpYIj5EnlCFl2OjOW5o6QJ8wj5Kn3DFkSP0D3ckCEvLCQ +IStRRMiLHRnSqklkvPwSIS/kZMhKQhHy4lKEvEyVISt4RcgqZ5HxElyGrJgXIS8LBuheYMyQVioj +4yXPDFnxNEJeho2QF3QzZKXhCHmROUJers6QFb4jpAX0iHghPkNW0o+QiwMi5DKDDJlgIUB36UOG +TEQRIZdjRMiFHRkyiUiEXGwSIZetZMgEMBFyKU2EXJSTIZP3RMiFQhFyyVGGTLwUIZdBZUj1VIG5 +C7Mi5BKvDJlYLEIuO4uQC9gyZFK4CLmoLkIuz8uQCf0i5JLBCLn4MEMmY4yQ6SEj48LKDJlEM0B3 +sWeGTDYaIRegRsilrBkyUWyEXF4bIRfqZsgkvxFy8XCEXIacIRM0R8il0RFykXWGVK0dGVN9Z8bk +43coCNEj5JL2DJk4PkIus4+QC/YzpMr/yFgHQWS0ESEj1tAQIW+NiJA3WWTI2jUi5I0fGbIWkgh5 +M0qA7m0tGbIGmQh5q02ErGcnM9b8EyFvI4qQNyRlaNLWpgh5k1SEvN0qQ9a4FSFvAcuQNZNFyNvS +IuQNbhnSqZQJ8vGWb2Lu9b7wZhl6T1/e29o7tzpgVEjR57R29fxBRmC2jdX3nxTZtUfpglyO2wjM +qSuUHRl3uaZOkVP7K/6lEzArBGufmLlXlfrPG9o7P+AX8/bOD/HFOnqX5s4+ar46AHO9/vLUnhb1 +v6c5DcC8MalonCHr/QZIm8gDdO9GB0jb2gHS8nOGrNEeIGnYB0Yb/zNkDgIAaR07Q+ZpAJCaIwCk +LgsZMrsGgLQiniH1jwBGfSgAEj+LzJgvBkBaXAdInToyZJYfAKl3SIbMhAQgLdMDpLYoGTJ/FYDU +qCVBN8cXgLTgD5B60GTIzGwAUlecDJm9DkAqHQBIDX8yZM5BAIkDETDqZJShVTUIAKm3UobUowkY +9XoCSE2jMmRiBoDUxipD5ocFkBprAaQOXRkyXQRA6hkGkJqPZchczABSO7QE3RQWAKlBG0Dq9JYh +s4wDSL3nMmRaDYDUDQ8gcdXLjLnzAaQ2fwCp6CNDZjwIkDoYZsisEAFST0WAVD+SIXN5BEjtIjNk +vpMAqYElQI9KlIyYnSZAs/hyZsgMPgFSp1CAVNOSoJt3KUBqggqQuqlmyGxZAVJ1TIbMKBYgdZwF +SK1rM2QeuACpziZD5soLkLj7AqMuwRkyu2GAFhHsAKQGyBkyJ2WA1JI5Q+btDJBqfwBSt+kMmW01 +QGJ/nRmz0QZIRUQAqbF3glZ3CAdIrcYBUs/yDJkcCSB1Uc+Q2bEDpL7uAIk/fGZM1wTQLIb1GTLn +e4DUQh+gUbz4M2QKKYBkOEBmbMgAQDqtACAde5AhlVoBo2MYANJ5DhmywRAA6YSJDJloCyCdeQGQ +Ds9I0G0KB0AyzSMzpv4CSMeLAKRzSjJkA08A0skpAImOLDM2yQUgmQiTGZssA5COqAFIBWkZsqE5 +AOn0nQzZGB+A1sdxQMCosi1DNp8IIB10BJAMTMqMDV4CSDVyGbJRUADpTCmAdDhVgm5TrgAStV1m +bOoWQDq+CyCdA5YhGygGkOr2ABpkxFmGbFYaQDp0LUM2vQ0gVQACpPPkMmSD6QDSCXcZslF5AD1q +CQHRwX0ZsgmAAOkowQzZTEKAVJUIkE5JzJCNWwRI5zYCpAMgE3TTNwKkIykzZLMt3wRtw/Mlbqkf +a2ytV3w7gPSDJ+h2CQDSiwmQ/iwZsh8YIL1VANKbLkN2+wKkD0KG7JEC6PHRBEQf8QzZYgGQLjsZ +sgUMIF0KAdJFNUO2PAOkC32GbMsASDcfgHQby5BtiADp1gqQbtIZ0t0eGA0bEnQLQADSUAYgDYoy +ZOEVQBqoZUgjPmA0dARIg9AMWTgLkMTFwGiAnSEL1QHSoD9DdnwASA8iAOmRJkN6NgJGD1kZ0tMa +MHrsA0gPkBmyoyhAeqgFSI/HGdJzNjB6YE/Q7egPkCYRANJ0RIYssQGQpkgyZMkWgDRtA5DkfzJj +iSSANCUFkCa3MqRZMmA03ZYhS9wBpClAgDSZmCFLSwKkCc4MaaYUGE25AqTJ2wxZGhggTShnyFLT +AGmSGyBNlyfolngHSFP4AGkxIENaVQBGyxMZskIHQFoyAUiLLxmyMg5AWhDKkJWWAFqkSAWQlrsy +ZIUzgKQCB4yW8jJkRUGAtLyYIStUAqQlT4C0eJohK8MCpAXdDFlpGCAtMgOk5eoE3QrfAGkJHSAt +xmfIyvoAqUAgQyI0AEQFCwCp9CFDJqIASOUYGTJhB0AqEQFIxSYZMtkKQCqAyZBJaQBSUQ5AKu/J +kOqEgFHBEUAqXcqQiaAAUjlVhkyYBZBKvABSsViCbrIzgFTAliGTwgGkojqAVJ6XIRP6AaSSQYBU +fJghkzECpILIDJm0EiAVaQIkas/MmGwUIBWgZsikrAAtj5pYYFRcmyGT6QKkgl+AVDqcIRMhA6Ry +5gyZMBoglVgDpGLtBN1k3wCpgDxDJkUHSEXtAKk8PkMmtAdIJfsZMvE/QNpGAJA2JGRIOxuA0RYJ +gKTXIjPWtAGQtn9kyBpJANKWFIC0uSVD1iYDkDbcZMhadwCSHiBgtJkoQ9aWBJA2OAGkrVIBujdd +AaTtWxmyRjCApKMMGG1Ny5ANwgRIR2pmyDxW3wSFmt/97QDSD56h93Xnva3Fc65jbXdBd6K7wucf +ZIJnLex/waDLPl5JJ+Q677cWzzpAbU912Frq5N2Jnnr72oa+/wTPjigqnF+ep2Nor4mKM9/U4/nh +vpn3eH6Qb7ZfZi/S5dm139dGeF414HrS+yA4H3Vd0gjPG5S6rgHS/u0MWSc4QNpTniHrTs+Q9bkD +pB3zGbLe+wxZFz9AYgeQGfMVyJA5FACkXgcJurkmZMj8FwBSJ4cMmScEQOoukSHzqciQOV4A9Oic +kRE14MiMGnkAo44gGTJvkQyZSwlA6neSIXNOCdDdgwUgMXPJjJrCAKPuMhma1KcmQ+Z4A5B652TI +XHgyZH4+AKkzUIbMYyhD5lYEkPoeZcgclDJkXkwAqatTgm7+UACp01SG1LIqM+Z9BZC6aGXI/Lgy +ZM5eAKlHWIbMbSxD5lsGkDqgZci81DJkrmwAqb9bhswpLkFuOQeMetdlyFzwAFI/vQyZM1+GzOMP +IHULzJD5DmbIHAwBUi/EDG2LuCpmyPwZAVKnxwyZZ2SGzH0SIJVLJujmiAmQemtmyESOGTK/T4DU +OTRDIk3MiDmZAqSeqBkyQWGGzKcVIHV8zZDJADNkLrQAqZ9thlS8B4w67Cbo5tWbIZPcAaT+wRlS +I+LMmFAOIPVGzpC5LGdoVX0bQOr8nCHzkM6QytKAUVfrDJk/NkCniMkyZJ7dCbq5fwOkGrAMmSN5 +hszbHCBRbmXG3NYzZL7tAKngKkPmJZ8hc6UHSGVSGTKnfIDUcz9Dpm7KkM0BAEgnCiTopknKkE05 +AEjnJWTIpEQZshkOAMkwiMyY/idDNp8CoF0mXWTIZDsZsukbAOkcjwyZ2AYgnS2SIZtSkqCbRAYg +nZySIZvBkiERtgCiM2EyZNNlMmRyFIBk4E1mbHJOhkxDApBO88mQzQUCSKUfGbJZRRmyqUcAqWAj +QbdJTBmymU4AHSKzyJDNmcqQDqwCRrURGbIZWhmyaVwAqaQhQzYhDCCdNZYhUyJk6ND5ZwDpJLUM +mX4gQbfpbgAdMicuQ1b1z5DNrgNIp+BlyGr1GXocyweETvfLkBXYAdKJgxmy2YUZsrI4QDpPMUM2 +mTFDVs0GSKdFBug+dzJDVoMGSGdhZkiHambGisJvgrq2NdQJ7pIV9WE4vFtm7GMDZEX4CNmlDND9 +RwHIxAoRshslQ3bLAWSajgjZY5Ahe6AAMu1LhOwhB+hhrciEy4MiZIsXQLoMZshlVBGypRkgXeQT +dJebRcg2HoB0C8uQy/IiZNsqQLpBZ8jVixnSoCFDFn5kyEWeGZKIKDMWWmXItbAZ0nAvQxY4Juiu +Gc6QBrMZsrA4Q66tzpCG6hmyoB8gk6BHyA4iGdITDTCm1I+QHbIyZMc1gKSfISJ2fMyQHUQBsq6P +AN0OxxmyYzZA1h0TITv6A6RJhAx5F1GELLEBkKZIMuTNVhHSrA0wmv7JkPekRchSUgBpcitD3roX +oFvCDSBN3WXIWxwjZOlEgDQxmSHvBM2QJkszZGnXDHnHbIY0FZwhSypnyPqKM6Np7gxZwjxD3n6d +IU3iJ+hWDsiQd6lnSEsUGbJiB0BSNcmMlV8yZIUcgMzyIEJWXMqQlakAMmeICGnlLDNWggPI/DMi +ZGXBBN0KjACpzUhkrOQJkBZPM+RuLBGygi5AWhrOkLvWRMjK1QBp4TtD6u0TESvEA6Ql/Qy5A1KE +TGYAkAoWEnR3isqQiigyZHKMDJmwAyCViGTIxCYZMtkKQCqAyZBJaTJkohyAVN6TIRMKZcgkRwCp +eClDJoMCSPRUibkJszJkEi+AVCyWIZOdZcgEbACpFC5DJqrLkMnzAFKhX4ZMMpghEx8CpDLGDKke +MjMmrARIJZoJuok9AVLZaIZMgJohk7ICpKLYDJm8NkMm1AVIJb8ZMvFwhkyGDJAKmjNk0ugMmcga +IFFrZ0ZV38CofDxAdyF6hkzSDpCK4zNkMvsMmWAfIFH+Z0Y7CDIjjQiAaENDhqw1IkPWZAGQtmtk +yBo/ANIWkgxZM0qCbm0tAGmDTIas1SZD2rMDjDb/ZMjaiDJkDUkAaWtThqxJKkPWbg== + + + BZA2bmXIWsAA0mayDFlbWoaswQ0gnaqZIB/P+RYm1PvubwbQe/ry3tbfWXtqPbprbyhTty/+DzPC +88qM6KTLWlu8v3NZ6oY8anGuBW+qKKTNhf6SGZ59d3RPZS1AFTS0od04/VAzPPM38/7OD/LN6u8P +u/Z31un31Sme9Sd1ROzjZG2N2x6neN6YVDfOkLWBA6QN5QG6t6YDpE3uAGkFOkPWeA+QdPADo1YA +GTJTAYC0lJ0hMzoASC0TAFLzhQyZjQNAWhTPkDpLAKMWFQCJ10VmzDQDIK2vA6RGHhkySxCA1Fwk +Q2ZTApBW6gFS65QMmQkLQGrnkqCbMQxAWvMHSM1qMmS2NwCpgU6GzIoHIFUPAKT2QBkyoyGAxLEI +GLU+ypDJEABSO6YMqa8TMGoQBZBaTWXI9AwAqf1VhsxICyC15AJIzb0yZNIIgNRwDCC1LsuQmaAB +pHZqCbqJLABSizeA1CwuQ2Y7B5Aa2GXI5BoAqakeQOLOlxmz+QNIDQMBUt1HhszEECC1Q8yQGSsC +pBaNAKmEJENmGwmQGlBmyKwsAVrFFBOgRzFKRkY16QRI7T4zZMahAKkFKUAqa0nQzRYVIDVYBUit +WjNkpq8AqUAmQ2ZEC9AqlrYAqTluhsxmFyCV2mTIrH8BEg9hYNSMOENmawyQanYAUqvlDJlpM0Bq +/5whM5IGSOU/AKm5dYbMJhsg8dvOjBl3A6Q6IoDUTDxBN1tygNTgHCC1Ss+QKZIAUvv2DJkRPEBq +KQ+QeNNnxqRNAKldfobMeB8gtfAHSIcBZMhEUgDJfILM2KADgHRkAkA6fCFDqrYCRsdBAKSDJTJk +IyoA0mEXGTLdFkA6gAMgHeWRoNtQEIBkukhmTAAGkA48AUhHp2TIhrAApONcABIpWWZswAxAMqkm +MzbyBiAdngOQatIyZAN9ANLRQBmyIUMAybQiYFTcliEboASQjmICSGY6ZcaGQwGkMrkM2cAqgHT0 +FUA6RCtBt3FcAIngLjM2IAwgHTUGkA4ty5CNPwNIpXsADTKSLUM23A0gHROXIRs4B5CKAAHSIXgZ +snF6AOlgvgzZiD+AHuWEgOjIwQzZ8EKAdAxihmygIkAqTARIhzxmyMZFAqSDJwHSEZYJukkcAdKx +mhmyAZ1vgypsG9Z6EGvzO1rHFd8uQ/bBA3S/BBmyi5kh+1ki5D9whuxWyZDddBHy2zdD9iBEyB+p +DMmjmRF7xCPki0WGbNmJkC9gGbKlMEO2qEbIl+cM2UIfId8yMmSbT4ZsG4uQb4gZsq01Q7ZJR8h2 ++8xY2BCgewCSIQtlMmRBUYQ8vMqQBWoRsogvMxY6ZsiC0Ah5OJshjYszYwF2hDxUz5AF/RHy40OG +7CCSITvSRMjORpmxQ1aE7LSWGTv2ZcgOkBHyo2iG7FCbITseR8jO2ZmxA3uA7kf/DFkSIUOWjoiQ +JzYyZCmSCHmyJUOWtsmQ5n8i44mkDFlKKkOW3IqQZckyY+m2CHniLkOWAsyQJRMj5GnJDFmCM0KW +Kc2MpVwzZMnbCHkaOEOWUI6Qp6YzZEnuDFm6PED3xHuGLIWfISsGRMiqCpmx8kSEvNCRISuZZMiK +LxHyMk6GrCAUIS8tZciKVBmycleEvHCWIa3AZcZKeRHyomCGrLwYIS9UZshKnhmy4mmEvAybISvo +RshLwxmyInOGrFwdoHvhO0NWQs+QFeMj5GX9DJlAIEIqNMiICRYyZNKHCLmIIkMmx4iQCzsyZBKR +DJnYJEIuW8mQCWAi5FKaDJkoJ0Mm74mQ6YQyY4KjDJl0KUIugsqQyaki5MKsDC0q8cqQicUCdJed +ZcgEbBFyKVyGTFSXIZPnRciFfhkyyWCGTHwYIZcxZsgEkRFyaWWGTKSZIVV7RsZloxkyAWqEXMqa +IdXEZsbEtRFymW6GTPCboVOlwxFyEXKGTM4cIRdGZ8gk1hkysXaA7rLvDJmAPEIuRc+QidozZPL4 +CLnQPkMm2Y+Qi/8zZG0EGbKGhAhZZ0NmrEUiQ9prERlv2siQtX9EyBtJMmQtKRmy5pYIeZtMhqzh +JkLeupMh7QHKjDUTRcjbkjJkDU4ZslapO3Tcm64yZO1bEfJGsAxpR1lmrDUtQjYMEyAdq5mhWW1W +3wbda37h7TJkHzxC7+vOe1OX59RBw1x7z3kdR48fZIpnPRw2frJPDu+bddlHY511ed6aPC8fhx5w ++dytxfV8Tr13fN/3qhuun8faDp/7889HRyNvafL8cF/Mezw/yBfrnPwiPZ7T2PNC/9Tjea8cn3WU +qM2zVv06A5/j0x+CPZAznwSfochYsTcy5nyUGbVQiozUZyNhhk6ZUWeoyFhJNTLmVZUZNb2KjFVB +I2M2XJlRP6/IaOEyI+ovFpibUVlkrNaYGbVOi4xasEXEyoOZUU+4yJi5XGSspJcZtbuLjPnmRUbL +cBnZxMcvMmYImBmtnEXGLAoDc/M6zIxWuyJj7ouRMRvHzEiBKiJmKxkZ86fMjBaVImOOmZEx683M +aB0oMmYGmhl1FY2M1W4iYz6nmVHD1MDcyi2RMQvXzKgXbGSsRBIZc6fNjLjcRsSKGpEx293MqH9v +ZKwQERlzFM6MWhNHxmoHmVGz5MiY63Jgbun+zKgPdGTMUDoykqHPhNpbR8Z8siNjSfXMiHF3RMwA +PDKWBs+MWpJHxrzNM6Op68iY23pkzLY9M5ptDszNSD4y5kifGU0QR8Y88iOjXvsZ0ZRuZMz8PzI2 +RSAzmoaNjM01yIwOSIiMpU4jYyMbMqOzHyJj2c7A3KZRZEbHWkTGEpSRsUEbmdGJHZGxnGJkHgeI +ZEDHkETGsoCZ0cEokbEJK5GxxF1mdOZLZGx4TGQs2ZYZHWdzZ47bXJzIWH4sMzqpJzI68Scilq16 +E1PH/IrKal+tL1rfN75XZPwzZ8i+fIT8Kt6h8HNkyH7XCPkNEiG/0zJkt2yE/N6PkD9EGbKnMUL+ +WGfocXGIhC8xEfK1KkO26EXIV88I+TKcIVvPA3TfGCLkO0yGbKuKkO95EfLNM0O2C0fIt/MMWVwQ +IQ8wIuSRSoY04omMR04R8hAsQxbLRciDwgDdo8sMWZgaIY93I+SBc4YsAo+Qh/IZsjNBhPxwESE7 +pGTGDjsR8lNThPz4lSE5xUXED4MR8lNlhux4GqD7OTdCfmDOkJ28I+RH+AxZLiBCnlSIkGcnMmRp +jgh5viRClnfJjOVvIuSJoAh5RilDlpqKkOe4AnRPlmXIsm4R8vRdhDwPmCFLKEbIM5MZshRnhDxX +GiFPumbIsrcR8jRwhCydnBlLS0fI89sR8kR5hizjHqB76j5CXgPIkBUTIuRViQxpdSMyXiWJkJdb +MmR1mwh5AShCXknKkJWkImSlrch4iSxDVmuLkBftAnSv/mVIq4iR8WpkhqysGSGvj0bIC60Zsopt +hLz0GyGvIWfIitER0pp2RLw0niGrsUfIi/UR8qp/hkw+EKC7DiFDOl0oQzZdKEM2XQggnS6UIZsu +lCGbLgSQThfKkE0XypBNFwJIpwtlyKYLZcimCwGk04UyZNOFAJLpQom5TRfKkE0XAkinC2XIpgtl +yKYLAaTThTJk04UyZNOFANLpQhmy6UIZsulCAOl0oQyNMl0oMzZdCCCdLpSg23QhgHS6UIZsulCG +bLoQQDpdKEM2XShDNl0IIJ0ulCGbLpQhmy4EkE4XypBNF8qQTRcCSKYLZWaQ6ULA6HShAN2nC2XI +pgsBpNOFMmTThTJk04UAkulCmdHpQpmR6UKA6HShDNl0oQzZdCGAZpkulCGbLgSQThfKkE0XStBt +uhBAOl0oQzZdKEM6XQgYnS6UIZsulCGbLgSQThfKkE0XypBNFwJIpwtlyKYLAaTThTJk04UyZGN6 +ANKBPwnyyUFvYm7lvvBekbEPnRj/9onxyxgZ+z0S4z9sZOwOSYzfaonxezYydvMnxp+ixPjjGBl9 +rBPiy0NifJ2JjC1Yd+a+8iXGl9DI2FqcGF/UI2O7Q2J8m0mM71eRkW0vEbZ5JsT24IjYXp4YDwoS +49FFZCxMSYzHO3dxxD1wiowGYAmxOC4iFg8mxgPLxHiEGhkLdRPjMXNiPPiOjEXxifHjQGL8XBEZ +O6Akxk86ifEjU2Ts7HVn7oe4yNhpMDF2qkyIn04jY8fcxPh5OTF+8I6MneAT46mAxHhOITKWnEiM +ZzkS4+mSyFjeJTGewLkzt0RQRCyhlBjPTEXGUlyJ8VxZYjzpFhnL3iXG04CJ8XxiZCwxmRjPcCbG +U6WRsZxrYjx5mxjPAkfm9ba2t/VGrs9714wr2KtNrp7AH2ICZv2JjG5crvD8fXMiF28h3Grd8+bI +rV0+6kmsSGjoCmI/3Mf3frPvJmCuFUyetdV1ZbtWrPc3R37Ab+bdkR/kmx3tyafdkfX3Hrojx2V7 +7vp8nR5qye/lY6xrUDdwKwnGfa3g9A8v0FSftn0gh17Kb9AnF3TUZ6yjU8uxRoR6BOjatd7hFab2 +ymns576faoC27Zzaxmi71BwEdTG8C0FT96MDtHanc8U661UrAqjCpLF+va7i7gyNPaq09s7XPlPr +E2qnb6cXvpZ1whqGtT0H+zBC0Hh0/fLcXvtMbcxSz/HeAQRCFVgcWzsAjL1dEVRLeh/9Dn6ltWvr +Y7txVQh6INQOn1M7Jcxbuue+heapVpyudOJnWru2PgwtTLwq4gQNvWPVz7fS7dSGg2crAKf5tRda +23Gh3nG7LHMJGoflRUc38tv1HbL2DffKR+rpyfVELcdrLzT3YtDuJFcQAdC0zq0cGPbXXmnsPv/x +aEvnV6CpAuOWZE47X6aKQHuvXIfLfjhCy3MfFeuU3AIKelbanXSs1XAe8cFc6s/qXjraI25/BWrT +jVpTW+uMUAdR23r0pkvP3PLcJihHBx3rQLfA0qX1sc2l9tdeqSW3U2tlz5Xu755/XNvu3JESPXJL +V9bbeqU2pJWvQFu3HG0wNR58uaejXWdanL7Qr1tQHVHrYFmr6iuvVG+2zG3EtQx8wevj9KGwVoxX +XqmFuZ1MWpaRoLlWnV4GOyc403WaO6oa+iLM/JnmWnXqFmjV+HVIAGjv7amjomOjn65Nv/e2kKsz +ySuvVAtX7dXt/rfSFZ87hB0uqexwvAK1uKSA/bXPtLTO+ezk0yuvNB8d5naWZqRbvKC6Akf9xr36 +IjS1CLItJ197pbHOJnUPtHSP1p222m/xSJ+RR/7thg5R6p6rhZXugqmj27Vi8PnYcVEpaK4Vsz1h +VvrcFcj3iaAilE4nMNQOPq2WPXGLnvrUOW51HNhe+0hbv0+rZc+TfrqC6gRztofpxB+p3R/Ho5bo +K58FUIvc219omvB6T33CH/vurpWM3+46Vfb5/LVXmq68xlAb/kLPytTJi9rFzqHPOQjVaXnvPbwe +K74HWn1f0cy2Xdl7gub2plnajxyYOsNvZ+vYp+4xYKgi+K3FsifGvOPzUYvSdFxCVw== + + + ZPZ9u8Yo7AfeAmNnwNq7sTMmdL3HWnb29UUNjzv0+LxeHRqd8eWP1Ab7dW4+53mlyz3WqlO/a32/ +bcUteuxs47h19WHGW6CgqT2Jagted/5RajGpcGcbjwO36LETqV3mOJfXPtPY+cjOxr72SsPW8xb6 +AeYrMFQcW79a3Zd4CwzPXTRY9mMaLqdbgOpqdy/TUMExXYGCxmGf+7CJH2moRacC/rV9z+hyD3VE +HdtFsn4/jPYKqn/pJHn/OUItpd36vLbg0zTUolMb5li75o4bdEFText2BHbQbTl00aNdfpdtH+nX +HWrRWVuY3YsqX6bacOYrV7MPfAnGPoG1UvbqvyCol7e2oh83frs+77TJ1Y6faT6fz4pUOy024is1 +NJytFa59kbb6uf3aetEdr0cPobr717Pnssy01TfUsw+uhhfa6gvaerm4zBTpLiio9521/WAvT1WC +pnrEz1qbY9LihekdbO6BMdvIV6CPID26ZT/op2uoNtW95wpd4myApj7M1RNTe88r0OWQ2PNgKKAv +aJy37i5oDTNfgdoulrYZP1/7THV46l6P9kSmC348t6Ns7zvrihe8/qzuyLFvlAlvgvqzir6Ood0b +J7rix3MtYN0k23kSZCr8HLd6mObXPtLWvpx1kXrQCUK1U7TKe3gxBAZoqdt7qmge94JmpuOqQx+v +vVAtumPvrdPlKQtQ/RZHX6L9tVea5jpAzksH/fxK495uktO5XN67BA1breFDbXevvFJXqXrmxLzg +L7fXurN3P0CXqejmbePkupu6efO1VzranPXoyuwKK31B+1XX6DovbfYN1TLfp4xlw5tgr3Wn+yjb +U+6gK74/r92i0gbxI630DVXwMS51/D0oeVfQstV5rgcAXO0lAM1n3wO1Cc+02zc0d62gDhmvvVIn +i/tGmV57pan2+nHonCJfgYpU+rTdtUp6DvbnDuPq3Lstr7xQrRJjP5V1vxDU3vf9y9ZesFISsKC6 +jvVGPXCAvn8xtSxN69C1frrBe0TAsrfZfgWO9MNtz1sFTG34fA4UNjQ0tQJm6zoXrU3bc/1b3XJL +N8jxZ1rOvZ7gWuQnisIb6ppURfQ9KwGhCiyXzv90BxVD3XZ9dH82ZdwKqntt7QTBtr1yneqfK05b +egQRPb4FdZJha6HUyTfBcI0ZmHqcEV2n9fnsgv/aBVd8pYLGfe/K137ibr8+H+s8v/SuUoJr7kEv +dRvUQWM7KTRuqEdrjdf/8Ctt9V9XqL7MM+72PQ+njX7H7pDjS7C2V/fVAbrTFV9r3alF/rLExd2+ +bV271Flh2rzTY7fWunMlXTvlwq/UVfCu39eRhW7fnq50bj31CWOitZadtW6mVpNN/GZDT2WpxalW +MLp5ewZVF8ra1h1faXk++9NchxF8peW5Leb7rSbcxHpS19ze8RXxUN61oB5wc5z9mPMLdaRTu8Xa +Ye8boan7t4aWRNTZu/22w7sBox+boMfvD4xeyAj5T0KQ/LgA6W0C0OPtRojctgDpAwCQPkoEyUMJ +kD7eBMlCAZAuOQDp4kWQLIMA6YIKkC7NBMkiHyHfLgDSjYcg2cIA0s0QIN1WCZINGiDd6gmSoAEg +DT8A0kCGIAmJANLgCiAN0wh6jPeA0cAxQh6CEvQYywKjQTFAEl0TI2E6QBrwEyRHB4D0EAKQHmcI +koMRQHrEAkgPawTJsQ8gPUACpEdRguRQGyE/HgOkB22C5MgOkB7+CZI0AkCakABIUxsEPeZIgNFk +C0CatiFIEkAASSYJGE1JESTJLYA0TRYhT7gRJKk7gDQJCJCmEwmSxCRAmuIkSJKlAGnaFSDJ3xIj +iWCANKUMkCanCZI0N0CaMAdIU+8ESRI/QbdyAEBaWCBIShQAabGDICmbAKQFGIC0lEOQFIUA0vIS +QFqoIkhKXgBJ7QwYqcERI8U8gLQsGCEvMBL0WKkERkueBEnxFCAtwwKkBV2CpDQMkBaZAdJyNUGP +dW9gtIAOkJbiCZKiPkCiDgBGZQYEiWAhQqZ8IEYkFACpGAMglXUQJAIRgFRqApCKVggS+QtAKqQB +SBQ5xIi0ByAVCQGkciOCRLgEkCigiBEpVYRclAWQyrsIEqEYQCo5A0jFawSJDA4gFdQBpNI8gkTk +B5DKBQFS4SFBImEESMWQAKmskiARaEbIpZ4EiWgUIJWfAqRCVoJEEguQimsBUpkuQY96X2BUOAxQ +Z5D/LEEmSMTMAKksGiAVWBMkUm2AHiXfhIh0PEIuQgdI5ewEiTAeIJXYA6RifYJE9g+Q9A8Ao40I +BElLA0DaHAGQdFkQI+0aAGnjB0HSQgKQNqNEyNtaCJIGGYC01QYgbdohSNp/ANJGIoC0JYkgaW4C +SNukANKGK4KkdQsgbQIj6LGbDBhtSwNIG9wIOh9b5SK017rTLsRz/XaUcbtBUQv43s68N3V49ump +Djxbdwx2S/KHn365dfLJWxP7MHdvTaxQ+M9lzGvIt/RB1t55a/CsJ7fbIOuY1LnOrW02v/dbdRBz +9XfWIbGvRcfideO9p7/zg36vW3vnh/hePZxcuzs37e7sgnAXi9ZhbrOcp5/M15JY797J8zq3/eGl +1jt2vbCWpMuJ3ZlPXpjlqNhsmIbLuAOYx5pxRuox6+nHtbjP+DLnVnFbXYAryk/I2tmOpQ9e2zUC +HZilZ0Ms3fYevvknoe6cmbEf3HocK3rDz1Mnjn6WOgm1IFMrfp9yliuMykwtmlM/iVvnCwCR6nVm +2rynTtT1wXtjAKbdZyr6qQcefq2ORNpW/2zXbfw8y/Ti4b4MC15CLYFnZq2TbUWil00IMnX2qRux +3Ybxe7XOoA5/19wEYurpW5c6uY9HH8qBkTo6MC/2yPNy0h3fNuEdXM4V8vBvsddzs3aIOfBv0bNe ++sR6rie+jhbjganbYrn8IAZ8nXOuH6OigVoQ8Rq2odB5TD3kAq5hLaRD+0T0WYYWFq/oA3OstUB2 +tWeHz9Nm8/Uml/UE/RZbp6P6kDrPK/0WFXlVfLq1JdBIS4vLAoCpr15/1oOO8bvPPUxl2XrKMjwX +vbivdeeM53iNHAGmftFxbF1MWuQ/CdoCYOq56sN+PTz43dehFrpOsdBj2oFihVzrtnT5FZkOgpf2 +LMNvrvIEYHoiTU9V2mmR75EOPfdg62wHLM7FLD2/aRy2k3+Jve0YWi+w0CLvGgdg1n2rz9L23PiZ +63QzHbXZvtiwZeasdafzgcuGv8RZ5/u5HZOmBT6OCyWAqTPyudXXn+mn6LkgZ5dN5vq/8JH3TvMN +bfA+0bO1d52qqxR1Z9AVNLUFIEt92KO1MiN+4rrCPa386DuemLmCiDrxHC8TM4BZr6kpFWnRsuKS +jcws814BSb8bLSs9WGatHbke4oWW+L3TjbVrVdRy0nZbzHUCXbqWh59HdR+Z2frXnNtqjJaVnr3T +c6zODsjwdfYKxPr5WnfabveuunWataU//DoiHslMCyDrSNDTNvB1KqCus1GP8Dnxd6+nvKLZ2nTX +FW/niow6Flt6sg4yokBJzNEyyt4De1GA1+kJTmuv3+O5029RTN0WWxed5wmuT5tbTv3wtKgNEVGx +ZKalmD3eqJ8OZJYKIc62G5thZy+mwvyhQqR2oyNmbrepbdqGjXZbl8JkphWddRCuJ5Ein2Jq22oJ +S19FZI5aneoKXfmUjKydl6lItqMsZERPA0xHhLUo1P6GH6czvPXtK67jn6JnWnUWpJcWYmo1Pab2 +7RppjTdRDiBHT1QYW22BTN0XdXrumx6/eZclukJV8QHeqLXqnNtcHJ1gXNcDTPu4DludCOiHOJ/r +cNyqtPrAtKycnZReOtofRlriz66sViAynB2rEaPiIGB6ktnc6ypc5B5GWGe3jkMW2myL6bFhQ6f+ +6EDVPqQvQ8rOa1xhZlRgBEzFw0On/Db8OBW/13LaGhzabItZKsSqZbeeHvzIy9GK5DqhTLTAm0gJ +kG28DId76yJmu6YtLbUw06JSTJ2161atVYV/iX6k5h6OMtD67konYNZWpVQAcdVYgOlQr+KQ+kR4 +gx2dMdyXPnLiL3q0l2s9XtPBP4XKpYBpCVR3GlzessAcW/0c9ZFXWOBbUFW3xdEqqAFix2bqxxh7 +sNUGe+1NcwVM3evXM3iNkgOm/ZjnHs6Jb1VR0zy39OWA0LGZ1roP1zgu/Oqq28pMG9BWGDuNCzwV +zexTbRKtFMt3T2u2xrGHsNXZHo5TzXShoKc0jRD13LRfmWkJcxeWT1o0muljW7/KwZd5q0877lMn +bPHzbD3ctRP3J/8UKiDLTG3pdY/u7RuL71VPTbtwX9JcZCp0bNXE8Mo1rLiynqvetfn3Uh1aZjoD +UYfts8N0ZCq42juFMMOxvpmzM4rjXj8YXMOxhQBrD4ftpx6ZRzFbRlqQXf92ZZeQWXoaYM8Uw0/T +4706bdJiCWIqPLiGgu54BV0QB0yd2eYuQ82wS3ZBp9eLY6utCQKWq+hTkWWdFLudhpjWUYw9UG/g +X0JVdcCc1xy1+j1gjW9NXT3G9byvnVtDpm/As0cBwhrfurtOL9T1m64xl8CINg+Yo5PAtRucEMS3 +Mm/qIKGbzvi3qKPWsnfOcODfok5SYx8HKobC7y4CP0D2jvOXnv2HTPdY1YJRhxz+KV6Cg/pOO/8U +Zz3JnRw4LsVlYkwlCEg/Dl1jXFZ4q+n50jzVde67/o3M9bjVGnG0WfgKbwaQfOjE3L48QHoVAdKf +I0P2uwIk9wcwep9lyG5YgPTOz5A9QgDpswiQPtQZstUBIF1mMmTrFUC68AGkK2iGbCkGSNf0DNnm +AJDuMgDpdpUh2/cAkv0TGN2HM6T7OTAaFyToFmAApJEKQBryZMhiJ4A0CMuQRXMAaVgIkMaXGbJA +FSCNeAHS0DlDFoMDpMF8huxUAJAeLwDSc0qG9LwDjJ6bMmQHMID0JAeQHgkzpEdLYPSICpCedTNk +h2aA9PQdoPsxHiDNBwCkiYUMWYYCIE11ZMhyJgBp8gUgzeJkyNJBAGleCSBNUGXIMl0AScYsM5Z5 +A0hTeABpLjBDmlMERnOTGbIkJ0CaLQVI064Z0vQtMJoGzpDlkwHSxDRAmuFO0C1VDpDm3AGS3H1m +rAYAkNQSMmM1CYCktgGM1kgyZMUWgLRqkyEr/wCkdSSAtCCVIS1sAaMFMoC00pYhK9kBpLW/DFkR +ESCtRgKkZc0MWX0UIKmzZsbqtQBp4RcgrSAn6FaKBkhr2gBpcTxDVmUHSMv1GbK6P0AqIABIlQgZ +MkkDQKqNyJCJLABStQZAKvvIkOlHAFIhSoZM0QKQSmMAUo1NhkysA5CqfgAS9VBmTIUEkKiZMmOq +KIBUXgWQ6rQSdBN8ASTCscyYAA0gVbIBpJK4DJm2DiAV6QGkar8MmWwQINUfZkh1jMCoHhIg0VVm +xvSZAKnQM0OmGAVIpacAjaJhzZCJYQFSVS1AKs/NkOl8AVLBcIZMeQyQSpgBUi10gg== + + + OvUtomqAVJ2dIZN5A6R6cYBUeJ4hU7ADpFL4DJmmHiAV5wOkKv8MWbsAQNp3AJA2MGTIOiEA0paK +DFlvBkDa5AGQdotkyNpOAJL2lcxYGwxA2k8DkDbmZMg6fADSViGAtOcoQd67BMwkPVAZ0l4qYLQn +CyBt7sqQdYkBNFcUs9VaP+CP4i6lb4OCmOf2bpl5tbntTf2RfWCvDaduo9qg2ujyg/dH9pzIWjbG +rhZtXSeoo+PV/q3NfbVhex/hZn2E9Q+3Bsl96j7CrqHVcWXp+uD5/d/ruwbJbewT99CZvnrDtwzA +/HBfzDskP8gXa3cp7ZCcttXnX0rnbxtxVMzTQ0G7BfT4dv6l9hDfoE/uzcjESFczQNofTZB0WgOk +PdsAafc3QdJHDpB2pAOkve0ESZc8QNpvD5B27hM0PXoAROhaXR7cBABSXwKCxOEAIPVKIOjRdAEY +dW8ASH0gCBJHCYDEmgIY9bggSNwyAFLfDYDUwYMg8QIBSF1FIuT+JAQ9+JwAon4pBInzCkDq4QKQ +usEQJL4yAKlDDUBidUOMeOYApO47AKmPD0HiCASQegsBpC5FBInfUYTcOYkg8WACSN2cAFJfKILE +YQog9aoCSF2vCBL/LIDUiQsg9fQiSNzBAFKfMYDUsYwg8T4DSF3UIuR+bAQ9GrsBow5xBInXHEDq +WgeQ+t8R9GikB4w68gGk3n4EiUsgQOo3CNAkzoUEiQciQOqmCJD6MhL0qIKMjDtFEiSekwCJdhEY +dcEkSPw0AVLFIUBi8UmMeIUCpDJBgNS/lCBxQgVIxX0AqTsrQeLzCpBo8ogR59kIuYctQKqkI+jR +VhcYsecFRtVvBIljMEDqPQyQatYIEj9kgNRZGSCVmhEkbs8AqW80QaIQA0i9rBN0c8UmSHRdAKlT +N0Dq+U2QqLEAUh9ygNTRnKBHDRUw6rEOkLq1EyTSJ4DUQZ4g8aIHSBVLAKk/PkHitB8h1xkBpO7/ +BMkcAYBEHwSMTjYgSGYkAKSqHoBkbAMxMv8BINXiAKQzKQiS6RYAqYKGIJm4AZDO7oiQC18Iknki +AOlkEoBUrkKQTEsBSOeuAKQiE4JkFgxAOlUGIJWGECSTbgDSmTkEPQo6gNEpPgDJOCBiRIYRIZ9Q +BJCMOiJGxBMA6fQlgHSOE0EieQBoldlSAOmUKoJEqgCQTs4iSGZwAaQCA4B0LhhBMmEMIJUFRGi1 +qWcEyfw0gLSYD5DOdCNIpsMBpCV4gHRiHUH1R3+efQeQFs4Jknl8AOlkP4C03E3Qw6xBQEaZWQiQ +1qgJkjmKEfKJjABJaZkYmREJkAybBEZLvW+DWtI7tS62AvyOpNK7ZcY+NkDy/TNjFzJBt58EIP1x +M2S3SYbkdgNEb9sM2QOQIXuUANKHMkP2eAOkC0WGbMnJkC1eAOkymCFbUDNkSzNAusgn6LZdZMg2 +HoB0C8uQbYYZsm0VIN2gM2RbPUAaNGTIwo8MWSADkIZEGbLgKkMWpgEk8V5mLHBM0C0EBUhi2cxY +UJwhja6B0TA9QxbwA6RHhwzZISRDdpwBSA9GGbIjVobssAaQHvsyZAfIDNlRFCA91CbodjzOkB20 +AdIje4bs8A+QphEyZAmJDFlqAyDJkWTGki0ZsrQNQJoAypBmkjJjKSmANLmVIUuTJeiWcANIU3cZ +siRghiydCJAmJjNkKU6ANFmaIUu7Zkjzt8BoIjhDllLOkCWnAdI0d4YsYZ4hS70DpEn8AN3LARmy +wgJAWqLIkBU7ANKySYasAJMhK+UApEWhDFl5KUNWqAJIS14Z0tpZZrQGB4wW8zJkZcEE3QqMAEml +MjNW8gRIi6cZsjJshqygC5CWhjNkReYMWbkaIKl7Z8YK6BmyUjxAWtTPkKoDMmMyA4BUsJAgVz4A +oxKKDJkYI0Mm6wBIBSIZMqlJhky0ApDKXzJkQpoMqSIHGJX2ZMhEQhkyuRFAKlzKkCqggFEpVYJu +oqwMmbwLIBWKZcgkZxky8RpAKoPLkAnqMmTSPIBU5JchkwtmyISHAKmEMUMmhsyQySoBUoFmgm5S +T4BUNJohk59myISsAKkkNkMmrs2QyXQBEr1vZkw4nCGTIAOkYuYMmSw6Q4cKrAFSqXaGRPINiErH +E3QToWfI5OwAqTA+Qyaxz5CJ9QFS2X+GtH8gM9aIAJC2NGTImiMypF0WwGi7Roas8QMgbSHJkDWj +JOjW1gKQNshkyFptMmRNOwBp+0+GrJEoQ9aSBJA2N2XI2qQyZA1XAGnrVoasCQwg6SbLjLWlZcga +3ACSWZMR8qmVb4OSFvD2dgC93pn3tv7OvnVrFWgTx6kLOT9Ef2etMza8sX/8986JPKwNct33W39n +Hem2p8K3XvK2s4sHtZ993zf7rsFz3/p8O7fNwP7+CZgf9pt5g+eH+WYdBkiHZ7c5vzYCc+s8yFxb +eR1dj71ON2kG5g365KN7wzVBj+VlYLQFnKDHXvLIeFM6QdLeTpDUqQHSlnuCpHmfILEBAEj8BIiR +kjdAanFAkJglECS2CwCpgQNBUjwHSE0lCBJ7CoLE6AIgtcwgSMrwBImNB0BqCELQ/mgtApCalBAk +BX2CxDgFILVgIUjMXCLktjAEiTSAILGqAUhNbwgS+xyA1IiHIBEZECTmQACpzRBBYlhEkFgfAaRy +BYLEjgkg8XUiRgyiCHp0mgJGZQ8EifkVQGqjRZAYchEk1l4AqYCCILEbI0iMywASBzRixEotQi7F +IEjs3QgSoziAxHGOGLGuA0hEHcSImR5BYssHkBr8ESRWgQSJPASgRewLCRIjRIDUUpEgMWckSIQm +AKlhJEFiPQmQmlgSJHaYBIlkBSC16CRIzD4BUttQgsSAlCARv0TITVEJEntVgsSoFSBxfCVGVDQA +qQktQWJnS5AY4wKkFrsEiR4HILX9JUgMhAl6dCIGRi2NCRJlD0FiswyQGjYTJNbPAKmJNEGPGiFi +xNYaIPHHJkaMtgESx25iRGtEkJiIR8jtyAkSY3OCxCIdIFUtEfTo2g6M2r8TJEbyBIklPUAqfyLo +0SUfGLXbJ0iM+wmSEQAAiY6KGBlKAJCONyBIBiUQtD+OXABIFVkEyRgIgmSgBEA6moIgGXIBkGq7 +CJLBGwTJCI8E3YaBECRjRQBSlRhBMuqEoMeZKcDo8BWCZIwLQSI3A0hHyxD0OKMGGB12Q5CMzSFI +dGsA6SgfgmQoEEA6XoggGVREkCjgANLhSQTJGCaCZKATQDoaiiBR0wGk46oIksFXBMkIrQj5MC6C +HnV5wOh4MIIe54wRIwPLAJpk9BlBIvAjSMaxAaSD3QiSEXEA6bA5gkQqSJAMwANIR+kRJEP5ANpk +vB9BojokSEYOAqTDCwmSMYgAdWnzzwMVCXrULxIjIx4B0mGRBMnYSYJkgGWETAlJjIzUBEiHc74J +WtfnPt/WCWhdel2Pb0fQ4+eOjF8AguRSEiQ/CkD68xL0eJ8QIzccQHrrEiQPAUD6OBEkDyZB8ogD +pIsFQbLsAKQLGEGyFBIkiypAujwTJAs9QLplECSbD0GyjQGkGyJBjzsrMbJFAyR7PTESNETIww+C +JJAhSEIigDS4IkjCNIA04CNIQkeCJAgFSMNZgiQwJkhCbIA0WCdIwn6A9ABBkBxFCJJDDUByOiJG +jlkA6YGNIDn6ESSHSIDkNEqMHGsJkgMyQHrUJkgO7Qm6Hf8JkkQCQZKSAEiTGwRJmgQgTbgQJKkb +giQJBJCmkwiSxBRBkuICSJNlBD1m3YDR9B1BkggkSFKKAElukhhJcgKk6VKCJPFKkKRwAZJcMDGS +VAZI09MESaKbIEmZR8iT7wRJGp+gx3oAMFpYIOixQgGMljoIeqyZECPFF4C0jEOQFIQA0tISQVKk +IkjKXQBJ3YwYKcARJKU8gLQoSJCUFwHSQiVBUvIkSIqnAGkZlqDHei4wWhgmSErMBEmxOkJe9iZI +CugESSkeIC3qEyTyAIBUaECQSBYIEvEDQCqjIEgEGQCptIMgEYkQJHITgFS4QpBIYABSMQ1BIssh +SAQ+AKlUiCARHRH0qF4CRmVQBD3qqYBRYRZBIvEiSMRiEXLZGUHzg34NGBXCESSSOoJEnAeQyvwI +EsEgQSI9BEhFjASJHBIg0VUSIwJNgh6VnsCoZJQgEZ8CpDJWgkQQS5BIawFSkS5BIvclSITDAKkE +mSARMwOksmiCRGBNkEi1I7Sa6JsgkY8DpEJ0gkTSTpCI4wFSmT1BItgHSKX/BEkTAUHSjgCQNjYQ +tDy2SBAkzRYAadsGQdIAApC2khC0PjalECTtLQBpowxBjx03wGjrDkHSBESQtBMBpI1JBEmLE0HS +LBUh67oiZnps3wJI+sCIkYYygqQ1DSBtciNIZmoCpGasb4KiCsjfjqDXu/Pe1uQ5V3w9LMPZCfMu +B/wQTZ71lW3+ZAdf7511eWuFrHvPmzzPPqgcQ7cxtu1I9zTWUeL7vtl3TZ79oY92jNrrk79liucH +/Gbe5Plhvtm9ybMisVfHeG7Hc7tYHWPdSF0AjGM8b9An98ZrYqSDGyDtBSdIusoB0v50gLTTnaDx +sWceIO2+B0j7+AkaHx0BAFJvAYDUpYAg8TuI0GrOCQCpBwNB4uYAkPpCEPRoMAGMOlUApJ4XBIl7 +BkBiwwGM+nkQJM4gAKnHCEDqVkKQ+J4ApA4qEXIvFoIePF0AUW8YgsRlBiD1qwFInW8IEg8dgNSN +ByCx9SFG/IEAUqchgNSziCBxPwJIfZQAUkcmgsTbKULuEkWQ+E0BpM5VAKkHFkHipgWQ+nIBpA5f +BIlXGEDqOgaQ+pcRJE5oAKmnGkDqzkaQ+LwBpI5xEXLvOYIeTeyAUTc8gsRXDyB16ANIvf4IejQN +BEbdBwFSH0OCxBERIPVWBEhdGgkSv0eA1DkSIPWgJEgknIlxV0yCxF8TIBW6ZkYdPwkS71CATA+c +IbEzJUZ8UQFaVDadIfVqJUhcXwEyeXmG1ImWIPG0BUhF+MCIy26E3K8XIOtVAOjRQhgYsSIGxjo6 +ABJ3ZIDUZxkg63wBSLyfAVIXaYCsQQggcbYGSD2yCdI+qgypb3eCbg7gBGm/WYbUlRwg9TcnSPvy +MqSe6wCpeztB0r6YGfWTB0id6QnSJs8MqVs+QeK7D5D1wmZIZwEQJFMFInTrGc7QIZMOCJKZCQBp +Y3VmdIoDQTIPAiDrP8+QjKggRmZdAGRd+hnS+RsEySQPgMzNACCZLgKQzimJ0M30ASCZnQKQTmEB +yMwxAJLJMADpjBmAzEQEIJl7A5BO0AHIzFYAkqk+AOl8IIKGR0+azOjEIoBk9BExatyTIJ/GBJCM +dSJG7Y0ypJOmANKZVQSpDVSGdI4WQItM5CJIzbIypFPCCJJ5YwCZqViGRpmBRpBMUwPIzNcStNqE +N4JkVhxAZlKXIZ1fR5BMwgPIzPwypNP5CJI5fwCZ6SFAMnsQIJ1iCJCZQwL0MFcREA== + + + nc8IkDloAiQzIyPk0ycBUp9RYGQeJkAyWBMYq/e+Bdrn5z7e1M3X2oXa/cO7AaMfm6DH7w+MXsgI ++U9CkPy4AOltAtDj7UaI3LYA6QMAkD5KBMlDCZA+3gTJQgGQLjkA6eJFkCyDAOmCCpAuzQTJIh8h +3y4A0o2HINnCANLNECDdVgmSDRog3eoJkqABIA0/ANJAhiAJiQDS4AogDdMIeoz3gNHAMUIeghL0 +GMsCo0ExQBJdEyNhOkAa8BMkRweA9BACkB5nCJKDEUB6xAJID2sEybEPID1AAqRHUYLkUBshPx4D +pAdtguTIDpAe/gmSNAJAmpAASFMbBD3mSIDRZAtAmrYhSBJAAEkmCRhNSREkyS2ANE0WIU+4ESSp +O4A0CQiQphMJksQkQJriJEiSpQBp2hUgyd8SI4lggDSlDJAmpwmSNDdAmjAHSFPvBEkSP0G3cgBA +WlggSEoUAGmxgyApmwCkBRiAtJRDkBSFANLyEkBaqCJISl4ASe0MGKnBESPFPIC0LBghLzAS9Fip +BEZLngRJ8RQgLcMCpAVdgqQ0DJAWmQHScjVBj3VvYLSADpCW4gmSoj5Aog4ARmUGBIlgIUKmfCBG +JBQAqRgDIJV1ECQCEYBUagKQilYIEvkLQCqkAUgUOcSItAcgFQkBpHIjgkS4BJAooIgRKVWEZhNl +AaTyLoJEKAaQSs4AUvEaQSKDA0gFdQCpNI8gEfkBpHJBgFR4SJBIGAFSMSRAKqskSASaEXKpJ0Ei +GgVI5acAqZCVIJHEAqTiWoBUpkvQo94XGBUOA6QSZIJEzAyQyqIBUoE1QSLVBuhR8k2ISMcj5CJ0 +gFTOTpAI4wFSiT1AKtYn6HiU/QPUf/Sn/gFgtBGBIGlpAEibIwCSLgtipF0DIG38IEhaSADSZpQI +eVsLQdIgA5C22gCkTTsESfsPQNpIBJC2JBEkzU0AaZsUQNpwRZC0bgGkTWAEPXaTAaNtaQBpgxtB +MlczQj6h801Q1AL62xH0emfe2zo865BZ0WU7EJ5tV/o/0BjP8zbrcvEGz3nsXNsxHHXkrFi7nq29 +7tS/dIpnPXfPZ8WYcy0c05saPD/cF/v5D/LF2qHThnjWGeq1KZ5Hlzb7XD4O2xVppimeN+iTj+5N +1wQ9VpeB0TZwgh77ySPjjekESYs7QVKmBkjb7gmSBn6CxAoAIPEUIEYq3gCpzQFBYphAkFgvAKQm +DgRJ7RwgNZYgSCwqCBKzC4DUNoMgqcITJFYeAKkpCEFiLwKQGpUQJPV8gsQ8BSC1YSFIDF0i5NYw +BIkygCCxqwFIjW8IEgsdgNSMhyDRGBAkBkEAqdUQQWJaRJDYHwGkagWCxJIJIPF2IkZMogh6dJsC +RlUPBIkBFkBqpUWQmHIRJPZeAKl+giCxHCNIzMsAEhc0YsROLUKuxCBILN4IErM4gMR1jhixrwNI +NB3EiKEeQWLNB5Ca/BEkdoEEiToEILUwJEjMEAFSW0WCxKCRINGZAKSmkQSJ/SRAamRJ0PJoiUmQ +KFYAUptOgsTwEyC1DiVITEgJEu1LhNwYlSCxWCVIzFoBEtdXYkREA5Aa0RIklrYEiTkuQGqzS5DI +cQBS61+CxESYoEc3YmDU1pggEfYQJFbLAKlpM0Fi/wyQGkkT9CgRIkasrQESj2xixGwbIHHtJkak +RgSJkXiE3JKcIDE3J0hs0gFS0RJBj87twKgFPEFiJk+Q2NIDpOongh6d8oFRy32CxLyfIBkDAJDI +qIiRwQQA6YgDgmRYAkEydgEgFWQRJKMgCJKhEgDpeAqCZNAFQCrtIkiGbxAkYzwSdBsIQpCMFgFI +RWIEybgTgh7npgCjA1gIklEuBInaDCAdL0PQ45waYHTgDUEyOocgka0BpON8CJLBQADpiCGCZFgR +QSKAA0gHKBEko5gIkqFOAOl4KIJETAeQjqwiSIZfESRjtCLkA7kIepTlATPKiDCClodZY8TI0DKA +dPwZQaLvI0hGsgGkw90IkjFxAOnAOYJEKUiQDMEDSMfpESSD+QDSEX8EieiQIBk7CJAOMCRIRiEC +pEMVCXqULxIjYx4B0oGRBMnoSYJkiGWETAhJjIzVBEgHdL4NqqW4wt+zI65+GvPbASSfOzG3CwCQ +XkqA9EfJkP28AMl9AozecBmyWxcgfQgyZI8TQPpgAqSPeIZssQBIl50M2QIGkC6FAOmimiFbngHS +hT5DtmUApJsPQLqNZcg2RIBkZwVGt+gM6V4PjAYNCbqFHwBpIAOQhkQZsuAKIA3TMmQBH0AaOgKk +QWiGLJwFSANjgDTEzpAF6wBp2J8hO0AApEcRgPRQkyE9HQGjx6wM2YENID36AaSHyAzpaRQYPdYC +pAfkDNlRGyA9tAfofvwHSBMJAGlKIkOW3ABI0yQZsoQLQJq6AUiTQBmydBJAmpgCSFNcGbJkGUCS +dcuMpe8A0kQgQJpSzJDmJoHRJGeGLF0KkCZeAdIUboY0FwyMJpUzZOlpgDTRDZCmzBN0S74DpGl8 +gKQekBkrLAAkFYrMWKkDIKmZAKPFlwxZGQcgLQhlyEpLAGmRCiAtd2VI62bAaAEOIC3lZciKggBp +eTFDVqgESEueAGnxNENWhgVI6rmZscIwQFpiBkiL1Qm6lb0B0gI6QFqKz5AV9QFSeUCGTGgAkEoW +AFLxQ4ZMRgGQCjIyZNIOgFQkApDKTTJkwhWAVAKTIRPTAKSyHIBU4JMhkwoBpKIjgES9lBmTQQEk +eqrMmDALIJV4AaRisQTdZGcAiX4tMyaEA0gldQCpOC9DJvMDSAWDAKn0MEObihgBUjlkhlRXCYwK +NAESpWdmTDIKkIpPM2QyVoBUEAuQSmszZCJdgFTuC5AKhzNkEmSAVMycIZNFA6QCa4BUqp2gm+gb +IJWPZ8iE6ACppB0gFcdnyGT2AKlgP0Mm/QdImwgA0naEDFljA0DaIgGQNltkyNo2ANIGkAxZKwlA +2pQCkLa3ZMgaZQCSjpvMWOsOQNoEBJC2E2XIGpMA0hYngLRZKkHedQWMtm9lSPvAgNGGMoC0NS1D +1uQGkIzVBEi9WN8GJRXQ7e0Aer077009nlMdIee581pT3QK18P4QPZ5dQdDxk10teN+sy87qaC9k +Peze5Hk5g9TuO9aWNla01UYZ3//NvmvyHIfno3a9qeKnziu+v8nzA34z7/L8MN9s6RzTY5fn1HfU +a1M8z/m5E6LjNtd6XXdSnOJ5gz65910TIw3cAGkrOEHSVA6QtqcDpI3uBEnLPEDafA+QtvETJIYA +AKm1AEBqUkCQ2B1EyI0TAFILBoLEzAEgtYUg6NFfAhg1qgBILS8IEvMMgMSFAxi18yBIjEEAUosR +gNSshCCxPQFIDVQi5FYsBD1YugCi1jAEickMQGpXA9AmxjcEiYUOQGrGA5C4+hAj9kAAqdEQQGpZ +RJCYHwGkNkoAqSETQWLtFCE3iSJI7KYAUuMqgNQCiyAx0wJIbbkAUoMvgsQqDCA1HQNI7csIEiM0 +gNRSDSA1ZyNIbN4AUsO4CLn1HEGPHnbAqBkeQWKrB5Aa9AGkVn8EPXoGAqPmgwCpjSFBYogIkFor +AqQmjQSJ3SNAahwJkFpQEvQohYyMm2ISJPaaAImAERg1/CRIrEMBUtkhQOJmSozYogKkWkGA1KqV +IDF9BUgVfgCpES1BYmkLkAjziBGT3Qi5XS9AKqcj6NFBGBhxIgZGJXAEiTkyQGqzDJAK1wgS62eA +1EQaINWbESTG1gCpRTZBIhMDSG27E3QzACdIxF0AqSk5QGpvTpBIsgBSy3WA1LydoEchFTBqJw+Q +GtMTJPongNQsnyCx3QdIZUsA6SgAgmSoQIRcbASQDjogaHwcmQCQiISA0SEOBMk4CIBU2gOQTKgg +RkZdAKSCHIB0/AZBMsgDIJXRECTDRQDSMSURcvULQTI6BSAdwgKQalYIksEwAOmIGYBUaUKQjL0B +SAfoAKT6EIJkqA9AOh6IoEdVBzA6sAggmXxEjGgxIuTDmACSqU7EiIICIB00BZCOrCJIdA8A6Rgt +gHQgF0GiVwBIh4QRJOPGAFKVAUA6Ao0gGaYGkGoDIuQD3giSUXEAaUUfIB1fR5AMwgNI6/AA6XA+ +gmTMH0CLVM8JGh5HDwKkQwwB0po3QQ9jFQHR8YwAaaGaIBkZGSEfPgmQ1JeJkXGYAMlcTWC03vs2 +qHa+rXfQZeibPr5ZROxDZ0a+fETsIgbm9mtkRn/WyNj9ERm5zTKhd2tk7LaPjD0/mdEHMTL2RGdG +l4bI2BoTGVusMqOrXmRs+YyMrcOZ0QU9MLedITK2xWRG96rI2KYXGds9M6PbcGRsP8+MBgaRsQgj +MhaqZEZjnshY8BQZi8IyI9FcRCwqDMwtvMyMhKkRsXA3Mho2Z0TD78hYHJ8ZPRBExk4WkbEjSmb0 +rBMZOzRFxk5fmdFjXGTsPBgZO1hmRk+ogbkddSNjZ+bM6OE7MnaKz4ymAyJjeYXIWIIiM5LoiIgl +TCJjmZfMaAonMpoKioillDKjuanIWJIrMLdsWWY07RYZy99FxhKBmdGMYmQsNZkZzXFGxpKlkdGk +a0Y0eRsZywJHxtLJmdG8dGQswR0Zy5RnRlPud+aeu4+MFQEyo9WEyFhZIjNa34iMFUoiYxWXzGjp +JjJWA4qMFZMyo1WpyGh1KyJaJMuIFtsiY1W7wNzKf5mRMmJErByZGa1rRsYKpJGxSmtmtGQbGav9 +RsaKyJmRYnRErKgdGauOZ0bL7JHRcn1ErOyfGdUPBMZ1CBlRPUNkTBgRGVNYZEalGpExzUdkTDyS +GVWhRMbkLJFRWUxGVF4TGdPpRMYEP5lR5VBkVIGUEVUyBWZ2SVRkTFuVGRVpRcbUXpEx2VhmVH8W +GROyRcYUcZlRaV1kTKMXGRP7ZUZVg5Ex+WFkTMeYGRVEBuamrMyMSjQjY1rPyJhoNDOqPo2MyVgj +Y3rYzIiuNiKmz42MCX0zo4rhyJj0ODKmYc6MiqEjI5rqTKg0OzA3jXdkTCyeGVWdR8bk65ExHXxm +VFAfGRXmR8QE/pnRToHIWMtBZLR1ISPaAhEZ66XIjDZlRMa6OwJzaxPJjPabRMYaVyJjHTCZ0Vaa +yFhPTmSsuSczu3QJRcbajSJjfUuZ0QaoyFgnVWakIysi1tkVGWsRy4zMpUyMD7h8E5OkdLc3A+j1 +xra3NUh2gWWtM8W0DnOfAj94g+TWaSKfFbnfOvvCrEhvI6zzz61Bsvbu6alOw/V4r7W9np1CnL73 +m33XIFlXY1vqSalAeX9/g+SH/WbeIPlhvtmtQbK+6uMYzF9/dD796MdPv/n7+qd/99uffvz1N//h +i8+++eKrLz/9+o9PP6s/+qv6nz8xn/z8o3/38S/X3/71l59/8ukf3339k5+8/PvP3/3uiy+vP/mo +74jx23uj/199xK7o1rpa/7L2n3zy3z760X/8rx//4unjeqP/992Pnz75sv7Wx3+d3w== + + + /6e/+ZtPfv3L//D0s6frL/32u7/0V08/+viX4/Db+hv1X//46d9/91nrpequ/80/1z9c/+vjdx/9 +9/qDj/+x/vl/+6izKxU51uNT/3epSPNpqCCnDRUqXlj77Lxcf9L2ZNvSFby68+tPKm7tYkGfi/v6 +f/vlfvNpvWgnq7779z/Wv/+v9Q//d12Bf34ah6e/efo//s/h6fP+MH/3US3jdetUcNKJ9+98imoh +rAVqned2iXn6Q4Cues851W46VOBcZ/96xp87yJna1Ovo3XU8+vQ2XTYza7sW1w38XBFimz92AmgN +yGcfrZcNap1T1743OhtwgyrwqK13qRcZtm5tD5/mjty+Vb3VDZqWq398HSsWW9tR7/ZppuHKfLeb +a29K6/1L3YjPPrpdmxtzv8C3j/KGH6qfoHzD2r//6NMvfvazv/7977/4x3+q2/anv/7yi8+++vzd +r775+osvf/d0/Zef1A39q3/49B/f/exn//HTLz///buv//bTP7x7uaX91eq61x28drJtaqfgn/7d +u09///T4HvUi77743T988/L3x6ef/vyrr5z4xe+/+uz/+ecv/undn6Bf1t6gzC+//OKbLz79/X/+ +759+/vWnX377ckN8w//0RX2fT7/+5uMvf/f7d+8Ba+l4L/Z3X33zaX/pB/AYt+XxF4h/7xe1w737 ++n//7m90b/l3d8v6yl/4zctfsEub3+Lvv/j8m3/4drW5/Xr/6dOvP/3DP+X/Vlao8c/rxb+tCf9/ +WhNeIq5ff/llPcCfP/3uu6hrX3/cG3Vnrtuqc+4z2LUh7rV7t091u+5dnj9TBXHt9NZKlqNtrm6x +1osB8txWs32cmZ8qfHjex6ElOWsX8586tKjgejsvD/e2O9wr1tg6BBja+aszOB3Lt5ahDiGtQul7 +YRufj56ffvZ3Pq9Qqy7P+Ly0RqC+Xn2wp31bL2flOhSPl6XbW95rqqNrO3cvbZ55+Xu1FcfzVIeo +OnNM9Z8OSI6ugHeSZZ62FmI8TZ1tbHemOgLse33ED/S9fv6BvtdVIFjbb20+Ltf2vh86sdCipmOp +v/PnMOvfdop/2yn+gp3ipxXijv/l3b98U79oXYD/+et373795edfFXD9W/32v/zy83f/8vLvv/rm +q6//+N2/T08/7b/38Zf9y3zx6T/1LfTvP/qrjz66tp3PP9q+jeiH7wLjuvXrGgydI9/aILAOlO0c +vF3ebpdxeTul3KCpxWUVLtdDVzH1i3fPDRpbwdjpgHEb2oP1aRzb2rUO5K3TnDq1sVUQvez1Z+e6 +jHVRr3W9M/tt4H5ctf8b8tlHZz3tV95nODu/fwSoF8euGa6dh7uGHdw+zR25fatffBSgoweFzPsx +9QH/2Oqrn12LGdZj6jPe3hnct0H3i3iHrjV071karSMa96ezbatr/6pNdFynLp6NY6sBx/pS18yG +JVzEG1K749hiza0VJrUXtiP1/XWmrq9tLSpazrOr27dPc0fCRQyvM4zPe9t6tv10r859/8zPc/21 +fWthWnsv1pLcstStL+B0nsula5ha8tIZtDqPHRdUH6kf4aWN8SpUePH6XPd6nS7Ejf299r5kc4sq +rgzf/8fe2/bMkl7Xeb9g/sP5YkA24kfdXV1V3fInknIQBmPHkSxYQRAIY3IiT0INDYp+0b/PXvXM +cHqtWteZM8KhYwSxLGrm8Dr9Ul113/vee+21C3KTRaoMdx9yVtt1fc6QCiLz8N8vsjt/6IS7zJKj +GR8TYBwDPK7r/KXLRQ7XE5Xc3+/neSS22e7nhWVsf0Lmfr5KDDyByqZvrqzOCdr3IyF6lYZi7uK9 +fJqCnL9Vga7bXMB93yVaklvpxH3PuwKL2eAex/e+yK72qadrnrm5L54auDK3zvwqkm7f3n+qm2S9 +UiJt81P9ot3K86Mrkygvr1WTcdr9rrLv/E6SLD3kb/ZleQQ/hXlKhzXL0Lbpjj4erl0W1brK0j3e +jk+9SqDwVCXsMtdiv0lHLjc7ZVoux6P1nii7SUu6z0NSkHKRz5AClOtDRr3zofbHh4d8t+83/cv2 +7k8+m8rbMUTgIsvb+6PdOonMXTqPm5bc5y7pzbVB79OW5Ft8mV95aZ+mIOWBOENz61y03us6z4P9 +4RD5rhcZSUtDv7xfYqWf5U17uL5/wobzi0/JYGqIh2oIunM0I6l6vF2P4uTc3Iv01OtP93jTrbQv +KgVquJBucNXwLPe2rxM3TkD/wy9+UbHLndCW5ymFKc3Lh8d3nrtXTchQPvcnvtnlcbhlLqty9MtE +rgp/90+wePuMXywzmJ/li0ms+bAMppRGrxZvejrmPlxnJZCGbWIA+YPK41pjVCZWn8DlKVv+Y/DV +3CaHkOkEPedlNB1MZpnv+vY5I8y6P39r3lHW+Q1Z5nKvUtOojroey90Jul7ukh8umzwdjy3ueX+7 +73fVSbSjva9A25wmZi+dpXcOc+v7UjZ7mWxs5aN/OTZvjUmSjHG5zeNz1wo929JsO5cjqXlscZqb +IGndXL1VFntn5PxEF+hQda1aMmfZmafzuczrPo71WsqzI46aZeAIgu/vo1qOaGPOeU85kO8SFp8Q +RRu3t2PWhhzr78eSeHqdWU3mRLxuc6JVH4qQuSG2+wQ5c9OtOvXfJMm7aL25PQ4z97mSb9rWteg/ +lueiaENBynzR+fluRynzvZivm2rZZwk6gtWritMyC5Z0SB7lR/lufy7boYyb2FRX/XroXfZZ9Z7H +jjtxxFU69fu7ZWj55om8B6vPQ5GunXFtr3PsXrMhSwC/H4bhh4B6ecyxUorc+aIFKb9ngeaCqV9p +PSaGHFu3ZnnIBV1Rja7gXIrlIvvWbX7f/XgiZo+em/Q568Qhtp/vP8/RPM1Ss18m1JiLPBv+rOjP +I1q739f3KEFSmdl/1rl/j2jtBJ0enArd3uSWfFuOpJLitTNy0Qlgvcvsef7nu83SloMT8n4TSt19 +l4prVzn4/DpnZLZT7aWa7KLJUg2ZtU0B1KJ4bH7d4yZM6MhY6SvNpqUl+bgLNTFifgjdBdfj1pgr +vR9SW52SHvt3cfFDepaLfun79v6LKfJZLvqldR/OrXBT8U9agl3qGf3u89g+l4f0h8u9InH//OKI +rlUnn1O0Jh7dCvRlg64aEbMvR3w/4dXxZrMUPg5Vx/M9BFeIK+ftOTTMOnU8yQ8lTCaqWB5qJ9NS +uGnco2I2VV/en+Tl8I7WFI/luzVV5WO56181DO7LAp1+jgZtEmNLSTV7j1pCPhyh3kUO+etctbaf +fMKW86tPC12khl0V7141kvHRQpc5DCkuvs7XnLPNdf1HhC7PD+vyJimrLMgvl+NRtk13ntOH0lc/ +bALHkAXf4eezZOgidnb4mw4Ocw6dnVKa0p/4ZtLPHrGLdAEKGmf7U0PAp8Qun+2bZezyWb7Zc/b4 +W8Qu+/ISu2yPN206OnZf52ZTKmDRxK7Z+DY5YM8R6+8EXdUmqLBgP0SyJ+hLQQoMjgFN66IzAkDH +qJEJwJdDRNyhZQL7i9IWc2WeCGlW1mXWFgnjCZrtZkI/Dat76Fnr0Krf4KbM7zGQAqCHdDlaNx/K +83RoorV5RmYZP+JRgPYJESR7V2CDl+BYj9ajJ+lKjAS++llu2zGPokNPqTPkm/44rMwBmn15O3QI +yxV+36daNGZFmOB7zq4IaS7iLln/fCb44ANtEp/KP/5yg5/u+Tb7wyw3s6pNSMrQbDu3OUDedJ4m +SCdX6Zye10Ps26G52reJB9UGdoHfV+Plnjo+ziVFZNUZePbx7UkPwTz5moMlje5O95tWh5uGB277 +3MD4ZrumdkxENzHfA3+Sxzz1R0Xj/p4W69C+Kgl2W3VKIUjNJUrNaHPsP67qSZf5UGrPvm3wXAra +JDmXoP7Zb8pd1ap5p3k/NW0gM1H0uhw3JUOKuCcI1bAkuHEHWuYHOabIqiaEkEZ8TRh1fxxTATuk +zms10EqrgVdpVa/JMc/hBveSIBUnH5IFPeFGGWhiZfVoKY91xUsgV4PZ2RQ3w3oiaOKP2WeeyvYh +9FAgqelFGg5HkGZnzu+v3ugLXqe5ABNy6VouC3zwOQPOXnJZpK/f4NkVJJnjPLZHdwVBVw0b3iRt +hud714lk15SgRccShqQQ3jWX5gpL3EDzXvvlUKIfwvcO3W+XCQSVabhe4TINJOOF2dzv2zExq0Pa ++dWXoz/v6+BAaipZlBI7lFwEzQM10a/+/wLPwVXNHE9NBpzI+4LQnPbkGyGnggU/02PXszsHEcWt +BD0P3dhFebY73HPKxl+0XWxzTIF3u6mj42ionkXlgdAx2Uaqyf29ONKh59GnozjsDlfgpqaO5xyd +pUK+IbQcc4LmlDI7B/y+AylW1ODHfX/A7TTHvFWj/G76ZAtcyznQXlfp6bVPQ4giaD73nG6WI9Al +aJsj1mxA61WmDASpW+eilhTcMwXtt6fCk5ua5gh6LJrRdTsaNxFSO9NdC+bjyIIAtG1aDtejFaRD +yyw8FzUQSxxN69yiDo+nRntKRww/8PKm9M+u091jp6VAKckjXanTPa1zAz20Vt60le3wA89pbVVV +5a7djJC7/AJkLaPuVIRmK5A5yJw1rgitc4fMZdLDSwuB/uiQJdwvysEiNP901bS352Fj0KFZTrZ5 +niaieUKUMpBOBHNYe07Uf2NoDnDbRYfyZYO7aVG3h0LCiXs3vAWUJphlQNIXWnfus+7MgUZ1rvVG +1/KurORTSbb5ZBf46QZ6PFURne3uSmHKXT0fkiwtlxut8/c3NQHN+nQIdGEXG+gxq5JGU82dh6+k +8+iR0bhgwHd/0+akCOUojCN03G/H6G1a5e5vUpyr5Xx9LHAQG0j5H/lQXC70XN7V+zHBjPRXdwpS +7m+ahb4fIdGFFrmBntIISbxzh6PKrvFNc/vrgduucBDb17fLbZv4StvdAw5igp6XTe3pSlDDZ9KY +q/WqxoQ529Iit77djhtX+pP1ydAxMP5yX3qC4GDU3j7x0DYLKj296yw7c6RRj8BzucAtt6oL5PlQ +ZULt7gRpKuIAUgjQ07uqD+ShmXB3TXdFSKX6m6yijtl5HZIhhRr0ZDmBv8qx1a/KBe4UpKyz7Oic +cVdfPJ1X1renLtGm+es7rXIDqX1asrHbnc5iqonO0zL7jkoJcAk0rPBY4p5XzRdHaE7Qu1JOs4jD +B9/epH9cLyppr3Re0VDH5flQS/b7SFaA5lGSjcEEInCHb2/K8M6lOmzA8Aqsqq3MsW3O0Tt+JPXe +rjKemn+AC66K0Kw4s7fu+5OCFE0IvWgi7yatPl6mfTukfw/t0vjBHzcN4VOX4L7iZZq7dvanhyYB +3/AzKYFwzPw7JlxVaJ+F56bu/m1uOrriGji7aVWRhxk9m/ssPJdjLu8cMmidU9VJs+xVCYPvpiLB +7LqH99GTVrl91p37Ucyb8ItWuf1NwhSNwX3MJ4IbXMOLZ53bDtcUfKF12TVp7ippHw== + + + /Lr7m9bAiYqly+MvN2+iRjf5LUBOZqBdtmmaxHi70lFsoKcOhkoo3iGhKqWNjBKOVu0rrXL7LDuH +Ivmm2B8/+HshcIKG25ViIs0MvyknqS7PC/x0j7erHOPms2sqLUOPi/qMjgASfhaNVp/F+ZiyuUG6 +eKBFPg/79RhXiIzkyxMQ7hqSStBdCfuH3BUWenofb+qw19jliVRokRtom4DwqRBrocPK400ZWRV2 +ddKG33cgieCO1MZOUcrjTfq1ecwPLxC4nR6z7Nxl06caBJ1rB3qoZXbVdF5a5SQ7XNQFfteeAYvq +8+2i3PxEMvscx+A6DTQf6nKIpW90FHu+Xe86qk2INZ8JLsHz7XgGHosclmiVG2iCuUNnP1cBfuDn +2zKb2E3Ks3klWFSfs/DMFjU/CR0MhtjmQHOVy8lGD+Zzlp3boYq4L0/Klg6kYo+mGl53enolIJ9v +P+eUXQV/gqRfu6o2fj3EhgA91ds3EfTz8ATr0EPt9qorzO+Cn0nl0wmspKukGGUgBfsqOu8U8D0u +b6qSXRUR3g/zmQ5pMrfeat8P1SZA6mU+JIZ08hvopoTyHMTnP/vvO4ySCPc5rM6FgMPKGXpX0Cgc +k6HT7dberTPxsQHyC9ChuJQFOv8oAPnP26G4UToUtxxAfvN2KB6DDsUDBZA/mh2Khxygl7WiE7Hk +dCgWL4B8GexQLKgdiqUZIF/kG3TaLjoUGw9AvoV1KDbDDsW2CpBv0B2KrR4gDxo6FOFHhyKQAcgi +os5EaNWhCNIA8nCvQxE4NugUggLkwWyHIizuUATYAHmo3qEI+gHy40OH4iDSIT/RAONHow7FIatD +cVwD6PXY15E4PnYoDqIA+ZG2QafDcYfimA2QH9g7FEd/gDyJ0KFIR3QoEhsAeYqkQ5Fs6ZBnbYDx +9E+HIpHUoUhJAeTJrQ5FmqxBp4QbQJ6661AkATsU6USAPDHZoUhxAuTJ0g5F2rVDkcAFyFPBHYqk +coc8Ow2Mp7k7FAnzDkXqHSBP4jfoVA7oUBQWAPISRYei2AGQVU06E+WXDkUhByAvCXUoiksdijIV +QF7w6pBXzjoTJTiAvJjXoSgLNuhUYATIKpWdiZInQF487VCUYTsUBV2AvDTcoSgydyjK1QB54btD +VkDvSBTiAfKSfodCHNChkBkA5IKFBp2kDwC5iKJDIcfoUAg7AHKJSIdCbNKhkK0A5AKYDoWUpkMh +ygHI5T0dCqFQh0JyBJCLlzoUMiiATE/VmJMwq0Mh8QLIxWIdCtlZh0LABpBL4ToUoroOhTwPIBf6 +dSgkgx0K8SFALmPskOshOxPCSoBcotmgk9gTIJeNdigEqB0KKStALortUMhrOxRCXYBc8tuhEA93 +KGTIALmguUMhje5QiKwBMrV2Z1z1DYzLxwt0FqJ3KCTtALk4vkMhs+9QCPYBMuV/Z7yDoDPWiACI +NzR0KFojOhRNFgB5u0aHovEDIG8h6VA0ozTo1NYCkDfIdChabTrkPTvAePNPh6KNqEPRkASQtzZ1 +KJqkOhTtVgB541aHogUMIG8m61C0pXUoGtwAuqjRe99mqYSy0ba/HSngu6aeQL7pxJR63/nNAPqR +vrxPctfVnJGJmTe5tV41OebH3HU3tb//xP7O+ROzhV2PXNTZFnZbX67Ovp08aGeViv7O+arzefY5 +QOp5l6HLvs8D8VPf7HqcBmZhustCZTZ9deN+QnvnZ/xiP/9jfLHZbFdv75R130t7p6q9D1UM73q0 +teIu7133cypTpLLKU0vQer1ohNrzpmrRiWll4w7NTbvvik2um+o3AGkyx22diPlI3hdIZeP52Ncj +1bRp6QZoPeaEHg557ct9WQrQHXp31VuVSlS9G6Aj0FekL18/YC7zEyjpfnvs/QqoSL3JMv2ifvwb +frmoZHdo04SX2cPnKj3xCsydcpTdnhqvgpAMdSaunBvviZ9ptolZhbaL9ji8llET75Bq1HeNmHrc +8VrKT3JuTSWkLvjl7tf3Q9NTDxAwqkusGoZ3ffCljPI6QBqOoeFzl50v5QTV61Gfk202QjfNvrrK +GkobXIcm6FqO+HRWZrwCUagHaO6RdZYiTQnBV7psGnY3j9NhUUTQoorLfgyGg5/ucRRLNKRO8RJ8 +u1PJHyB50MiOYbZY+EyzEe+bbFjWXe31CC06WCn6uNJ9OfHZnLxkKzVPFV3Mk3gAoLkCu5wf9kOr +0KFZSuYZn9/kesyZA+h+SB4ucqBBRpn2ebFZfemBOqkQALrJqmNZPvJEaRamtkzVL67MrBqNq/TB +vuKPokKQYmvFH/jlQs4A0NxMSrFstwtfynnAZ7lclB154BWYM/NtmV1uuTwX/HnlmKYpQpq0ga8U +ygiA7poBN0uBphsjJFsm1d0eO98EF3kayVh4uT7xM6k6tWkK0L7RxTxpLABSUk/Ow9sxsBIghedH +vupCF3NXivCpwriqM/hK87ipyjF/dkxX7VCoNQA66iCrRlLv+O12GSXPeq9HgRjZOctARcoPfCFV +zGQsLP0Av5LLPjokvdasuvOGclAi6HZX3W2VwzO+kvyvNEtaAQ1+prvyeousv1a+lqEg6dCi33bT +lNRlhZVec541Gn2Oj++efh26zT/rydOcWfxMquI9JevZjto5QK9alI4cnrx3TULZ+FLqBH6Rt5Lu +OoJmBZjI+HqMZYeFYD/KgRoUfn8eNXiAXNXSoE3KTO2aWjHovtS08LtWeo3GesCPMpCOMDJvncUC +PpNG3Ox6oGbzPar5ALk+pkMaKCobxbsGqyKkKUoyDb2vd7hRBtKMV1lEPo/Zoh1SjVJR+FFZQciV +Nh3SCMCLCqy3Q9gD0CGC1PpLm4/sMJ8qv2oU4A0/ktLocxs8rvOCeC1DsgOQQstZMDQ3D7+cBk1q +cPos4nwtJ9Z7THipKX0P/FVUON3l/fW40PHopP4B6HqRYfChPoWFQD56quEdFukUp2zKXMtwTick +vOCzKqmUsM2Wz9cyZEQATVS4P5eHXMvgCswJX976KrssGz11SgNILjmHrLmk/EoXBTLPixzj4Vqe +BEkAHQU1Lb8rHdvXt32iK9kAa8Y3vtKu2qOyK5eFzkfrURVWkUeVQ2JC2QTQRNhPDWmWuzpB888P +qTMnvtzwMq3rewlLGXx+pTmvXTTcVmZpBIVGCqDlcUzpmt0O7sv1TX67chJXFIIvtEhitCrue9Lp +aD3q1Ju0qYofCXKxFTB3jYtb5zPd+FLOWrnKB/Jy2+lwtKpaoLq5Jn7TSVNzEp8Su+9KrOOPErIt +gI7BDZfjseJXmhVwmZtctpRwLe9vh8JTPnLPO50070ft/KE57csTvtxJ/wXQ3P/Hs6nhEQjpT/Tt +J9KG1fmuAoamIM877nRqH+i+TNCvEfM3upapJOvM3G0yON0fs7TCDT6QxmKpNvOkSO6uSsiqqHBd +nvTI3Y9i/lPjyOft8FKGJK1Dd7W7aLufaBZf6a6joV7nutNef1dNZZEL5JxZd3wlyQJ0xpzgEC9l +aNs6NKGA3HVnxdkonB/ornKSQtULPXMDTch4V8b4QevgXfKC7aq9fjlqlAC5Sq5DGlAzR/uLJp3j +pVRp+lAOyKAfoYsSnHMO0y7doeVQKsxSsswqQGf21Nt1Znalm8Qzu2IUhFYpKR9amyicH0i6VY0W +XS6U3NGEZGWTZ63cVzpmnpR7AF3k5zoHuu0QCnZo2w4N5Gxjh1wWoNu7CkOKaLwEEk88NOfh+aD7 +8qQBBOiigFfzjTdavxZ1Y82fzCq/XCicH0j35OWYZM8Xc9Hg3Vl21JQHT12oCQGRuOAw63zypZyf +VfMBH5o3gd/ttqh0LCPoBz10yyHn0BlDKSD8UUKXCNBNZ4d1HvUrX8oJPaVDumnUEt7h7yHF3CV8 +HF8OaYiyEddtpfTHSeEI0E31tcuqnha4mJqc8HiodihNKVyCM3SM+dUae51HEd6tMvGxz8z5+1cm +LmRl4hdpTP60lYl7pDJxszUm79rKxO3fmHyOKmOPYyXiqW5MLg+ViXWmMblgVSZWvsrEEtqYXIsr +E4t6Y3J3qExsM5WJ/aoxufFVJnbQysRW3JjY0isSocGZOccYlYlgpTIR9TQmw6fKRBzWmIjnKhJx +YWUiwGxMRqqV8Yi3IhE5NyZD8MpELN+YPBRUJk4XlYljSmPiuFORODY1Jo5fFYljXGXiPNiYPFhW +Jk6olYmjbmPiyFyROHqfmfMZvjKRDKhMZBUak+mJykSeozGZMKlMZF4q4xmchmQmqDKRUqpM5KYa +EzmuikSurDGZdKtMZO8qE2nAxmQ+sTKRmGxMJDgrEonSykTGtTGZuq1M5IAbk8nkykRWujKR3j4z +5zx5ZSLhXpnI3DcmKgAViUpCY7IkUZmobVQmiiSNyWpLZaJs05is/1QmCkmViYpUY7K0VRkvkVUk +Sm2NyZpdZaL415isIlYmypGVibpmY7JAWpmotDYmS7aVidpvZaKIfGbO1ejKRFm7MlEfb0wW2isT +FfvGeOG/EqEfqEwIERqTiobKhDSiMamxqEyINSoTqo/GpHykMqFDaUwKWioTypjKhMSmMSHVqUhI +fioT2qHGpAipMqFmakzKoioT+qrKhFDrzJwVX5UJ6VhjUoNWmRCzVSZUcY1JeV1lQqdXmRD8NSaV +g5UJCWJjUstYmRBFVsbFlQ1JkWZlQu3ZmJSNVsblpxUJGWtjUg9bmRDWViYUuo1JqW9lQjPcmBQf +VyZUzJUJOfSZOeuqKxMC7cak0rsyIRmvTGjPG5Mi9sqEGr4xKauvTOjzKxNC/8ZEw0BFovGgMt7A +0JBshKhMdFQ0JlszKhM9HpWJZpHGZNdJZaJ9pTHZB1MZ76epSPTlNCYbfCoTnUKViZajE1N6lyoT +TVCNyW6qynhXVkWiu6sxc4fOPfo8OtHodY7h5Mv9yEzSxwmX0k9iziWz8mYdik9doR9rbvukHslF +2858ovsxFvdax3dbj6S2uJ/cI6nhsVf5zyhJrNytDhbe3ad8yTF4+vuK4n7LKdfbfhrffTsmb+s2 +OYw2Nvmaqm/xJ77Z3GyreiSf6j+faOkpe8FP6ZH8fF/s53+ML7ZfVPb4SI/kudX2/lAKdA6bc1yf +J3mtIzBPUOtaBsj7nzsUndQAeU92h6K7u0PRJw6Qd5x3KHrXOxRd8ABZO31noi+/Q9HhD5B7BTTo +5DrQofAvAMidEDoUngoAuTtDh8LnoUPhGAHQq/NER9zAojNuhAGMO2p0KLw5OhQuHwC5X0iHwnmk +QGcPE4DMDKUzbqoCjLuzdOjmPi8dCscYgNx7pkPhYtOh8MMByJ11OhQePR0Ktx+A3DeoQ+FA1KHw +MgLIXZEadPJXAsidmjrklk+dCe8ogNyFqkPhZ9WhcMYCyD22OhRuXR0K3y+A3EGsQ+FF1qFwNQPI +/dE6FE5rDUrLNmDc+61D4SIHkPvRdSic7ToUHnkAudteh8K3r0PhAAiQewl2KFwJOw== + + + FP6GALlTYofCc7FD4d4IkMsNG3RylATIvSk7FErBDoVfJkDuvNkhE/l1JJxAAXJP0Q6FPq9D4XMK +kDumdiikdR0KF1eA3A+2Q66KA8Ydaht08rrtUAjaAHL/3Q65kW9nQosGkHsLdyhcijsUOjKA3Dm5 +Q+HB3CHXgAHjrtAdCn9pgFy+1aGne1436OSeDZBLrzoUjt4dCm9wgEw11ZlwK+9Q+J4D5IqnDoUX +e4fC1R0gFyt1KJzmAXLP+g6F0KhD4aMPkDvyN+ikEepQTAkAyOcNdCj0PR2KGQgA2TCFzoQyp0Mx +3wEgnxTRoVDVdCimVwDkczA6FIIYgHw2R4diykeDTloWgHzySIdihkmHTIYCiM9U6VBMZ+lQKEgA +soExnYnJMx0K7QdAPg2nQzFXByDXbXTo4bN+OhRTgwByyUWDTpOMOhQzkQBytUSHYk5Th3zgEzCu +c+hQzKDqUEyzAsg1Ch2KCVsAqRr1w6yuDoW+oEMxPwwgn0TWoZAGNOg0HQ0gn7PWoajqdyhmvwHk +U+Q6FAX5Dr2OtQPCp+N1KErpAPnEvg7F7L8ORRUcIJ9H2KGYbNihqGAD5NMWC3Se29ihKD4D5LMk +O+RDKTsTNeFPg9TStlzfrVvVGtDerTL5sTsUF6BCeSnPUPlROhQ/b4XyRqlQ3nIdipu3QvkYVCgf +qA7Fo1mhfMg79LpWVCKXnArl4tWhWAYrlAtqhXJp7lAs8gU6bxcVyo2nQ7GFVSg3wwrlttqh2KAr +lFt9hyJoqFCGHxXKQKZDHhFVJkOrCmWQ1qEI9yqUgWOBziFohyKYrVCGxRXKALtDEapXKIP+DsXx +oUJ5EKlQnGg6E0ejCuUhq0J5XOuQHfsqksfHCuVBtENxpC3Q+XBcoTxmdygO7BXKo3+HIolQoUxH +VCgTGx2KFEmFMtlSocjadCbSPxXKRFKFMiXVoUhuVSjTZAU6J9w6FKm7CmUSsEKZTuxQJCYrlCnO +DkWytEKZdq1QJnA7FKngCmVSuUKRne5MpLkrlAnzCmXqvUORxC/QuRxQoSwsdChKFBXKYkeHvGpS +mSy/VCgLOR2KklCFsrhUoSxTdSgKXhWKylllsgTXoSjmVSjLggU6Fxg75JXKymTJs0NRPK1QlmEr +lAXdDkVpuEJZZK5Qlqs7FIXvCnkBvSJZiO9QlPQrlOKACqXMoEMhWCjQWfrQoRBRVCjlGBVKYUeH +QiJSoRSbVChlKx0KAUyFUkpToRTldCjkPRVKoVCFUnLUoRAvVShlUB1yPVVhzsKsCqXEq0MhFqtQ +ys4qlAK2DoUUrkIpqqtQyvM6FEK/CqVksEIpPuxQyBgrFHrIyqSwskMh0SzQWezZoZCNVigFqBVK +KWuHQhRboZTXViiFuh0KyW+FUjxcoZQhdygEzRVKaXSFUmTdIVdrVyZU350J+fgZKkL0CqWkvUMh +jq9QyuwrlIL9DrnyvzLRQVAZb0ToSDQ0VChbIyqUTRYdinaNCmXjR4eihaRC2YxSoHNbS4eiQaZC +2WpToejZ6Uw0/1Qo24gqlA1JHbp5a1OFskmqQtlu1aFo3KpQtoB1KJrJKpRtaRXKBrcO+VTKBuV4 +y09izvW+8mYd+pG+vE9r79zmgDEhhc5pcvX8o4zAlI3VT58UqdqjdUHeH6cRmDdVKBUZq1wzp8ib +/BX/sRMwJwSTT8yiVWX+3ye0d37GL5btnZ/jiyl6t+ZOHTU/OgBzPf7yTZ4W85+3pQ3APDGtaNyh +6P0GyJvIC3TuRgfI29oB8vJzh6LRHiBr2AfGG/87FA4CAHkdu0PhaQCQmyMA5C4LHQq7BoC8It4h +948Axn0oADI/i86ELwZAXlwHyJ06OhSWHwC5d0iHwoQEIC/TA+S2KB0KfxWA3KilQSfHF4C84A+Q +e9B0KMxsAHJXnA6FvQ5ALh0AyA1/OhTOQQCZAxEw7mTUodU1CAC5t1KH3KMJGPd6AshNozoUYgaA +3MaqQ+GHBZAbawHkDl0dCl0EQO4ZBpCbj3UoXMwAcju0Bp0UFgC5QRtA7vTWobCMA8i95zoUWg2A +3A0PIHPV60y48wHkNn8AueijQ2E8CJA7GHYorBABck9FgFw/0qFweQTI7SI7FL6TALmBJUCvSpSO +hJ0mQIv5cnYoDD4BcqdQgFzT0qCTdylAboIKkLupdihsWQFydUyHwigWIHecBcitazsUHrgAuc6m +Q+HKC5C5+wLjLsEdCrthgO4m2AHIDZA7FE7KALklc4fC2xkg1/4A5G7THQrbaoDM/rozYaMNkIuI +AHJj7wat6RAOkFuNA+Se5R0KORJA7qLeobBjB8h93QEyf/jOhK4JoMUM6zsUzvcAuYU+QFfz4u9Q +KKQAsuEAnYkhAwD5tAKAfOxBh1xqBYyPYQDI5zl0KAZDAOQTJjoUoi2AfOYFQD48o0GnKRwA2TSP +zoT6CyAfLwKQzynpUAw8AcgnpwBkOrLOxCQXgGwiTGdisgxAPqIGIBekdSiG5gDk03c6FGN8AFpf +xwEB48q2DsV8IoB80BFANjCpMzF4CSDXyHUoRkEB5DOlAPLhVA06TbkCyNR2nYmpWwD5+C6AfA5Y +h2KgGECu2wPoYiPOOhSz0gDyoWsdiultALkCECCfJ9ehGEwHkE+461CMygPoVUsIiA/u61BMAATI +Rwl2KGYSAuSqRIB8SmKHYtwiQD63ESAfANmgk74RIB9J2aGYbflJ0HZ5O8Qt82NdpfWqbweQf/AG +nS4BQH4xAfKfpUPxAwPktwpAftN1KG5fgPxB6FA8UgC9PpqA+CPeoVgsAPJlp0OxgAHkSyFAvqh2 +KJZngHyh71BsGQD55gOQb2Mdig0RIN9aAfJNukO+2wPjYUODTgEIQB7KAORBUYcivALIA7UOecQH +jIeOAHkQ2qEIZwGyuBgYD7A7FKE6QB70dyiODwD5QQQgP9J0yM9GwPghq0N+WgPGj30A+QGyQ3EU +BcgPtQD58bhDfs4Gxg/sDTod/QHyJAJAno7oUCQ2APIUSYci2QKQp20AsvxPZyKRBJCnpADy5FaH +PEsGjKfbOhSJO4A8BQiQJxM7FGlJgDzB2SHPlALjKVeAPHnboUgDA+QJ5Q5FahogT3ID5OnyBp0S +7wB5Ch8gLwZ0yKsKwHh5okNR6ADISyYAefGlQ1HGAcgLQh2K0hJAdytSAeTlrg5F4Qwgq8AB46W8 +DkVRECAvL3YoCpUAeckTIC+edijKsAB5QbdDURoGyIvMAHm5ukGnwjdAXkIHyIvxHYqyPkAuEOiQ +CQ0AccECQC596FCIKAByOUaHQtgBkEtEAHKxSYdCtgKQC2A6FFIagFyUA5DLezrkOiFgXHAEkEuX +OhQiKIBcTtWhEGYB5BIvgFws1qCT7AwgF7B1KKRwALmoDiCX53UohH4AuWQQIBcfdihkjAC5ILJD +Ia0EyEWaAJnaszMhGwXIBagdCikrQPdXTSwwLq7tUMh0AXLBL0AuHe5QiJABcjlzh0IYDZBLrAFy +sXaDTrJvgFxA3qGQogPkonaAXB7foRDaA+SS/Q6F+B8gbyMAyBsSOuSdDcB4iwRA1mvRmWjaAMjb +PzoUjSQAeUsKQN7c0qFokwHIG246FK07AFkPEDDeTNShaEsCyBucAPJWqQKdm64A8vatDkUjGEDW +UQaMt6Z1KAZhAuQjNTsUHqufBJWa3/ntAPIP3qEf6877tBbPZY616oJWonvC5z/KBM9Z2P8Rgy51 +vLJOyHXZTy2ec4DaPsxh6z4nbyV65u1nG/rpEzwVUUw4f3+7PS7ympg485N6PD/fN8sez8/yzfbD +7MW6PFX7/dgIz6MGPE+6DoLLY65LG+F5glrXNUDev92h6AQHyHvKOxTd6R2KPneAvGO+Q9F736Ho +4gfI7AA6E74CHQqHAoDc66BBJ9eEDoX/AkDu5NCh8IQAyN0lOhQ+FR0KxwuAXp0zOuIGHJ1xIw9g +3BGkQ+Et0qFwKQHI/U46FM4pBTp7sABkZi6dcVMYYNxdpkM396npUDjeAOTeOR0KF54OhZ8PQO4M +1KHwGOpQuBUB5L5HHQoHpQ6FFxNA7urUoJM/FEDuNNUht6zqTHhfAeQuWh0KP64OhbMXQO4R1qFw +G+tQ+JYB5A5oHQovtQ6FKxtA7u/WoXCKa1BazgHj3nUdChc8gNxPr0PhzNeh8PgDyN0COxS+gx0K +B0OA3AuxQ9vdXBU7FP6MALnTY4fCM7JD4T4JkMslG3RyxATIvTU7FCLHDoXfJ0DuHNohkyZ2JJxM +AXJP1A6FoLBD4dMKkDu+dihkgB0KF1qA3M+2Qy7eA8Yddht08urtUEjuAHL/4A65EXFnQigHkHsj +dyhclju0ur4NIHd+7lB4SHfIZWnAuKt1h8IfG6Cnick6FJ7dDTq5fwPkGrAOhSN5h8LbHCBTbnUm +3NY7FL7tALngqkPhJd+hcKUHyGVSHQqnfIDcc79DoW7qUMwBAMgnCjTopEnqUEw5AMjnJXQopEQd +ihkOANkwiM6E/qdDMZ8CoN0mXXQoZDsdiukbAPkcjw6F2AYgny3SoZhS0qCTRAYgn5zSoZjB0iET +tgDiM2E6FNNlOhRyFIBs4E1nYnJOh0JDApBP8+lQzAUCyKUfHYpZRR2KqUcAuWCjQadJTB2KmU4A +PUxm0aGYM9UhH1gFjGsjOhQztDoU07gAcklDh2JCGEA+a6xDoUTo0MPnnwHkk9Q6FPqBBp2muwH0 +sDlxHYqqf4didh1APgWvQ1Gr79DrWD4gfLpfh6LADpBPHOxQzC7sUJTFAfJ5ih2KyYwdimo2QD4t +skDnuZMdiho0QD4Ls0M+VLMzURT+JEi1rcuc4A5ZkQ7D5d06Ex8boCjCVyguZYHOPwpAIVaoUNwo +HYpbDqDQdFQoHoMOxQMFUGhfKhQPOUAva0UnUh5UoVi8APJlsEMpo6pQLM0A+SLfoLPcrEKx8QDk +W1iHUpZXodhWAfINukOpXuyQBw0divCjQyny7JBFRJ2J0KpDqYXtkId7HYrAsUFnzXCHPJjtUITF +HUptdYc8VO9QBP0AhQS9QnEQ6ZCfaIAJpX6F4pDVoTiuAWT9DBWJ42OH4iAKUHR9FOh0OO5QHLMB +iu6YCsXRHyBPInQou4gqFIkNgDxF0qFstqqQZ22A8fRPh7InrUKRkgLIk1sdyta9Ap0SbgB56q5D +2eJYoUgnAuSJyQ5lJ2iHPFnaoUi7dig7ZjvkqeAORVK5Q9FX3BlPc3coEuYdyvbrDnkSv0GnckCH +sku9Q16i6FAUOwCyqklnovzSoSjkABSWBxWK4lKHokwFUDhDVMgrZ52JEhxA4Z9RoSgLNuhUYATI +bUYqEyVPgLx42qF0Y6lQFHQB8tJwh9K1pkJRrgbIC98dcm+fikQhHiAv6XcoHZAqFDIDgFyw0KCz +U1SHXETRoZBjdCiEHQC5RKRDITbpUMhWAHIBTIdCStOhEOUA5PKeDoVQqEMhOQLIxQ== + + + Sx0KGRRApqdqzEmY1aGQeAHkYrEOheysQyFgA8ilcB0KUV2HQp4HkAv9OhSSwQ6F+BAglzF2yPWQ +nQlhJUAu0WzQSewJkMtGOxQC1A6FlBUgF8V2KOS1HQqhLkAu+e1QiIc7FDJkgFzQ3KGQRncoRNYA +mVq7M676Bsbl4wU6C9E7FJJ2gFwc36GQ2XcoBPsAmfK/M95B0BlrRADEGxo6FK0RHYomC4C8XaND +0fgBkLeQdCiaURp0amsByBtkOhStNh3ynh1gvPmnQ9FG1KFoSALIW5s6FE1SHYp2K4C8catD0QIG +kDeTdSja0joUDW4A+VTNBuV4zk9hSr3v/GYA/Uhf3qf1d86eOo/uqg3lpvbF/25GeB6ZEZ90OWtL +9nfe73NDPmZxngXvNlGIzIX+MTM8dXeop3IWoAkaZGh3vf2xZnj2b5b9nZ/lm83fv+ze3zmn349O +8Zw/mSOijpOzNW57neJ5YlrduEPRBg6QN5QX6NyaDpA3uQPkFegOReM9QNbBD4xbAXQoTAUA8lJ2 +h8LoACC3TADIzRc6FDYOAHlRvEPuLAGMW1QAZF4XnQnTDIC8vg6QG3l0KCxBAHJzkQ6FTQlAXqkH +yK1TOhQmLAC5nUuDTsYwAHnNHyA3q+lQ2N4A5AY6HQorHoBcPQCQ2wN1KIyGADLHImDc+qhDIUMA +yO2YOuS+TsC4QRRAbjXVodAzAOT2Vx0KIy2A3JILIDf36lBIIwBywzGA3LqsQ2GCBpDbqTXoJLIA +yC3eAHKzuA6F7RxAbmDXoZBrAOSmegCZO19nwuYPIDcMBMh1Hx0KE0OA3A6xQ2GsCJBbNALkEpIO +hW0kQG5A2aGwsgRoNVNMgF7FKB25ukknQG732aEwDgXILUgBcllLg062qAC5wSpAbtXaoTB9BcgF +Mh0KI1qAVrO0BcjNcTsUNrsAudSmQ2H9C5B5CAPjZsQdCltjgFyzA5BbLXcoTJsBcvvnDoWRNEAu +/wHIza07FDbZAJnfdmfCuBsg1xEB5GbiDTrZkgPkBucAuVV6h0KRBJDbt3cojOABckt5gMybvjMh +bQLI7fI7FMb7ALmFP0A+DKBDIZICyOYTdCYGHQDkIxMA8uELHXK1FTA+DgIgHyzRoRhRAZAPu+hQ +6LYA8gEcAPkojwadhoIAZNNFOhMCMIB84AlAPjqlQzGEBSAf5wKQSck6EwNmALJJNZ2JkTcA+fAc +gFyT1qEY6AOQjwbqUAwZAsimFQHj4rYOxQAlgHwUE0A206kzMRwKIJfJdSgGVgHko68A8iFaDTqN +4wLIBHediQFhAPmoMYB8aFmHYvwZQC7dA+hiI9k6FMPdAPIxcR2KgXMAuQgQIB+C16EYpweQD+br +UIz4A+hVTgiIjxzsUAwvBMjHIHYoBioC5MJEgHzIY4diXCRAPngSIB9h2aCTxBEgH6vZoRjQ+WnQ +hG2XdR7E2fwe0nHVt+tQfPACnS9Bh+Jidih+lgrlD9yhuFU6FDddhfL27VA8CBXKR6pD9mh2JB7x +CuVi0aFYdiqUC1iHYinsUCyqFcrluUOx0Fcot4wOxebTodjGKpQbYodia+1QbNIVit2+MxE2FOgc +gHQoQpkORVBUoQyvOhSBWoUi4utMhI4diiC0QhnOdsjj4s5EgF2hDNU7FEF/hfL40KE4iHQojjQV +irNRZ+KQVaE4rXUmjn0digNkhfIo2qE41HYojscVinN2Z+LAXqDz0b9DkUToUKQjKpSJjQ5FiqRC +mWzpUKRtOuT5n8pkIqlDkZLqUCS3KhRZss5Euq1CmbjrUKQAOxTJxAplWrJDkeCsUGRKOxMp1w5F +8rZCmQbuUCSUK5Sp6Q5FkrtDkS4v0Dnx3qFI4XcoigEViqpCZ6I8UaEsdHQoSiYdiuJLhbKM06Eo +CFUoS0sdiiJVh6LcVaEsnHXIK3CdiVJehbIo2KEoL1YoC5UdipJnh6J4WqEsw3YoCroVytJwh6LI +3KEoVxfoXPjuUJTQOxTF+AplWb9DIRCokAsNOhKChQ6F9KFCKaLoUMgxKpTCjg6FRKRDITapUMpW +OhQCmAqllKZDIcrpUMh7KhQ6oc6E4KhDIV2qUIqgOhRyqgqlMKtDd5d4dSjEYgU6y846FAK2CqUU +rkMhqutQyPMqlEK/DoVksEMhPqxQyhg7FILICqW0skMh0uyQqz0rk7LRDoUAtUIpZe2Qa2I7E+La +CqVMt0Mh+O3Q06XDFUoRcodCzlyhFEZ3KCTWHQqxdoHOsu8OhYC8QilF71CI2jsU8vgKpdC+QyHZ +r1CK/zsUbQQdioaECkVnQ2eiRaJD3mtRmWza6FC0f1QoG0k6FC0pHYrmlgplm0yHouGmQtm60yHv +AepMNBNVKNuSOhQNTh2KVqkz9Dg3XXUo2rcqlI1gHfKOss5Ea1qFYhgmQD5Ws0OL26x+GnSu+ZW3 +61B88Ar9WHfeJ3V53hQ0LLP3PI/j6OOPMsVzHo4YP6mTw4/NutTR2GddPk9NnoePgwZcvqm1eJ7P +m/aOn/pec8PpeZzt8E2ff3koGvmUJs/P98Wyx/OzfDHl5O/W43m7al7oH3o8z5Xj5xwlZvOcVX/O +wM/rh78r9kDJfFl8hioTxd7KhPNRZ9xCqTJWn61EGDp1xp2hKhMl1cqEV1Vn3PSqMlEFrUzYcHXG +/bwq44XLjri/WGFORmWViVpjZ9w6rTJuwVaRKA92xj3hKhPmcpWJkl5n3O6uMuGbVxkvw3VkMx+/ +yoQhYGe8claZsCgszMnrsDNe7apMuC9WJmwcO2MFqoqErWRlwp+yM15Uqkw4ZlYmrDc743WgyoQZ +aGfcVbQyUbupTPicdsYNUwtzKrdUJixcO+NesJWJEkllwp22M+ZyW5EoalQmbHc74/69lYlCRGXC +Ubgzbk1cmagddMbNkisTrsuFOaX7O+M+0JUJQ+nKWIa+E25vXZnwya5MJNU7Y8bdFQkD8MpEGrwz +bklemfA274ynrisTbuuVCdv2zni2uTAnI/nKhCN9ZzxBXJnwyK+Me+13xFO6lQnz/8rEFIHOeBq2 +MjHXoDM+IKEykTqtTIxs6IzPfqhMZDsLc5pG0Rkfa1GZSFBWJgZtdMYndlQmcoqVeR0g0gEfQ1KZ +yAJ2xgejVCYmrFQmEned8ZkvlYnhMZWJZFtnfJzNmXmc5uJUJvJjnfFJPZXxiT8ViWzVJzFzzJ+o +bPbV+aLzfet7VSY/c4fiy1cor+IZKj9Hh+J3rVDeIBXKO61DcctWKO/9CuVD1KF4GiuUj3WHXheH +SuQSU6FcqzoUi16FcvWsUC7DHYr1vEDnjaFCucN0KLaqCuWeV6HcPDsUu3CFcjvvUMQFFcoAo0IZ +qXTII57KZORUoQzBOhSxXIUyKCzQObrsUISpFcp4t0IZOHcoIvAKZSjfoTgTVCgPFxWKQ0pn4rBT +oTw1VSiPXx2yU1xF8jBYoTxVdiiOpwU6n3MrlAfmDsXJu0J5hO9Q5AIqlEmFCmV2okOR5qhQ5ksq +FHmXzkT+pkKZCKpQZpQ6FKmpCmWOq0DnZFmHIutWoUzfVSjzgB2KhGKFMjPZoUhxVihzpRXKpGuH +IntboUwDVyjSyZ2JtHSFMr9doUyUdygy7gU6p+4rlDWADkUxoUJZleiQVzcqk1WSCmW5pUNRt6lQ +FoAqlJWkDkVJqkJR2qpMlsg6FLW2CmXRrkDn6l+HvIpYmaxGdijKmhXK+miFstDaoajYVihLvxXK +GnKHohhdIa9pVyRL4x2KGnuFslhfoaz6dyjkAwU66xA65NOFOhTThToU04UA8ulCHYrpQh2K6UIA ++XShDsV0oQ7FdCGAfLpQh2K6UIdiuhBAPl2oQzFdCCCbLtSY03ShDsV0IYB8ulCHYrpQh2K6EEA+ +XahDMV2oQzFdCCCfLtShmC7UoZguBJBPF+rQ1aYLdSamCwHk04UadJouBJBPF+pQTBfqUEwXAsin +C3Uopgt1KKYLAeTThToU04U6FNOFAPLpQh2K6UIdiulCANl0oc5cbLoQMD5dqEDn6UIdiulCAPl0 +oQ7FdKEOxXQhgGy6UGd8ulBnbLoQID5dqEMxXahDMV0IoMWmC3UopgsB5NOFOhTThRp0mi4EkE8X +6lBMF+qQTxcCxqcLdSimC3UopgsB5NOFOhTThToU04UA8ulCHYrpQgD5dKEOxXShDsWYHoB84E+D +cnLQJzGncl95r8rEh25MfvvG5GWsTPwejckftjJxhzQmb7XG5D1bmbj5G5NPUWPycayMP9YNyeWh +MbnOVCYWrDNzXvkak0toZWItbkwu6pWJ3aExuc00Jveryti214jYPBsSe3BFYi9vTAYFjcnoojIR +pjQm452zOOIcOFXGA7CGRBxXkYgHG5OBZWMyQq1MhLqNyZi5MRl8Vyai+MbkcaAxea6oTBxQGpMn +ncbkkakycfY6M+dDXGXiNNiYOFU2JE+nlYljbmPyvNyYPHhXJk7wjclUQGMyp1CZSE40JrMcjcl0 +SWUi79KYTOCcmVMiqCKRUGpMZqYqEymuxmSurDGZdKtMZO8ak2nAxmQ+sTKRmGxMZjgbk6nSykTO +tTGZvG1MZoEr8/G2tk/rjVzfdtWMJ9ibTW6ewD/GBMz5ExvdeD/C8x+bE3nPFsJt1r1sjtzk8jFP +4kRCF1UQ9XA/fvKbfT8Bc51g8jlbnSrbs2L9eHPkZ/xm2R35Wb7ZQ5583h05f++lO/J6395Un5/T +wyz5Wj6ucw3mBpaS4LqvE5z+3Tt0m08rH8iLlvIT9OUBPeYzztFJcqwrQhoBuqrWe/kIM3vl7arn +Xk81QNv2vMnGaDvUHASpGK5C0E396ACt6nSeWGc9akUATZh0nV9PVdydoatGlc7e+bHPJH3C7PRy +euFrOSesy2WV56AOIwRdH6pfPrePfSYZs8xzvCuAQGgCi8cmB4CrtiuCZknX0e/Br7Sqtn6VG9eE +oA+E5PB5k1PCsrV77jtouc2Ko0onfqZVtfXLRcLEoyJO0EU71vx8K91OMhx8SgF4Wz72QqscF+Yd +t8Myl6Dr5f6uo7vy2+kOWXXDfeQjaXryPFH3x8deaNFiIHeSI4gA6LYuUg5c9o+90lV9/teHLJ0/ +At0mMJYk87bzZZoIVHvlejnshyt0f9NRcU7JElDQsyJ30uushssVH8z7/NncSw95xO0fgWS6MWuq +tM4IKYja1oc2XXrm7m8yQXko6FgvdAvcVVq/ylxq/9grSXJ7k1b2udL9rfnHs+0uipTokbursi7r +ldmQVr4Csm55yGDq+uDLfXvIdUbi9Dv9ugPNEXUOlrOqfuSV5s3ui4y47he+4PNxdCicFeMjryRh +rpJJ9/uVoGVWHS2DygkudJ0WRVUXXYSFP9Myq87cAlKNH4cEgHZtT4qKHhv9dDL93mUhN2eSj7zS +LFyzV8v9b6UrviiEvRxS2cvjI5DEJQPsH/tMd+mcn0o+feSVlofCXGVprnSLDzRX4A== + + + Mb+xVl+EbhJBynLyY690nbPJ3AOS7tG6I6t9iUd0Rr7yb3dRiDL33CysdBfcFN2uE4Mvjx0XlYGW +WTHlCbPS555AXieCiVCUTmBIDj5Syz5xi77p1Hnd5jiwfewjbXofqWWfT/rpBpoTzFMepjf+SHJ/ +vD5miT7yWQBJ5C5/odsNr/dNJ/yr7u5ZyfjtjlOlzucfe6Xbkde4zIZ/p2flpuTF7GLPi845CM1p +edcePo8V3wNS3080s21H9p6gRd40d/mRAzNn+O0pHftNPQYMTQS/SSz7xJj3+vaYRen2OISuyOz7 +doxR2B94C1yVAZN3ozImdL2vs+zs67saHnfo69t6dGgo48sfSQb7c25+LstKl/s6q878rvP9thW3 +6KuyjddN1YcFb4GBbvIkmi143flHmcVkwp3t+njgFn1VIlVljuf9Y5/pqnyksrEfe6XLpnkLeoD5 +Clwmjp1fbe5LvAUubyoa3PfH7XI43QI0V1u9TJcJjukKDHS97IsOm/iRLrPoTMC/yveMLvdljqhX +uUjO74fR3kDzL0qS688RkpR203ntjk/TZRad2TCvs2vuuEEPdJO3oSKwB92WFxU95PJ73/Yr/bqX +WXRWCbO1qPJlmg1nOXI1+4UvwVUnMCllj/4LgrS8yYr+uvHb6bwjk6sdP9PyfHtOpKq02BVfSdDl +Ka3w7Iu01S/ya9Oiez0ePYTm7l+fmsuy0FYvSLMPjoYX2uoH2rRcHGaKdBcMpH1nlR/s4alK0G0e +8eeszTVp8c5oB1s0MGa78hXQEUSjW/YH/XSCZlPdNVfoEGcDdNNhbp6Y2Xs+Ah0OiZoHQwH9QNdl +U3eBNMx8BWa7uMtm/PmxzzSHJ/V6yBOZLvjjTY6y2nfWFS/4/NnckVfdKDe8CebPJvp6XOTeeKMr +/nibBUxNssqTIDPh53Wbh2n52Efa5Ms5F0mDThCanUIq78u7ITBA97m9bxPN414g5vY46tCPj73Q +LLpX7a23w1MWoPktHrpE+8de6bbMAXK5K+jnV7rucpO8Pe+H9y5Bl23W8Mtsdx95JVWpNHNiueMv +t8+6s6sfQGUqunllnDx3k5o3P/ZKD5mzPlSZXWGlH2g/6hqq89JmL2iWeZ0y7hveBPusO+qjlKfc +g674/raqRUUG8Vda6QVN8HG9z/H3Qcm7ge7bnOc0AOBoLwFoeeoemE14od1e0KJawRwyPvZKShbr +Rrl97JVus9dfL8op8hWYSEWnbdUq6TnY3xTGzbl3u3/khWaVuOqpnPuFIHnf65edvWClJOBAcx3n +jTRwgL7/MLMs3daLav10g2tEwH2X2f4EjvTDbW/bBEwyfH5eKGwQdJMCZlOdi9am7W3+bW65uxrk ++DPdn/s8wbPI3ygKF6Sa1ET0mpWA0ASWd+V/1EHFkNquH+rPpozbQHOvrUoQbNtHrtP888Rpd40g +osd3ICUZNgmlnnwTXI4xAzeNM6LrtL49VfBfVXDFVxrouu+qfO1P3O3Xt8e6LO+9q5TgWjToZW6D +OWhsTwqNBWm01vX4X36lbf7rCdXvy4K7vebhyOj3qg45vgSrvLqPDtCdrvg6684s8oclLu72snVV +qXPCtGWnx26ddedIuirlwq+kKrjq93NkodtX05Wem6Y+YUy0zrKzzs0kNdmN3+yiqSyzOM0KRjev +ZlCpUCZbd3yl+9tTn+Y4jOAr3d9kMa+3uuEmpkldi7zjJ+KhvOtAGnDzeOox5xdSpDO7xaqw9xOh +m/q3LpJEzNlbftvl3YDxj03Q6/cHxi9khfInIch+XID8NgHo9XYjxG5bgPwBAMgfJYLsoQTIH2+C +bKEAyJccgHzxIsiWQYB8QQXIl2aCbJGvUG4XAPnGQ5BtYQD5ZgiQb6sE2QYNkG/1BFnQAJCHHwB5 +IEOQhUQAeXAFkIdpBL3Ge8B44FihDEEJeo1lgfGgGCCLromxMB0gD/gJsqMDQH4IAciPMwTZwQgg +P2IB5Ic1guzYB5AfIAHyoyhBdqitUB6PAfKDNkF2ZAfID/8EWRoBIE9IAOSpDYJecyTAeLIFIE/b +EGQJIIAskwSMp6QIsuQWQJ4mq1Am3Aiy1B1AngQEyNOJBFliEiBPcRJkyVKAPO0KkOVvibFEMECe +UgbIk9MEWZobIE+YA+Spd4Isid+gUzkAIC8sEGQlCoC82EGQlU0A8gIMQF7KIciKQgB5eQkgL1QR +ZCUvgKx2BozV4IixYh5AXhasUBYYCXqtVALjJU+CrHgKkJdhAfKCLkFWGgbIi8wAebmaoNe6NzBe +QAfIS/EEWVEfIFMHAOMyA4JMsFChUD4QYxIKgFyMAZDLOggygQhALjUByEUrBJn8BSAX0gBkihxi +TNoDkIuEAHK5EUEmXALIFFDEmJSqQinKAsjlXQSZUAwgl5wB5OI1gkwGB5AL6gByaR5BJvIDyOWC +ALnwkCCTMALkYkiAXFZJkAk0K5RST4JMNAqQy08BciErQSaJBcjFtQC5TJegV70vMC4cBkgZ5B8k +yASZmBkgl0UD5AJrgkyqDdCr5JsQk45XKEXoALmcnSATxgPkEnuAXKxPkMn+AbL+AWC8EYEga2kA +yJsjALIuC2KsXQMgb/wgyFpIAPJmlAplWwtB1iADkLfaAORNOwRZ+w9A3kgEkLckEWTNTQB5mxRA +3nBFkLVuAeRNYAS9dpMB421pAHmDG0HP11a5Cu2z7siFeJnfjjJuJ6hqAX+0M++TOjx1epoDz6aO +QbUkf/7pl5uST9maqMPcuTVxQuEfypjHkG/rg5y989TgOU+u2iDnmKRc5yabzZ/8Vgpijv7OOSTq +WigWnxvvR/o7P+v3OrV3fo7vpeHk3t25eXenCsIqFq2XRWY5H/75ciyJ8+5Kns+57e/ea71X1Qtn +STqc2JP58p25PyY2u9wuh3EHMK81447MY6bpx7O4L/gyz23itrkAR5TfkFXZjrsOXtsxAh2Yu2ZD +3NX2Xr75l6Xu3JmrHtx5HCd6w88zJw49S0pC3ZGZFV+nnPsRRnVmFs2bnsRN+QJArHrdGZn3zIl6 +Prg2BmDkPjPRzzzw8GspEpGt/lOu2/h57rd3D/f75Y6X0EvgnVnnZDuR6GETgsycfeZGlNswfi/p +DObwd8xNIGaevvU+J/frQ4dyYKyODsy7PfJyf9IdL5twBZfLhDz8W+zz3KwKMS/8W2jWi06sz/WJ +r+PFeGDmtrgffhAXfJ3nMj/GRAOzIOI1lKHQ83HTkAu4hrOQXuQTobMMLSxZ0Qfmsc4CqWrPDp9H +ZvPzJof1BP0Wm9JROqQuy0q/xUReE59usgS60tKSsgBg5qvPn2nQMX73RcNU7pumLMNzocV9nTvn ++rweI0eAmV/0epUupi3yXxZtATDzXOmwPw8Pfvf1MgudUiz0mCpQnJBr3e4qvyKjIPguzzL85i5P +AEYTaTRVaadFXiMdNPdgU7YDFudh7prfdL1sT/4ldtkxSC9wp0U+NQ7ArPs2n0X23PiZ53Rze8xm ++27D1pnnrDvKB943/CWec75f5Jh0u8PHSaEEMHNGfm7z9Rf6KTQX5KmyyTL/Fz7yrjTfRQbvN3q2 +dtWpVKWYO4OuYKgtALnPh31IK3PFTzxXWNPKH7rjiVkmiJgTz+N9YgYw6zE1ZSItWlZSstGZ+7JP +QKJ3o2VFg2XW2ZHnIb7TEr8r3Ti71kQtT9puhzlOoHfV8vDzuO6jM5t+zUVWY7SsaPaO5lg9FZDh +6+wTiOn5WnfabndV3ZRmlfSHX8fEI52RAHKOBJq2ga8zAfWcjTTC54m/+zzlE83OpruueDtPZKRY +7K7JOsiYAqUxD8kotQdqUYDX0QSnVev39bnTbzHM3Babis7LDa6PzC1vengkakPEVCydkRRT4430 +dCBznxDiKbuxBXb2YSbMv0yIJDc6Yha5TW237bLRbptSmM5I0TkH4XkSKfIZZrYtSVh0FZF5zOo0 +V+jIp3RkVV5mIllFWciYngYYRYSzKMz+hh9HGd759hPX8U+hmVbKgmhpIWZW08dNvl1XWuNDlAPI +QxMVrlJbIDP3xZyeddPjN1dZQhWqiQ/wRp1V57ktw9EJJnU9wMjH9bLNiYB+iOfbHI6lSpsPTMvK +U0npu6L9y5WW+KcqqxOIXJ6K1YhxcRAwmmS2aF2Fi6xhhHN2Uxxyp812GI0Nuyj1Rwcq+ZC+Dyl7 +HuMKO+MCI2AmHr4o5bfhx5n4fZZTaXBosx3mPiHWLLvz9OBHvj+kSJ4Tyo0W+BApAbJdD8NhbV3E +bMe0pfsszLSoDDNn7blVZ1XhX0KP1KLhKBda31PpBMwqVcoEEEeNBRiFehOHzCfCG+yhjOF+15ET +f9GHvFzn8bo9+KdwuRQwkkCp0+DwlgXmsc3PMR95hQVegqq5LR5SQV0gdhQzP8ZVg6022GtPmitg +5l4/nsFjlBww8mNeNJwT32qipmWR9OUBoaMYad0vxzgu/Oqu2+qMDGgnjL1d7/BUiNlvs0lIKdbv +Hmm2rlcNYZuzPRynxKhQoClNV4h6TtqvzkjCrMLykxYNMTq26VUefJm3+bTX/aaELX6eTcNdlbh/ +8k/hArLOzJY+9+gu31h8r3lq5MJ9SHORmdBRqonLR67hxJXzXGnX5t/LdWidUQZiDttPhenITHC1 +K4WwwLFezFMZxes+Pxhcw6uEAKuGw+qpR+ZVzNYRCbLn347sEjJ3TQPUTDH8NBrvpbSJxBLETHhw +DAXd8QqmIA6YObMtKkMtsEuqoKP14rHN1gQBy1H0mchyTopqpyFGOoqrBupd+JdwVR0wz2OO2vwe +sMZLUzeP8Tzvq3JryOgGfGoUIKzx0t0pvTDX73aMuQTGtHnAPJQEnt3gCUG8lHk3BQlqOuPfYo5a +9105wwv/FnOSuuo4MDEUfncT+AGyK86/a/YfMuqxmgVjDjn8U7wHB/Oddv4pnvMkKznwOBSXjQmV +ICB6HFRjvK/wVre3Q/M011l3/Scyx+M2a8RDZuErvBlA9qEbc/ryAPlVBMh/jg7F7wqQ3R/A+H3W +obhhAfI7v0PxCAHkzyJA/lB3KFYHgHyZ6VCsVwD5wgeQr6AdiqUYIF/TOxSbA0C+ywDk21WHYt8D +yPZPYHwf7pDv58B4XNCgU4ABkEcqAHnI06GInQDyIKxDEc0B5GEhQB5fdigCVYA84gXIQ+cORQwO +kAfzHYpTAUB+vADIzykd8vMOMH5u6lAcwADykxxAfiTskB8tgfEjKkB+1u1QHJoB8tN3gc7HeIA8 +HwCQJxY6FBkKgDzV0aHImQDkyReAPIvToUgHAeR5JYA8QdWhyHQBZBmzzkTmDSBP4QHkucAOeU4R +GM9NdiiSnAB5thQgT7t2yNO3wHgauEORTwbIE9MAeYa7QadUOUCecwfIcvediRoAQFZL6EzUJACy +2gYwXiPpUBRbAPKqTYei/AOQ15EA8oJUh7ywBYwXyADySluHomQHkNf+OhRFRIC8Gg== + + + CZCXNTsU9VGArM7amajXAuSFX4C8gtygUykaIK9pA+TF8Q5FlR0gL9d3KOr+ALmAACBXInQoJA0A +uTaiQyGyAMjVGgC57KNDoR8ByIUoHQpFC0AujQHINTYdCrEOQK76AcjUQ50JFRJApmbqTKiiAHJ5 +FUCu02rQSfAFkAnHOhMCNIBcyQaQS+I6FNo6gFykB5Cr/ToUskGAXH/YIdcxAuN6SIBMV9mZ0GcC +5ELPDoViFCCXngJ0NQ1rh0IMC5CragFyeW6HQucLkAuGOxTKY4BcwgyQa6EbpNS3iaoBcnV2h0Lm +DZDrxQFy4XmHQsEOkEvhOxSaeoBcnA+Qq/w7FO0CAHnfAUDewNCh6IQAyFsqOhS9GQB5kwdA3i3S +oWg7AcjaVzoTbTAAeT8NQN6Y06Ho8AHIW4UA8p6jBmXvEjA364HqkPdSAeM9WQB5c1eHoksMoGWi +mG3W+gv+KOlS+mlQEfOc3q0zH21u+6T+SB3YZ8OZ22g2KBldfvb+SM2JnGXjqmrRpjrBHB2P9m9v +7psNO/sIt+gjnH84NUjuN/URqoY2x5W76oPPn/5e3zdIbleduC/K9M0bfsoAzM/3xbJD8rN8MblL +eYfkbVtz/qV1/sqIY2IeDQVVC+jju/mX3kN8gr48NyMTY13NAHl/NEHWaQ2Q92wD5N3fBFkfOUDe +kQ6Q97YTZF3yAHm/PUDeuU/Q7dUDoELH6vLiJgCQ+xIQZA4HALlXAkGvpgvAuHsDQO4DQZA5SgBk +1hTAuMcFQeaWAZD7bgDkDh4EmRcIQO4qUqH0JyHoxecEEPdLIcicVwByDxeA3A2GIPOVAcgdagAy +qxtizDMHIHffAch9fAgyRyCA3FsIIHcpIsj8jiqUzkkEmQcTQO7mBJD7QhFkDlMAuVcVQO56RZD5 +ZwHkTlwAuacXQeYOBpD7jAHkjmUEmfcZQO6iVqH0YyPo1dgNGHeII8i85gBy1zqA3P+OoFcjPWDc +kQ8g9/YjyFwCAXK/QYBu5lxIkHkgAuRuigC5LyNBryrIyqRTJEHmOQmQaReBcRdMgsxPEyBXHAJk +Fp/EmFcoQC4TBMj9SwkyJ1SAXNwHkLuzEmQ+rwCZJo8Yc56tUHrYAuRKOoJebXWBMXteYFz9RpA5 +BgPk3sMAuWaNIPNDBsidlQFyqRlB5vYMkPtGE2QKMYDcy7pBJ1dsgkzXBZA7dQPknt8EmRoLIPch +B8gdzQl61VAB4x7rALlbO0EmfQLIHeQJMi96gFyxBJD74xNkTvsVSp0RQO7+T5DNEQDI9EHA+GQD +gmxGAkCu6gHIxjYQY/MfAHItDkA+k4Igm24BkCtoCLKJGwD57I4KpfCFIJsnApBPJgHI5SoE2bQU +gHzuCkAuMiHIZsEA5FNlAHJpCEE26QYgn5lD0KugAxif4gOQjQMixmQYFcoJRQDZqCNiTDwBkE9f +AsjnOBFkkgeAVpstBZBPqSLIpAoA+eQsgmwGF0AuMADI54IRZBPGAHJZQIXWmHpGkM1PA8iL+QD5 +TDeCbDocQF6CB8gn1hE0f/TD7DuAvHBOkM3jA8gn+wHk5W6CXmYNAnK1mYUAeY2aIJujWKGcyAiQ +lZaJsRmRANmwSWC81PtpkCS9N+liJ8BXJNXerTPxsQGy79+ZuJANOv0kAPmP26G4TTpktxsgftt2 +KB6ADsWjBJA/lB2KxxsgXyg6FEtOh2LxAsiXwQ7FgtqhWJoB8kW+QaftokOx8QDkW1iHYjPsUGyr +APkG3aHY6gHyoKFDEX50KAIZgDwk6lAEVx2KMA0gi/c6E4Fjg04hKEAWy3YmguIOeXQNjIfpHYqA +HyA/OnQoDiEdiuMMQH4w6lAcsToUhzWA/NjXoThAdiiOogD5obZBp+Nxh+KgDZAf2TsUh3+API3Q +oUhIdChSGwBZjqQzkWzpUKRtAPIEUIc8k9SZSEkB5MmtDkWarEGnhBtAnrrrUCQBOxTpRIA8Mdmh +SHEC5MnSDkXatUOevwXGE8EdipRyhyI5DZCnuTsUCfMOReodIE/iF+hcDuhQFBYA8hJFh6LYAZCX +TToUBZgORSkHIC8KdSjKSx2KQhVAXvLqkNfOOuM1OGC8mNehKAs26FRgBMgqlZ2JkidAXjztUJRh +OxQFXYC8NNyhKDJ3KMrVAFnduzNRQO9QlOIB8qJ+h1wd0JmQGQDkgoUGpfIBGJdQdCjEGB0KWQdA +LhDpUEhNOhSiFYBc/tKhENJ0yBU5wLi0p0MhEupQyI0AcuFSh1wBBYxLqRp0EmV1KORdALlQrEMh +OetQiNcAchlch0JQ16GQ5gHkIr8OhVywQyE8BMgljB0KMWSHQlYJkAs0G3SSegLkotEOhfy0QyFk +BcglsR0KcW2HQqYLkOl9OxPC4Q6FBBkgFzN3KGTRHXq4wBogl2p3yCTfgLh0vEEnEXqHQs4OkAvj +OxQS+w6FWB8gl/13yPsHOhONCAB5S0OHojmiQ95lAYy3a3QoGj8A8haSDkUzSoNObS0AeYNMh6LV +pkPRtAOQt/90KBqJOhQtSQB5c1OHok2qQ9FwBZC3bnUomsAAsm6yzkRbWoeiwQ0gmzVZoZxa+WlQ +0wKe3g6gj3fmfVp/p27dWQVk4nhTIeeP0d8560wMb9SP/6NzIh/RBrnu+6m/c45024fBNy1521PF +g9nPfuqbfd/guW863y6yGdh/fALm5/1m2eD5eb6ZwgDr8FSb88dGYG7Kgyyzlc/R9bHP6abNwDxB +X35xbrgm6LW8DIy3gBP02ktemWxKJ8ja2wmyOjVA3nJPkDXvE2Q2AACZnwAxVvIGyC0OCDKzBILM +dgEgN3AgyIrnALmpBEFmT0GQGV0A5JYZBFkZniCz8QDIDUEI2l+tRQBykxKCrKBPkBmnAOQWLASZ +mUuF0haGIJMGEGRWNQC56Q1BZp8DkBvxEGQiA4LMHAggtxkiyAyLCDLrI4BcrkCQ2TEBZL5OxJhB +FEGvTlPAuOyBIDO/AshttAgyQy6CzNoLIBdQEGR2YwSZcRlA5oBGjFmpVSilGASZvRtBZhQHkDnO +EWPWdQCZqIMYM9MjyGz5AHKDP4LMKpAgk4cAdDf7QoLMCBEgt1QkyMwZCTKhCUBuGEmQWU8C5CaW +BJkdJkEmWQHILToJMrNPgNw2lCAzICXIxC8VSlNUgsxelSAzagXIHF+JMRUNQG5CS5DZ2RJkxrgA +ucUuQabHAchtfwkyA2GCXp2IgXFLY4JM2UOQ2SwD5IbNBJn1M0BuIk3Qq0aIGLO1Bsj8sYkxo22A +zLGbGNMaEWQm4hVKO3KCzNicILNIB8hVSwS9urYD4/bvBJmRPEFmSQ+Qy58IenXJB8bt9gky436C +bAQAQKajIsaGEgDk4w0IskEJBO2vIxcAckUWQTYGgiAbKAGQj6YgyIZcAOTaLoJs8AZBNsKjQadh +IATZWBGAXCVGkI06Ieh1ZgowPnyFIBvjQpDJzQDy0TIEvc6oAcaH3RBkY3MIMt0aQD7KhyAbCgSQ +jxciyAYVEWQKOIB8eBJBNoaJIBvoBJCPhiLI1HQA+bgqgmzwFUE2QqtCOYyLoFddHjA+Hoyg1zlj +xNjAMoBuNvqMIBP4EWTj2ADywW4E2Yg4gHzYHEEmFSTIBuAB5KP0CLKhfABtNt6PIFMdEmQjBwHy +4YUE2RhEgFTa/GGgIkGv+kVibMQjQD4skiAbO0mQDbCsUCghibGRmgD5cM5Pgtb1TefbOQGtd63r +9e0Iev3clckLQJBdSoLsRwHIf16CXu8TYuyGA8hvXYLsIQDIHyeC7MEkyB5xgHyxIMiWHYB8ASPI +lkKCbFEFyJdngmyhB8i3DIJs8yHItjGAfEMk6HVnJca2aIBsryfGgoYKZfhBkAUyBFlIBJAHVwRZ +mAaQB3wEWehIkAWhAHk4S5AFxgRZiA2QB+sEWdgPkB8gCLKjCEF2qAHITkfE2DELID+wEWRHP4Ls +EAmQnUaJsWMtQXZABsiP2gTZob1Bp+M/QZZIIMhSEgB5coMgS5MA5AkXgix1Q5AlgQDydBJBlpgi +yFJcAHmyjKDXrBswnr4jyBKBBFlKESDLTRJjSU6APF1KkCVeCbIULkCWCybGksoAeXqaIEt0E2Qp +8wpl8p0gS+MT9FoPAMYLCwS9ViiA8VIHQa81E2Ks+AKQl3EIsoIQQF5aIsiKVARZuQsgq5sRYwU4 +gqyUB5AXBQmy8iJAXqgkyEqeBFnxFCAvwxL0Ws8FxgvDBFmJmSArVlcoy94EWQGdICvFA+RFfYJM +HgCQCw0IMskCQSZ+AMhlFASZIAMgl3YQZCIRgkxuApALVwgyCQxALqYhyGQ5BJnAByCXChFkoiOC +XtVLwLgMiqBXPRUwLswiyCReBJlYrEIpOyNoedGvAeNCOIJMUkeQifMAcpkfQSYYJMikhwC5iJEg +k0MCZLpKYkygSdCr0hMYl4wSZOJTgFzGSpAJYgkyaS1ALtIlyOS+BJlwGCCXIBNkYmaAXBZNkAms +CTKpdoXWEH0TZPJxgFyITpBJ2gkycTxALrMnyAT7ALn0nyBrIiDI2hEA8sYGgu6vLRIEWbMFQN62 +QZA1gADkrSQEra9NKQRZewtA3ihD0GvHDTDeukOQNQERZO1EAHljEkHW4kSQNUtVKLquiLm9tm8B +ZH1gxFhDGUHWmgaQN7kRZDM1AXIz1k+Cqgoo346gj3fnfVqT5zLx9eV+eSphrnLAH6PJc75yzJ9U +8PWjsy5PrZBz72WT51MHlcdFbYyyHVFP4xwlfuqbfd/kqQ/9kGPUPp/8U6Z4fsZvlk2en+ebnZs8 +JxL76BjP7fEmF6vHdW4kFQDrGM8T9OW58ZoY6+AGyHvBCbKucoC8Px0g73Qn6PraMw+Qd98D5H38 +BF1fHQEAcm8BgNylgCDzO6jQGs4JALkHA0Hm5gCQ+0IQ9GowAYw7VQDknhcEmXsGQGbDAYz7eRBk +ziAAuccIQO5WQpD5ngDkDioVSi8Wgl48XQBxbxiCzGUGIPerAcidbwgyDx2A3I0HILP1Icb8gQBy +pyGA3LOIIHM/Ash9lAByRyaCzNupQukSRZD5TQHkzlUAuQcWQeamBZD7cgHkDl8EmVcYQO46BpD7 +lxFkTmgAuacaQO7ORpD5vAHkjnEVSu85gl5N7IBxNzyCzFcPIHfoA8i9/gh6NQ0Ext0HAXIfQ4LM +EREg91YEyF0aCTK/R4DcORIg96AkyCScjUlXTILMXxMgF7p2xh0/CTLvUIBCD9whszMlxnxRAbq7 +bLpD7tVKkLm+AhTy8g65Ey1B5mkLkIvwgTGX3QqlXy9A0asA0KuFMDBmRQxMdHQAZO7IALnPMkDR ++QKQeT8D5C7SAEWDEEDmbA2Qe2QT5H1UHXLf7gadHMAJ8n6zDrkrOUDub06Q9+V1yD3XAXL3doKs +fbEz7icPkDvTE+RNnh1yt3yCzHcfoOiF7ZDPAiDIpgpU6NQz3KGHTTogyGYmAOSN1Q== + + + nfEpDgTZPAiAov+8QzaighibdQFQdOl3yOdvEGSTPAAKNwOAbLoIQD6npEIn0weAbHYKQD6FBaAw +xwDIJsMA5DNmAAoTEYBs7g1APkEHoDBbAcim+gDk84EIurx60nTGJxYBZKOPiHHjngblNCaAbKwT +MW5v1CGfNAWQz6wiyG2gOuRztAC620Qugtwsq0M+JYwgmzcGUJiKdehqM9AIsmlqAIX5WoPWmPBG +kM2KAyhM6jrk8+sIskl4AIWZX4d8Oh9BNucPoDA9BMhmDwLkUwwBCnNIgF7mKgLi8xkBCgdNgGxm +ZIVy+iRA7jMKjM3DBMgGawIT9d5PgfblTcebufmkXZjdv7wbMP6xCXr9/sD4haxQ/iQE2Y8LkN8m +AL3eboTYbQuQPwAA+aNEkD2UAPnjTZAtFAD5kgOQL14E2TIIkC+oAPnSTJAt8hXK7QIg33gIsi0M +IN8MAfJtlSDboAHyrZ4gCxoA8vADIA9kCLKQCCAPrgDyMI2g13gPGA8cK5QhKEGvsSwwHhQDZNE1 +MRamA+QBP0F2dADIDyEA+XGGIDsYAeRHLID8sEaQHfsA8gMkQH4UJcgOtRXK4zFAftAmyI7sAPnh +nyBLIwDkCQmAPLVB0GuOBBhPtgDkaRuCLAEEkGWSgPGUFEGW3ALI02QVyoQbQZa6A8iTgAB5OpEg +S0wC5ClOgixZCpCnXQGy/C0xlggGyFPKAHlymiBLcwPkCXOAPPVOkCXxG3QqBwDkhQWCrEQBkBc7 +CLKyCUBegAHISzkEWVEIIC8vAeSFKoKs5AWQ1c6AsRocMVbMA8jLghXKAiNBr5VKYLzkSZAVTwHy +MixAXtAlyErDAHmRGSAvVxP0WvcGxgvoAHkpniAr6gNk6gBgXGZAkAkWKhTKB2JMQgGQizEAclkH +QSYQAcilJgC5aIUgk78A5EIagEyRQ4xJewBykRBALjciyIRLAJkCihiTUlVoCVEWQC7vIsiEYgC5 +5AwgF68RZDI4gFxQB5BL8wgykR9ALhcEyIWHBJmEESAXQwLkskqCTKBZoZR6EmSiUYBcfgqQC1kJ +MkksQC6uBchlugS96n2BceEwQC5BJsjEzAC5LBogF1gTZFJtgF4l34SYdLxCKUIHyOXsBJkwHiCX +2APkYn2CHq+yf4D0R3/oHwDGGxEIspYGgLw5AiDrsiDG2jUA8sYPgqyFBCBvRqlQtrUQZA0yAHmr +DUDetEOQtf8A5I1EAHlLEkHW3ASQt0kB5A1XBFnrFkDeBEbQazcZMN6WBpA3uBFkczUrlBM6Pwmq +WsB8O4I+3pn3aR2ec8ic6FIOhE/Zlf53NMbzeZp1ec8Gz+WqXNvj8pgj58Ta82ztc6f+Y6d4znP3 +9pwYc5mF4/ZJDZ6f74v9/I/yxeTQGUM85wz1sSmeD5U2dS6/XrYj0mxTPE/Ql1+cm64Jeq0uA+Nt +4AS99pNXJhvTCbIWd4KsTA2Qt90TZA38BJkVAEDmKUCMVbwBcpsDgswwgSCzXgDITRwIsto5QG4s +QZBZVBBkZhcAuW0GQVaFJ8isPAByUxCCzF4EIDcqIcjq+QSZeQpAbsNCkBm6VCitYQgyZQBBZlcD +kBvfEGQWOgC5GQ9BpjEgyAyCAHKrIYLMtIggsz8CyNUKBJklE0Dm7USMmUQR9Oo2BYyrHggyAyyA +3EqLIDPlIsjsvQBy/QRBZjlGkJmXAWQuaMSYnVqFUolBkFm8EWRmcQCZ6xwxZl8HkGk6iDFDPYLM +mg8gN/kjyOwCCTJ1CEBuYUiQmSEC5LaKBJlBI0GmMwHITSMJMvtJgNzIkqD7qyUmQaZYAchtOgky +w0+A3DqUIDMhJci0LxVKY1SCzGKVIDNrBchcX4kxEQ1AbkRLkFnaEmTmuAC5zS5BJscByK1/CTIT +YYJe3YiBcVtjgkzYQ5BZLQPkps0Emf0zQG4kTdCrRIgYs7YGyDyyiTGzbYDMtZsYkxoRZEbiFUpL +coLM3Jwgs0kHyEVLBL06twPjFvAEmZk8QWZLD5Crnwh6dcoHxi33CTLzfoJsDABAJqMixgYTAOQj +DgiyYQkE2dgFgFyQRZCNgiDIhkoA5OMpCLJBFwC5tIsgG75BkI3xaNBpIAhBNloEIBeJEWTjTgh6 +nZsCjA9gIchGuRBkajOAfLwMQa9zaoDxgTcE2egcgky2BpCP8yHIBgMB5COGCLJhRQSZAA4gH6BE +kI1iIsiGOgHk46EIMjEdQD6yiiAbfkWQjdGqUA7kIuhVlgfM1UaEEXR/mTVGjA0tA8jHnxFk+j6C +bCQbQD7cjSAbEweQD5wjyJSCBNkQPIB8nB5BNpgPIB/xR5CJDgmysYMA+QBDgmwUIkA+VJGgV/ki +MTbmESAfGEmQjZ4kyIZYViiEkMTYWE2AfEDnp0GzFE/4+1TEpaexvx1A9rkbc7oAAPmlBMh/lA7F +zwuQ3SfA+A3Xobh1AfKHoEPxOAHkDyZA/oh3KBYLgHzZ6VAsYAD5UgiQL6odiuUZIF/oOxRbBkC+ ++QDk21iHYkMEyHZWYHyL7pDv9cB40NCgU/gBkAcyAHlI1KEIrgDyMK1DEfAB5KEjQB6EdijCWYA8 +MAbIQ+wORbAOkIf9HYoDBEB+FAHIDzUd8tMRMH7M6lAc2ADyox9AfojskJ9GgfFjLUB+QO5QHLUB +8kN7gc7Hf4A8kQCQpyQ6FMkNgDxN0qFIuADkqRuAPAnUoUgnAeSJKYA8xdWhSJYBZFm3zkT6DiBP +BALkKcUOeW4SGE9ydijSpQB54hUgT+F2yHPBwHhSuUORngbIE90Aecq8QafkO0CexgfI6gGdicIC +QFah6EyUOgCymgkwXnzpUJRxAPKCUIeitASQF6kA8nJXh7xuBowX4ADyUl6HoigIkJcXOxSFSoC8 +5AmQF087FGVYgKye25koDAPkJWaAvFjdoFPZGyAvoAPkpfgORVEfIJcHdCiEBgC5ZAEgFz90KGQU +ALkgo0Mh7QDIRSIAudykQyFcAcglMB0KMQ1ALssByAU+HQqpEEAuOgLI1EudCRkUQKan6kwIswBy +iRdALhZr0El2BpDp1zoTQjiAXFIHkIvzOhQyP4BcMAiQSw87tLmIESCXQ3bIdZXAuEATIFN6diYk +owC5+LRDIWMFyAWxALm0tkMh0gXI5b4AuXC4QyFBBsjFzB0KWTRALrAGyKXaDTqJvgFy+XiHQogO +kEvaAXJxfIdCZg+QC/Y7FNJ/gLyJACBvR+hQNDYA5C0SAHmzRYeibQMgbwDpULSSAORNKQB5e0uH +olEGIOu46Uy07gDkTUAAeTtRh6IxCSBvcQLIm6UalF1XwHj7Voe8DwwYbygDyFvTOhRNbgDZWE2A +3Iv106CmAjq9HUAf7877pB7P2xwhl0V5rdvcArPw/jF6PFVB8PGTqhb82KxLZXW8F3Ie9mzyPJxB +Zve9zpZ2nWhLRhk//c2+b/K8Xt4es+vdJn5SXvHHmzw/4zfLLs/P883uyjG9dnnedEd9bIrnc3lT +QvS6LbNez51Up3ieoC/PfdfEWAM3QN4KTpA1lQPk7ekAeaM7QdYyD5A33wPkbfwEmSEAQG4tAJCb +FBBkdgcVSuMEgNyCgSAzcwDIbSEIevWXAMaNKgByywuCzDwDIHPhAMbtPAgyYxCA3GIEIDcrIchs +TwByA5UKpRULQS+WLoC4NQxBZjIDkNvVALSZ8Q1BZqEDkJvxAGSuPsSYPRBAbjQEkFsWEWTmRwC5 +jRJAbshEkFk7VShNoggyuymA3LgKILfAIsjMtAByWy6A3OCLILMKA8hNxwBy+zKCzAgNILdUA8jN +2QgymzeA3DCuQmk9R9Crhx0wboZHkNnqAeQGfQC51R9Br56BwLj5IEBuY0iQGSIC5NaKALlJI0Fm +9wiQG0cC5BaUBL1KISuTppgEmb0mQCZgBMYNPwky61CAXHYIkLmZEmO2qAC5VhAgt2olyExfAXKF +H0BuREuQWdoCZMI8Ysxkt0Jp1wuQy+kIenUQBsaciIFxCRxBZo4MkNssA+TCNYLM+hkgN5EGyPVm +BJmxNUBukU2QycQActvuBp0MwAkycRdAbkoOkNubE2SSLIDcch0gN28n6FVIBYzbyQPkxvQEmf4J +IDfLJ8hs9wFy2RJAPgqAIBsqUKEUGwHkgw4Iur6OTADIRELA+BAHgmwcBEAu7QHIJlQQY6MuAHJB +DkA+foMgG+QBkMtoCLLhIgD5mJIKpfqFIBudApAPYQHINSsE2WAYgHzEDECuNCHIxt4A5AN0AHJ9 +CEE21AcgHw9E0KuqAxgfWASQTT4ixrQYFcphTADZVCdiTEEBkA+aAshHVhFkugeAfIwWQD6QiyDT +KwDkQ8IIsnFjALnKACAfgUaQDVMDyLUBFcoBbwTZqDiAvKIPkI+vI8gG4QHkdXiAfDgfQTbmD6C7 +Vc8JuryOHgTIhxgC5DVvgl7GKgLi4xkB8kI1QTYyskI5fBIgqy8TY+MwAbK5msB4vffToNn5Nu2g +94tu+vpmFYkP3Rn78hWJi1iY06/RGf9ZKxP3R2XsNuuE362Vidu+MvH8dMYfxMrEE90ZXxoqE2tM +ZWKx6oyvepWJ5bMysQ53xhf0wpx2hsrEFtMZ36sqE5teZWL37Ixvw5WJ/bwzHhhUJiKMykSo0hmP +eSoTwVNlIgrrjEVzFYmosDCn8LIzFqZWJMLdynjY3BEPvysTcXxn/EBQmThZVCaOKJ3xs05l4tBU +mTh9dcaPcZWJ82Bl4mDZGT+hFuZ01K1MnJk744fvysQpvjOeDqhM5BUqEwmKzliioyKRMKlMZF46 +4ymcyngqqCKRUuqM56YqE0muwpyyZZ3xtFtlIn9XmUgEdsYzipWJ1GRnPMdZmUiWVsaTrh3x5G1l +IgtcmUgnd8bz0pWJBHdlIlPeGU+5n5lz7r4yUQTojFcTKhNlic54faMyUSipTFRcOuOlm8pEDagy +UUzqjFelKuPVrYp4kawjXmyrTFTtCnMq/3XGyogViXJkZ7yuWZkokFYmKq2d8ZJtZaL2W5koInfG +itEViaJ2ZaI63hkvs1fGy/UVibJ/Z1w/UJjUIXTE9QyVCWFEZUJh0RmXalQmNB+VCfFIZ1yFUpmQ +s1TGZTEdcXlNZUKnU5kQ/HTGlUOVcQVSR1zJVJglJVGVCW1VZ1ykVZlQe1UmZGOdcf1ZZULIVplQ +xHXGpXWVCY1eZULs1xlXDVYm5IeVCR1jZ1wQWZiTsrIzLtGsTGg9KxOi0c64+rQyIWOtTOhhO2O6 +2oqEPrcyIfTtjCuGKxPS48qEhrkzLoaujGmqO+HS7MKcNN6VCbF4Z1x1XpmQr1cmdPCdcUF9ZVyY +X5EQ+HfGOwUqEy0HlfHWhY54C0RlopeiM96UUZno7ijMqU2kM95vUploXKlMdMB0xltpKhM9OZWJ +5p7O7NYlVJloN6pM9C11xhugKhOdVJ2xjqyKRGdXZaJFrDM2l7IxOeDyk5gmpTu9GQ== + + + QB9vbPu0BkkVWNY5U9zWy6JT4GdvkNyUJspZkfups6/Misw2wjn/nBokZ+++fZjT8Dze62yvT6UQ +bz/5zb5vkJyrsd3nSZlAef/xBsnP+82yQfLzfLNTg+R81dcxmJcPP/v6i3/2n+b//u0X86XfZsub +M4BiEG2fcynUQv5YZMl3O3olh1FT+XPXmq08RzIi1L59f8wp4Ig6z4Tu3eMBWI7CzTswO9NVi/z+ +4Vdf3JX03GbLe6rqKcemOSbNbXmTH4UOIM8POlzOSVf/PHf7XIgjATwxxEO5OaX5dJZTsWWOMzLp +fe+jVgSvRtL5j0F+9cVcKh2J9l2Bw/FxbzoIrXInu8kNavlwf074Owu5TGMmNrl9uE2MqjrP8zj3 +zwfWd55f9dh5L8+tEL86rpxOBnPxjj7y/ioPZdLltajPW4jH22VfZHQlx43vXkO5qcfcIhNi6X3m +177on2+HBcpVzKac7n3T5Zo7bZZmNbPfVGmZDzOr0CAyebjpMj1mcTqQTU3zOju9GxVeZ0GWj9p6 +XbR8ffjFF58AfXlA8rNURX4Cipt+J2Vjr8usiXKve849PWHSfB2dLBV59Hvq43fmL+aGvn748y/e +f4nbbCz327zW3CYXzQaeaG9+dtV65h5e51PKI/Ymr5U5Zp2ZTdX0+9wQE9BvhyDhppb8uxwu5xbU +47opt7HLd0xWDd+bfqrycNOyvd50c2lxVcLvdpd5gML1o/qpY9ThBzv30ipT2wnbZjG/XDYFXNfH +XLG5Hle5Lcyp/f15mVVjl2/i4RcnZFOA8ZhnXYWD99tLNYRlooXtcMU4oLlGOnRoQz6u4vwSi85p +l8NSriKr6kerThfbvSC6w+a8PAHZ3CkTdynoOEHza85NN8+LfGaOCPqoAE50P8HyUbI9EPlFzN+V +a+Tt/e65ytll1VK266GZwOfttutMoLVXX10blnyAdpl/HHOB56B3uUk/8XwM8uGq7UvGmVqi5JBy +PDTrfT6K0vJ6fPVzz0OkiHrRxvx+9R6yJ7lv23EUPN0Sx+M72/nE8/uqp6oBH7/zfvEpG/KsUHd5 +Jcl5eXvKtPPyQefviZb27wzQF619koOowDJHkLlpLseW/dC3vqkqs3zQtrAeMoSJVVWhe98p/I/O +f015vSPvLi+Xp540RVnKT83J43akA48df1acOV/PzajVV255s5K/aeHatCvJHvG63d7us4+tcx/N +M6Qbcr/KLWguiJzTlRu6LnMn3Z86JzzfbXiOiO0yL7IMojrDbPgTLk0k9ZTv4mwr8/V1hY463mWR +9dAnvdXcqte3y5Gd3w+X8XWbx+p+k7Pe7TqPpTbF/2bf6uef51tdH1qWVLq4Hn4JH+Y+e5s9VJbk +E3Uut5ed/p/91Rf/5G/+9Ge/+/2ff/Or33/z22+/+t0/fPgz/dHrv3/403/929//xde/+u3vfv31 +rz/8D/Nf/7e8s/70L77+6jf/6qvf/+6b/zrv/OFPfvGzX37/nPzb//O3v/u79//qnx6f6198+JOf +/fq3//7rv/nZL59/M9/qL3//D7/5+m9++C7fUfO/XyhI/etf6+G7/VEevnM4rOu9ffiTf/rhr//d +F3DZj0/2/I758udf/JOf/XL9m3/57a+//Oofvv7dP//n7//+86//9ptvjz85vsT1uzfRP89B9cOE +f/P/L7OHzH98+e+/+JN//dV//uZvv9LbfPjlt1/N+/3nr//phy+/VZT3L+HX/+t/9eVf/fLP55d/ ++ct/88Nf1mX+5fWiKzyYXdSfzVr21/9l/uH4jwkj/9MXfzrs9d9+/V9/P699+fCn/+Pvvv76r779 +9W/nbx3/9tXfff3Lb3/99X+df58f+y9//9vf/cP3/3778Kf6ez/79vfffPWbb776+2++/dv503/x +xReXP3znv/6H+Zf/ef7h/5o/+i+z3n74Vx/+9//j8uHX+gh/8cWB/PoPl/27T3T98LP/OP/85/O/ +/8v8y+Xt/sOrHZvU/LKH5+n31tZzLtXB/Lsq3t8V6JDfzF2tcuhDsbwe1Lk7ZtNUiuH+3X74mE1J +6r/lub6HvLKFXVWq3RW2n5CJFubTbXPQnxPGPNTLrUDzdEv+8th0GOmf5oycvtXE1ydoAhzVfye4 +WuXO/OH0YWY7kw5Baevnfrnfzt/pRChUiEtzYs7XNz/JJ/xMv/puZ/2rb7+de+zXH/72+wf8eZ+n +WgXBOWYpejzsSPXE3CVHWuRmrMkaOk0sUj0qupzz+bOccWfbmGju+/+ZV5nzwKy13//PNtH57DDK +HF3vsslS8uPdtHBi/ouSPMfh4nJ/U6HvdgQSiiwnCn+b4G7Wzsf9oVrt7Hj3WRLf9llzJtSc1X79 +IFut2VN2mUtPxHr7pPe6z64xMeGcA2brWZRAmiBUGdIJJuXKOlHMbA96pVWzPhS56SA14aM8eS7S +Sq4ylP2U97rOEeLdAm6+1nI9vqkGGsx7S2Y1J5Off6avpU83EdrsNvNeRyS+S7u4a0GezeTxuuf9 ++IY3//4nX33zZ3/2L3/zm2/+49/Pgvenf/XtN7/67a+//svZamYNOv7LL2cp/Mv/8NV//PrP/ux/ ++urbX//m69/967nN3hfDfLUJjOcrrqqGTyw4t++xqX14fZN5la+/+dv/8Pv3F5iV8Oe//W0Sv/jN +b3/1f/+Xb/7+6z9Av5zb2ZlffvuNVsv/9T999evfffXtdy93qW/4b76ZL/TV72Z9/dvffP0j4GxC +P4r9xW9/f+wUL+BDkfgPj+VS/94v5qH8+nf/2/d/43l5WUEeH/kbf/3+Nz7p4v67b379+//whyAh +fr9/89XsQn/f/1vf3b5Lixzbh21BmSjZ9h+Oo1fdlvfjlBmZkluBIlWyVuQ1V3L/w9n4quPhriTF +KVtyff6QLZloa9/k9GvZkv1943hPl0wcqvk8D0yXzD/epHle9kyX3HVc/S5dsihzoYE5mC6R8uwq +WV2kS9bnmTilS+BVXtIl10ZYuuT6fbpkvvZjjpn7dkqXTMT3Xbpk02QYncs5XXKZ48Sm/8V0iQTM +8jZ7PD6SLnmBMl3yntZ6T5cMMXf8vma6hG6sH7lBIWGyfX9snT1j7iTdOpkwWe9n5jVhsr6f04+E +iXLfT13N1RMm6/eWujqnzD25Snn/0YTJHJ5U631GwmTdv0+YaEe7zlbz2DJh8od8yfJcFtX8tnO+ +5IdkyFUZvPlJtsiX3J6AvORLbgU55Uv2AnG+ZFPEsn4kXXJsjPN/P5ItuWmy1PN5JEM8XXL/Pl0y +W/YcNZVPsWyJloX3bMlx5aScPWdLnuf7wbMll3JX/fh99//hdMk1Ewv3OO0fa7if9q+nxMLjh8TC +ROrrojECni55HIvcS2JhAnkVCD7hvV7yJRM6SyX+h4TJLj3EtSVM/njf6+ef6XtFxuT2h4zJnK5u +Csz//4zJ/+sZE6tJLdp8l9k1Z1lY1Diyz9p+1b5/2xYZGyvUWiTQfXfj1+GsQLP1vWldWfXTH7Ni +dkn4J1CZz3VVT05BZoU9lIdSoU08s2rpO0FPjeyScnMW8okF5ha7Sbo2L3m7qjFCtWvNA/l/2nu3 +HruS7FrvF/A/7Bc9MhH3y6NI+TzR6APbAuyngzZPQ2pA1W109zmG/73HN2PtzNwrIis3WUmKVRUt +SBDZk2uvS8SMeRljzKYt4ZTGgPFQfvMARDUbZtHK7I5RevKySMlrcfJTHrSdUhyYHHZqsLcUUFX5 +XK/tpsvoCEjyzaG1pPgFk2jw6kR7IREsLEyygiJauUknYcHPLoxMY1s3x7hMTptPS6PCKBCjbOqg +4H4j0EHFoclZzw7GCvG9Pj4lDJlEEFf6JgUGSxkmcCSUixdf7V7SA+u7WK8qHf0ihQh6Lx4Ev/Js +rwAIeArCx6P1B4IdxI7CQCYryYSoITL9DWn2NK5CWTRDOyMc/ziwLtwaVAbDbBuPkiZ3sR/Tmigs +JMas8Uxm4t3A2djhRzN8Mlktm8loXn4lG/GLk7jwPheLuID19IwF4vRebYaP9+yYT+bhFPt56IwK +7XpiwIhffPefVkZaQcE4Kzb81IANAQwOTSWS8ORXi3W6rx5sNKZeEiw14rbJZHqVH9/NL2Ey+rQw +Iq5h3lZANFtxxsUwuorFzbmWbpG2brlQF9OC0G1c7ng/dwUpnkIIDSmCemJNeT07J3XDJBby5hcC +tayTijlNnRxu8pHvC7spdaSsDaB1iRGnwSQx9rL2iiyiAulI1SXxZbSZIMF1wj+jRPOM8FfpJ/MM +BOo2pFUxLGrjyicVQrxXmCiX2gnCdRktGR2f6UFLtZB56CL3/FStFMgUy+t/x0iHwDKh5lg8ZSHO +2u/1VB/e6KkUyysEV+pB9MtslNYVx8L+gzjrzgHE9SzzVoKmdAAnRbclj6bcrS08/0/vFHmRTzfY +h35gus8nSAMbxoIPUG396hyaTRaOaTaaHFOjPglbh8yEWunsUBrlBWYyRMrFhHQLx5TJ0hg766Be +QCFaOKakdMSGX+qPIAcXRkkLRqllNZgsnbzpjieLxYNPNpNjL2NSoQ47pU6xL04HfRUFbzXS33Vh +RLLTKdOVvlf49Iwes8mB82lFqZRUjzXmUlqdefiLDlFAsWzvfTo5ycqA/ejCjUfKZXX+KjzwcOnB +IbvS5jN8YTB5vIXR4kQgEiFlqPKitaYRm1DyhrerNJZUk/J0sipVt1lEPCWl9FgUWzGL8o7t8vE4 +zPSeQU7rdJWXL7kvD7MaCBQZCKIN3lteOP15mU5Hx2yyOKfmPbE4p2YjHYrQoPQnZyk3/kXPm/iz +UgZDx5yP1sWjnz/Ix3vez12IQf9AHVG5UgV90sPqMEtEigHsmQlS+NcPs3J2+/6SGdqnXKiiN0Bd +3xvnyBmIt1Euq0xBkS/WPi5GVw1ZoXeDY0b1S4nGOMsCJG0YomzJKq8feMlKLylshjt+iBST8UTa +KFHL2VxpRZbDBvVoP65Osm/0SB/e5pEoTlfKaFWBEFutMkYwU8RDCaL0V86xYDzOBgI8G4F+Wt0/ +LYxqsqlplRIkczsXmZDeIozfaOF/I5+yStHjf/LC5PPiXJ2MegJuDrITUgzct+luZpPFybEwMrK8 +4kzeHgCt+W56VHysTxoIPa6Qttunmkw+v5vfznyd+UNMd/P6t/p8zQimu2pwnuXkO5SUGu2zym+3 +qLUCQrnYBJez0exsGkB+YJclgrmLK5PFu56MKgojiTyjMMcwXOa7qcT+iQ+q49bV1QqaTEa6jY6D +dxSeCfbn60z5wHw3k8kqG5yNzm9nvpvpHd/xrT7f49CRxqH07KkKtLbMTpS3M+CMqZcOZv9rDl3r +7tb7MfuPPzP5qkdF2PJmdA0oeMm7FU/DXys1QdTn1bQxszvAFdRRqzWftesePXp5gMvoeakdFIxu +kC5y6ZQWwj0/VbMzDGVjpLdNx5JjZ0QZtENO1tmnf7un+vBGT6Un0CdsOptdRUHmIg== + + + Z8AATvqLcnHM4Xnu1ecl5OlnoDlkNJBukG86MKEaRy7luDLyBURGYZ5tY7jo5f0Q1Sn2VwQ4MmkP +tDI644wTc5gLjEoFkR4CsIIQIsuqw44mQ5DTHKfB2YjcPj94Q93Kv3sKYxFOnDZppB2XgM4N8Q36 +fjoEowXUika7qSmM9Ts/+cni8zttbsi5ToEXndXFVZStMBGboZxAmePiVqyIS4SuKKywjxePDYmn +GcEACSYk0haPnRO9TOgCxHXQZqZ3rCNcJw68Wwg6sPHmL/X6F7/LacBLVjpci43IDGld0ogUPLjn +YLza16LAGs4hk/5NkFMjhrQavmJtbRLIZ42sjBF4PDXCOcEq4s1Z1yvAl2vaNpz++eo0KD5qzaA0 +18uFuE3BlqOJTmvrjp9SHKjPSfWT8vZo4dIcjYDCM12QRSD4zZ7qw1s9lQF10BFh0Hi0dVRp+Ct7 +Y0b5gi7yVM44L6dAlbgGhSuZFDjJgdCoVILTQXQFwqzZSPEq0lDE1mC29WJt1rjzjI6FqTn6vsqY +uwcJYSouYMvgs3SAbwNvBmpNL8hHAE40QEvSHla0hhoZsze5TCVn7mxHY1fJnRQLjBlKCJ1YX1S7 +yentZDru2tXF2GgwLhKzr9fVjEJTlK8OYxY/qcidCyvhzHRUV7FtNqVBOmy6rNG4JhNlku1BH5iJ +2yCDAQJPRsoku2XOFRZ3tpGQcwDM+De5TaUNMV9jbUfOEIkNFTJeuh49Gz4t6t/h6wuSZcXTZkZc +iH52z4g1wvzUa+0cnfTddAleGEjAZr4geYPgA2yTSe5sHGWOERUCbZR56UwmREoR9QxHm57Ky+o6 +vivX4RMorbE67nw3gNOUB0W0D031YvFUnNIeViLT5tPy7VDlVloLbUtRm199CIWgD2mMCu3IMiw/ +qOchUD+oNgvULz+obs9k1cBGKU5cfVCq3EYvTsVF63dOaxDsgdUvyfCNZDutZboTkNwrwo+81rrY +E5iAwYPp7Yy0Ne0sgxY0gDb67B1a/mKDEmN5OHbNBleuNvroBhNxa3/Z+MvJXdzhdh4zmvmDnG+c +RFX/XJFLsUGR5GtySF15ODJzWnZ1JKrIigE788bgyzbQtiPlY6y7eT3fGowkFSBXiTbesE8myu6o +2vAqDl3I6T4WzuD8PHJOs1s5G316V2jLKmliBY3uss42YCysJe1/qrr6TB26vXyqoVdBlWlPcsBH +11cPPZl8to6UPLuREz0rbnGdzFJR+pEIwGkunm9msWfm577jY9/Hin2gsBOglqHZ90J0Q6tGLyZW +6omvN2zSOQ4w50Wgx+1SltFjylNR0vEwyCIRfSucVz0iIwPxkZeHRJSnHxANFvAY3bA3QVux8dEG +ATvOYOaEvMzrP4UooDwMyF+rCFp0g0gNKi1UJNsiuvlmT/XhrZ6qoVBB0IQOivZ2QzksgD90QB/9 +KSWqehjFzzkzTbSsEvifFkY0nHlNiE56w1WhuSM33UFQeryhaVxwB3i55FabZzL5TMVa6xZurLYP +4cpkg/JKsmRUNxCtwXC+mdlk1RGZjdA00+FSyOkQ6sGE/iTkTjmkMXTYadloTwTUm72ZICUnv0Lj +gi4P+EX+mAdXUvsUIT1lPKjtAF5bGX0yo8BHJui19vz4MVMSgapbLkAjO4JYFSGTcL3jXJhJLD/Q +Fxbzg082XmuGP8t5Bh1Y7VJp2KD/JlecK10yHQEPzuB4EaR6WX7Mk8nnIVACota6RiGtrlORaUbn +A5E4I1ee72Y2WdWYZqPzu8FEX5LWu6dPu3jBZqK0vRlilhB28TVtN3jUhZtJ0yy/phnZ9GbO9rZY +OYudd15/d2zOu7JXbkXvRql8UI4dl/5dwQxrVPGeXhB+5BX33s71ftoeqK0ZDDWi+yvv1Jl/zhxj +JFrzpaCTrffvTMTZsMWc3Z13zhOVfnh303U1ZLMOQWWHcnd653IsSunA3b36S9bCUEiBsGIfNUeF +fA/oGcfKZVbO/Vs904e3eab3IDggJzkOYiRJatFGNSKLMt3mnysd/Osj2+5fvyXv7p+/nnX3z1/G +uTuobX94x8EJiVX7CiSCXoP2jaEvybjRA0z2Nw65WoDBHfi1Q4sLAWQwBWhKXDkOf4RK9xD6fbQ7 +MMeOGjhiwjE8sbP0XSOBbDQS3dnoSluL2bHHqiUqCDcFi6ryM4acHKNusw9yuqcIXT2ilnlhYhUA +TgyyTvK7sDDKAJqN1IbnNXDQ+W5mk+mpAKufjQ7qGgu6Znr9090c/LcckHYpLc8PNVkMAPnNu5ls +5hc83codH4q98p9Pmfr9MaaOL3AXY8o/rZb8xYSp9U+8DWHqGUdq+4Tfkk94gVpbs8G/UePtvqaI +rpzORmfBMklc7LClYFQ9OMqJ9GJA7i/6AKbCnGl9dopO8aIM5KGiFKK3RFZ4QS6pOyYDKAY2cLFi +TL2hTNUm0C8ydDwwS52EjckarIWiCCKjsMAzd5OPIlmE2lwpmlFqUGDpEEgLtVFbDnf9FjSIh96R +LArQeECheaVqoPmVeFGYUejRUPVHOBKMKRplNP4QalDiaT28t3quD2/0XCZ6nBUAekJf+ofQElql +ilRbivWHItfuk+JXeVLcUGu37NiWHduyY1t2bMuObdmxLTu2Zcc2ifZtSLT3S3HF+6W4ZoUtC+T+ +sKm6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrup +upuqu6m6m6q7qbqbqrupupuqu6m6m6q7qbqbqrupupuqu6m6m6or3/7FtNx8peUGYyA98nL/67// +9S9/+opRmPbvvnoK5iMx9zRv8jUabayBuiP7078wi/JstJhFCaY+wKNi2mF6oro9m0VZH/Li7z+D +UA+6vvINet1j2NjJyNqQAcoEKWyOi1uYTRbzGmejaQDl+WZuR0fGeDzI9NcDKX7zEiab+U3OUydf +/SA/wtTJcufUycg/YqJZaVSjX5o6qV2rF6V9rBy8j/GMDWZBUj6e4r1TJ4n7lMyQ+dIHKjqgiA8S +sBAwn284dTIo+VWGBbFCn3aaOhmOsZO//Ll0e/KUyjKsNqfT/3bsZE4/FDPO//6ocV8ydlJr74sZ +cesrvwUj7n6odvrKqcmrycgnHt4fVly81WzBMxmvLGxuyXjFL01uBls+jij8mcGWhim6HWzpT4Mt ++zNC3hhsmW/5eKmU1+da9tRfnWtZlvMmb/h49Y65lvHVuZbt1bmW5TTX0s7yEx8vnOZaJn/m49XX +51rm88jKOtPxFjYTG88/sfFemmqZXlhVryzOF/h47TRdsOaJj9fCbHMz1dLms/78VMtjbT0bapn7 +mY5XjUh3M9QynOh4sMfOQy3TmY53pdE9TbW8rq5ndLx5ZGU+0/HiCybP6HjzwMqrAMEzOl5eGN3S +8Vp8ouO9MNUynada+vD6WEtTTHiBjneMtSQTf4GO9/JcSz8viNNYy7q2+PmF9xum46Uzca2e2WR+ +YpPFibg2jX+MZzreXeMf17/16ljLuiDkfbvn+oqxlsvfOjHyyh5r+eMx8qzFRXkyayE5JEHwrJHF +B2Dnerj/ZI03QoTO0jAjaGr6imAYtQRk9OkdH1jnp7w/R6IZEdWAZ6mhjDABNQ95N6BT2Q83TqsX +OlZrdh26MGD3dTjnx6voxKPW+xSyAHDzwHwejViQ+nS1RBA2iWZ0LnLgvti/5aRUEOY5ZwICLjKp +8YFuWo6UhcyEzw7xOjUYG/ZT9JayuWPGIpfR1NZZ70iTxy0ngk+9f0Mrm0mrD4F4rl0fXBf2wHDL +493QztM+UdAQ7beILZPBM93T/YD1y9l2UDEjhZ+KaMAxPJrQtdI21HEFjqtTpXCKQrjDWg6TZkPt +2/HkcviUI7T6tS0ejfRpdPrqpNQJqtukx5cfOBhJksPVKCpGCi5cb5quskLaNhZPOboQmcb+8Q4v +VF0dMnD+8dHPJp/f6VPQs5R/y/Wl6+g5FR2ksQSXdwOEKVjjIFzfzvmpPgJAiLQFn70fD+8iOk7n +49F7JfSDBnn9pB51HQUoBAIsQ/gb2mgAaZ9MKInrURUq2P2sTALleBO4Y50CiJiNFF00wmb6KXYd +rTjInOHpuXSoczY8fnU9VUgu3iwwHhTC4PFTH9/hkkMKz1ZPJ1PVMq3XtfwJwE32dMMf3zO4Dp0c +ekHHXq/KeOLN/fRgTkTfuY4FL5PqKKc8vkBMqi7zuCc+vqv69Ug6oAyg0gU1AkMlAPY0n9ulUp+i +gxCvu68T22uXPPqU/8nikWOswE9LLsaDiA8MmXcEnvrQ7aJgTM939Rfj9QSQH+A1xvf8v95pY+uC +6fkiHHRX8HH07lkZWoY16FeejLoibuWCFX0WvhhGWityCNqESQdNGjYoIACv0C92+oj2vgA70Gkz +E11AR4616mO46EMQgZfy9LWqcQGfPI9Ws/yeDuDmn333BvhXPmC4ZlYzWKLI0fx8icUM57mMB+tp +Xqo6KLMnSR27a2Uyr+aFUSLdlTscX+yyuBsgzQmsMg0nfmp+Km0/PU4wTzNWs5YYbbfnvjAamSs+ +XucTa0PpUHi+kRNtIId8ydilhSbazUlhJuGZQ1DmqrSW2OXRZ+inCl1o3NG4n0wLVCfvs+sAVVCY +zaPaRv7EcQKTSw79yYFDeOlKAuK4aUoM54fPtw+v5MwryXl2chkLDGxhPVbqqJ0TL7bHkws8L222 +wyZdDLN8s+J5GejRpH7dyDq5tCif3XDqhCIEI4+HJGsOVCPEATfOdSUdka17vY5euU7bDlPwOPrB +HrZbE71BJZbVPUYZOoEoaHKz9lMweHHNsdqaG/GKcrEMC+warwB/Mhkxf+zSaogQ1CWu5wBT4Dsd +rWivfZjkB6pH7qmoUUZe6tM1oElUhJWcl/Dow+CBRxPPiMejg4eiRVrj8X4+mRH5OZt3XElGiVYA +KypdjeTHtFj7OG8PIBXRXRvLeeAC4tORXA2QZSzCx08KP7A8nbcrE0A11I51jfB409N1IlFNzGks +n+XdKFLUQr16qOtTUYt6clDsgYqiQb0+Olhk2qKPB8Eng8+B58mcH+BO32foE4VizPHlgeFRTs1d +5wM+HsgHASltV3O7WMBCjabdVOxrUYJi8zUWgvHbozwLYL7rQo04Qpgt4fEENEWIpgPocTUbiB0M +4TMjQ305ioPykTQqWQj6ONTw0QSoJnugRQYV9zFORTWAOEf/Ig9yBOcQiLdsnWxMdHg4SHKmVajb +bjgo6r6PQVahZ06T4rp6PnO2P9sWZpQtcrUKl71nsCtaqM92Oxzr7suTiQ6uAqvkydEZP/Z5KPuR +CIF4Mz4dyg2O0PN6oMIIuEaFAuDVi8kVN2PnX0P0ho9o1xVWBjcr0qB/DCM6N0jR9Omp4oNlGI9n +IN5Hn6IA6rkueYO7Px3baTDF9Ocnr8HysWbvOP6TQUFJaJ4SITk66DDPj1szInd8XA== + + + GkB5cYf+mp1AmNItX0OfcTedluHT3VDJ1eJxj+5AjrhB7o9Pb9ly9acYvVriIYde7S+uPiMq7rOS +0fWm5daonz45cDZys4Lr1fFW96rPmEw+m3u69YaL62RER1x9civUycKNB9Pd6KWzsQ/3JD/DQZuu +nvmjue9GJe9xl3KW5aQU/bowPi0SVzKfrG/MW72+H2PpZfeUTer38SJPP7cwcZbUPK3CO3Lke2po +V8HuWWw0KLjJkRWr5CU3+2+MXAwZnCMbETy93E4bEW2Tkq3cmk+H7P8JXl7rpkPjAOro8/pa2rEK +BnQtkIo0GRcXoyf6Vjf24d4bMxIPNd5wPQlW9/WWAuo/j9T4UvH0gdP4Qt30M0pjy6dvqeQtn/4r +7vz/JkRxt3z6b9QnbPn0LZ++5dP3SbHl07d8+pZP3/LpWz59y6f/IHitLZ++5dM3WOsXyqfnr5ZP +/5dBEtuQsA0J25CwDQnbkLANCduQsA0J25CwDQnbkLANCduQsA0J25CwDQn7oSFhy+KU1W++GiKG +Dm57/N9nGLH/TV/1r1+h5mP/7rur+ZyAAai20IBLWeeaafOvEBw0ihAxpcm2BnAodlfYqY1YTPR1 +BeA4mawBHCejFYDj9mYW+I3zMy3xGzpvlYNZCUDRVl/iNzgDlLPor0KJS/zGrcUav3Frs8BvnG/l +js/0Q2r8HMOAnvRp0Gl2DOPzaLVG2m1I/BAPKeVOxejOjxI/KOUqeGhoPpgUTnHNPEJDGvP1nzKF +n86v6CQyNaGSGE7FaA5FBjrpvkrhZ/VTHNQdJQWHfLpJa1PbV7io1F3B/RAoe4un0s1lCsQ6FuV2 +aiLl1PkSU1XU4JCr+5GgG78rfZ/8tCd/zciN+1sK5fvK/JT+1JkPipqZdzaDRtrC6GXUyDOTG52f +R5iAN2XYiLzhGTiS8xNwJDnFfgzOutX5ce0JOVL0r6i1vYgc0Z0VAHsm2fYicoQsVzu9hxeRI2Rl +Jmr8InLkyWJCjrxwlWfIkbiyWCNHdMKAQo8/hxwxYUfUZ19GjjB5hAL/y8iR1plWUNHdfBk58szo +jBwZCJ+BHAkMXnT1DBwJL6yrV9bnC9CRRwxA4NDVjU7IEVOduTW50fkZeIUBHHEIr+d4wo0A/7/i +RpgJ06v38YQbYQE+4UboprGifgY34gLy3bWdcSNPsBHLAZDqm2Aj5QnLweyp4I4gag0buTF5BhsJ +C5Ofg408Gr0MG9FGU2oc88uwkWCpKCndBBvJj7ARR5OzjtE0a9wICsdIVIYTbiS1K26EAoseI0yw +Ee+n9XCS+SlLg59ddL9n0AjDDU6YBz/BK/ITvKLaxgvpLPJT9YluxHCq7/6u33ou8sPyfgYbaQHG +Tvoa2MhXP9eHN3quF0V+KIMEVzdu5D8fN/IYdY2R3fIv9I37ERzRV652IackyrQU0WFlYgNNYFMZ +dwjCJ4TNqGKbHjfYCvkz6tjoI15sPmtl9BkJsLPJQdVU+lFFz4DV6WbqdZsYOOMRwsKEpKkBaHRd +WZIv1iw4GyXyos6VAgdftPs5GzEYBFF0Oi5UYi8IoeugtA6rQ5QxugeEy5USBwapHeDQTMhHxw5I +8mTy+Z0eIsmh64pFp7BLC6OmYw4ACyN7qVAvbmY2mR7q47vZaHo9nxZGvGZtbiW46N4pbaQ9nhmE +qFtM12+l1RXABrRIVceAJxb/EFaX45tnRjwlhlm3MQJWZw85L8cUyra2eBLTYZgWE+MYJMQ/6qga +9zGv2IETioj1g0INF+o8uTPAro5hK8ynBpWQydl1XreFyWJhzEaLhTEbUabVSU0pheCh0sNWXE1b +XqvXFBUVITGlphCZ6ScXC2My+WzjSpmrR9nYjSh+uk6EjMFUaI/I4upmZpPFwpiNFgtjNuI1wxwp +kS4EU2kUzDAGyaM16Uy90jHfh2E+LJhcLnd4jLsCC+Iz0DPMANfKpNJL+9XgPYVNQXmD5it5iXw2 +U35mvxZJvBmxTQoVFCbJkYBD8VbtcqHTvUaeW/EX63TMwnNMbgcFo9gvGnSl2qz1wlBwgsf+kOy4 +1bqm1sWh3wiLaysWJPtwUXSnjUYelxgIH+/5IbAUiihx5GBTOPOjNmeLnbF7cujRzvzv8kwf3uaZ +tEvIrvU3gYlwYfR7tbwK44Br6DeV+JfS/z8c2b4rAzJgOPxgnUhFRfISyi2Y/KbYO3Cil8HZWxhV +cCSsxObJ0usBddE/CoxiV7C8MDEkkBKkxqR2IPgf3zG+ODkEW40+WBZGnxZGbBfPqArtModEe6cn +VRADTswJt/kbLOsu508d8CBnnB79bIIz4TRN+qQ9tVEen67D7HVteDoxpEyLu5lNFo9ujb7kaNh7 +y+VWjz4bTe/ZmvrVaBRuzAOZvtYdX/0uZ8KQHsT0lUOSx7aVM2EkIA1p3TlTmBYTOG43nmLX08ZL +jH9J1htPpdLykjNOD0F7R1lbz1zdWpVJXyUGm5xpksWeMm7MYBDoWA5/Uqn2NnIxepbae5T+lZ3K +02bGXNzzW0g/A35R2sisXwaNKduj2etovetjzA7lGz7Xhzd6rsDBlOkFKoevZBWk5hSxOhcO/m6n +0pl5p4AeEJ0BshL+qzF+WcFztApitiRf5zhgr7gw+rQyCowGgWpZKGCYzfnH7jCZf+qeoxOCKQCW +2K1kuTw6DbmgA9qDGKmLCcs3qyKeThklgRcgpzTXGZrE+SQ/8MC8CqY9MmqLeXLgf7T0qHmCaK1j +8Fah1kb7QwfQsdgV7xLtdTjDSYtCsYjWIgloVPBx128hVf2gQKTGykgdTk/9C65L2UleKE+L/Rs+ +1oc3eqwI4pzSm2I+AgGOp06mBaQlQmK7b60rGIcJFm2GZvID/5Mo9VHcIqbjAGXGRVMAT8ttjOw8 +G31aGOXKsAwrGWYmGIAWnX7uLqPFz90zX0lxM4MxKO5Rj10t+Ajij9KevhKltldjxX5ygxGiFdDn +yEgoo96xh5kHxZzZAtz5mGlVQFEH/UiFeBdcUEBeGcIVGG85VjxTP4rFWoYyyVQk8WXyIEoN7/st +ndQBUL4nrI7MR9PZlhgbY2k+1fc5Xvx2z/XhjZ5LLpRiN01phYiW9ius1MfT8lcs4MJXL3nY8Azs +dD5RsarLJT8ZrZZ8somCZKBWYW3L1XyX0eLn7lny9UGRXqV+rTfbX1/xRHc/v+LL+eC3Csfzr2Wo +nJuvhepB4/zuTmcUuFuCXEoekdqTVgLTlGzBewWJMDRdD4yMQOPBMm1muOIL7/kp8lrCSiWtCjdJ +LsEV8SbcaHsvEqRv91gf3uixAphKJvJl18dy79oyCgMaaN9Wv3q5V5ouSYGJiW60tlzuk9FquTM5 +KDE6lbJ0HXyA2XnfY7T4uXuWe1YiCnS2j0nh38fDrxdGhVMk/9r069TI8ISN9mtCjZ+Eayz4SBMR +uohjYusFigM9WVumRNl3LXg5PAClTdkPCA6rCPQH8O3KiVbh+zd8qg9v9FQBIAsgaLm7SGWVVJUE +VEmCK/cG7/PSstId8HwbOljicrlPRqvlXilKGmGOslKK65V8j9Hi5+5b7sk8nHIk3/2y+PW9AhrI +HKRwDBnTRahlMpsaCYEYUkpHukqzhAERiTli+EG9CwaYZu4g3BvPGF1IC64XG/jwnjn2gHarwcjK +G8Yzrz/Whzd6rEAJz1HA4CPpHxSDcUeQGuXeTDWQFSu1dcouI0yvRfRO6ZWile9G72zLcHo2WgTm +88/dZfSV0buyIKbtJJgtenVvsNiJPG9XhY93ecGisCrB4mIKNFxCnTYPBLzyTQ3w3RHLwIqgzOZN +MonauJ4hKJFuKQAPuSuWkW9w0IDQhanm2eGVQJkAsVSmtf4Nn+rDGz0VlZnG7XXKQH6M+YqAQgq4 +pnBv6L5YgHPovljKcyw9Gy2i8vnn7jL6ytAd+nXpCHNCaLojlnk9dk/nLkDOp89lAKTnn6v0EY0Z +DIVZ5SkZXMX7B5hWQFh0KB7NDZp7HdCxRz70AuniARSATa0v9/2WlUPgKMnjomJmwbvehYIbBcrV +zeWZb/lYH97osYI2LUFDMwYbuBpYQsgm5QEh/+oVv4je58W8CKcXx8AcmC+c9z1GXxm9661S5Wxo +3r1JNPP1rhBAtw5+YDU1MKwtBFD4+uLFN3LIozxDTJjBYHqnr5wNt6KQ1zVaGPdlkLCVodwCsZID +NBKX3GGIVEuAPtQ3dPGvP9eHN3qu6OBZau0DLNNaMPahZyBjo0v8C3z8IoCfF/Miol5sizk2Xyzm +e4y+MoDXiduMKhwVDd1Tn/l2Sz4b8DPSQOstMHotBFJIQmz9TW2Hj4/ZBgzD9kQKGhcGqtPQGS3d +G9TQ0DQVMsWAhMN6wEBvJhv5KrxhVHPHc314o+eKQBhCcgUkZ6zhghRDKPRN9aeQvsTJF2CgBU60 +CSul8KA9BGQmdsBTPxnZWbm0/pvCBlvYfFrYQNCsTmFI4b16q5lqR9LvA7KehwnUVV5ZMYQycgiA +tBQDApFfmHxExIT+EB8n92Cyi2cj5b309GycaEB1bGEz6MextAZFOS9ueLY4P/ZHMvXIwqHKhpb5 +8t0sjCIiPZ2Gl1xdNvUItBGArMPlWZosnvtkApN3foMnoyvJ2wOS6TX11ZUW6+IOk/n93OGZEjuk +JPwOo+6Xh7GPDzVSYVLk35k2/JpnOodp4JGROIEwLKec6oDGIebrEXwYOKVgpVydO5lqv82vT/Ci +gpZM0WY96mgIljR9x2bF14tCM60U7TlkFpB1fP2XcoeNK5+e8ePmO1IfZVolLIWO0eyVvtUzfXiT +Z4qBJVyTli/BqjeV3kqpGgp7+nmP9JVTEPwziqt/jeL6pWMQBsH1rjEIewLCVjvfExB+O9zI35Cu +9Z6A8Bv1CXsCwp6AsCcg7JNiT0DYExD2BIQ9AWFPQNgTEH4tZPY9AWFPQPh9MtnvlyuqXz0B4ZEr +bw2ezZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998 ++c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X33z5zZfffPnNl998+c2X/yH48t9gRLSS +P4vOg/3pkT3/v/6P//jHn3/603//8x+/Ykr00z/+zqOi2wNMg2oooBZeGBV9NppHRYcHcJ50JnPy +qznQIHAyQEojEdjssuWoaBg4nay6HCyok5HWmHxC01kEobAsRkXPFou5yrPRalT07c0sRkWfnmk5 +Kvr0ahajos+vdzEq+tXP9J8wKrqdR0Xne0dFKxCUI4eLY1Di9aho+l9AlscEVhuqrDMi6GRo94+K +VnwDWKby0MlGRecxNDRBB7hrVHS9b1R0JBeWB+0eMP+Lo6J/8VMpcdeiUILprFrV96joH4bk+qWj +ot1z7/HFHNf4A8yKbt9jVrTS01pB29GXeGlWtI9ZOZcOiR7qwmiwAal1ddicL5koQA== + + + ol9HLvH4U+dZ0dVAy0qIZLWaFQ23vcHeyUxSbvWJY/tsVrRX3qj/VsdPZybw7azo6o1im7qrDcap +zg8D3y9GRctjMmW0MpV5PePZwvpEjhcXM54/H3jjXpJCfD1FXl+lkjw4OqQMtV3Oku4V7wPDP6wn +RWt7KNIO4AUg3S4nRet9KTDkb3x9YVI0eepgq5A7vTAp+hWjwbD1GckGjtTinxi2x6ToaAxbBxRH +r7zzr9ajol9Zns85ttGQoM70CdajoqHNGem30R+aR0X74sEm9UI2lOdR0QT2Be0kRRi1PfFrj0nR +FmRxUOlO9KYh54Uneu0xKNo0Pvg94o0E8/WJXnszKFrX5Owi/rjSWc+TokFZw+702apw6zHQZO16 +ZrKTl0ZJQzKljxhXI6AHuVYviaaaZ1UujCyGaglucIX8/USuvZkTXSlm6aAlvX9xTrTBcMhxWn4i +1x5zoiHT6m60AMC2krOc5kTD0R2kdTksvSgI/LdzoinIH9R3rRaa9b3M62VQZ/locAbrPAb61RX3 +u6bW+okZGkcxgsdwcFOC+7k50VT5Y6imvgMH1ejXege6/l0/Nai1jV3IEeAPbm3UbzXdsjsgAN/r +sT68zWNRZS8FDIGSioqf2FOifzRuLZRXfUnnUBBolE3dkUabDFJUHAMvSgsi6+yAHqMz2IEBmY0U +gnS9rIJqQNVixURnUPGQ54Kt2CQHX/TPE3QpWHEycYgYyKtBAUwWVyWt/Gp/EQCBH6SBUKBdogjU ++FxUqfXQgScvg/hj8hKe/yiMyiOCK6RPRCZwcaCLO09RqiPj8fkdDSQKr54PX5yxg7KRDzLIdKSH +5L6L/hNSrK7acyv07igKOTJEFy5VQRNvICIb0duwaBGCkcfHw/2r1YhBIAIiTMdxN7y7phdkEdyn +d/otxxtGSoUi3TDSUWEMVV6sksQH3krR8ab0wt4NgLWg2DB12865UTCgl6lVbwbAizj29Us62ziL +9aW8vgfIIx1lfbw93bBCBxeNeZtgXBpPSU8REvcLlxndjULzRlkNNZHGvwfl0MyRAOHUe4HTpfVk ++h0Q4RQryJ156zaNNeFYNhzPup0ip0B3Lhbq0mNNFHj9Cm1g2elvanrQ+3esc/mnUWpXblw5Y/Wx +Ea36/E7RTUO6ploANG5Zbw/ZKOq+cAZp+xGpU8lRlpwHs0pREucxQO2MCfJWFdEScCG8GzlMrefo +iyx6pSKPH8sgzrsjWMZI8aqu0pGjCkYGm41MMSsrWOM7eOsheJapnrPwKkcU1yCwKazC8SC2MYya +nohauuIKoyY7sOE90JAsqbxgBEu15diADnM45vjATqT1hhrKsWsqpfRMGUIm0I4UXrFQ9d1s71HX +4UGa/m6EcjpCPOTprNDSAjXdNAhVSLPN5O70WoNiZjqlbnwwbWH9l+xraMTGmEWGJ7GMTU4C5rmS +jsL2DEMYTi8VbD+YFF/T+BQK/TknUcghdiKaCmwGJUJxbD3dJq5d8WdE1jTB5mxD1Ij922Hzyjdm +Xq8CPOMR9ocIllrJk/ygvkIH5a+NpkON96mjNWKiFL1SW8zGJdXXrgOO3lB+wRebYFBDYSmZiX5B +h4hWtWJe4yTLSP91pzNoLbT3PT2Q5iFe2pBMMk5yN+0XjlItwmRG3LEepiCGA2dR8ZsObHlOPQbo +pl7MM3RCzzBoy6B5tL0hV1XccdcLpiTfEi7lkY4dE7p5XnGr+T+PVE5Gj60A9fMUXYF+OzdgJkZp +1EFPhBqdYT8abXjtRr2xeqVqJvlC7VYnJzx+KPBDify11+RHmUz/VBdJbGJecSSabvD3jLj0no+n +T0wP1eFbL6P7A6iqaa3bIvfsF4XXLHxFsvyUPBM1xWYgomiHg67DLVJK1bPaTqD97RCXLXY38vus +Dz4nClhmQnSs74n6Xx6bTt9PQbZ2utYpn5PraElEO4cINqD/y7fiBamLWnt9MuJBrSxAgqcjAm/R +aMHL347XSsWSElLBVcI9HrIBkxFbRO7XU6WoKDGZUXbkG7bNrfNm20bRj9Yzrm5tFAgdrDRgTRrU +BRRryCsVMgt714ETnj1N9UTXqYWkGNyAAocUD5pgomTZKtBRPgdafslyWOh8/eiCotdLcqolXylb +ynXSvGSt+iO2AHsQ5ZMVkl3uiFHuzGDQiNLZqPtVwmoxVHXG1E8QHFyUQ1AsHvEq2kodJuEUQul0 +1C+ydAOno63cjCiTsr3s2J6OEjBSSFbYp7Cdda5kAgb5JS2zi16UFWpBS6DdOc40T0fVxCXknpF4 +1Fp84Mzr/KBPCjaCRSRZQbazqsOrv/Re/yeaOkKhbgPFkqwXuUwtJo4eAvHv9Ewf3uaZOOy1pBXV +ewSAaFhoyVW033Sa5PgsteBqOHxPtt05h/ngQHfM59bUrWwYdPhQa9EZb8FDIWEGHwEUHcU06N0B +7EygaZxKHwBh8M86BKjCWt/bIvIKUSEDlTCQUjB5kDrE+j7dc0d34W0goKeko1l7uECUXaxlKjwK +eBSKttyMZ/PKYq7nL6/P2h50GmRidt6whV8PnE5OB408t96/QlfavZQtUe82/IayP2qN2vkK3Mdi +ztT5Ct0U6z8jlvBgeixoMsgz3vFL7xUqOvs0ERkMnA6mDyQ8vhlffl7N3+qhPrzRQynAfyisMmNe +jSNUhyM1X1D3csE3ne2vEn7/2sa1rbdf1L3+b+MKd7awtxj8Fn7eYvC/7u7nb0jid4vB/0Z9whaD +32LwWwx+nxRbDH6LwW8x+C0Gv8Xgtxj8rwaxssXgtxj87xSwYgDh+2HJ/as14YcY/EbHbHTMRsds +dMxGx2x0zEbHbHTMRsdsdMxGx2x0zEbH/KjomG8g82AoEp/taHwOl/n417/85U9gXP78j//vK5Qe +nv/z76z1gPIGg5rQsC3pLCKQ0rWTfWM0az2YdqNOg1LimHV1q9EwqvD6igShFCPjwsQa2You5BeZ +m1baLAhBl5ppMcrZXM5WE51uZraYnokS8tnoRmAhKXuebmah9XB6pqXWw+nVLLQezq93upU7PtN3 +13qIZ6WHSRPhmqM+ChWAcEDqQe9ED4M0AgWHW6mH+Kj0oPSOdoq1EkwTgREXCrIys4Tu+SkCZqvw +K61rRFQMTEOfK0SLceOs9DAJPUzqC8tfIiqU83L0/1Mt8az0UP2j0sMvfapCN05xV7Tku/iT1EMt +P1QHe61H8BttYX+p1IN/7jx+lVIPOk7eWOvhZyQfPNuFCA3YzplTny06LYpvKup3dAzDwsiKPXqJ +SuUr3fQXTBRLJOeRqWwvSj7IWTG/qBLi+KdG+jPJB2qLFZE9yn/lqZN+SD5kSt5MkqPCwtykeJJ8 +oAdIJ10+utFnIXSj8Her+dCsk550YxH8kU14uBVjSO3KqNd/qsJyTqGzxWjWRaR8tbgy4iPLqwCe +KeSc1b3wO5VxVcgzGIf9VvTh0HxQ+CYPR0+1h1vNB5pB1gBHtDCQ6tRJ80HxurW/HXktZUzqYrdy +Dv7aSH/FiEY6DRSdeCFaveCpkX5oPlgrlBWlrKMPrfTFmnl1eT7vpHtll0zuDAxEvSXgez866cg3 +KJgBydbPJH1kHDlHTCeeyQOoCZ9EH7pMwG90r/fOtLh8ln0IB5xP77PRMdCL9c866c91HwoAap0t +FQWJp076je5DoRzMwM3kX9Z9qLpF/VQavYhZ1aFQhGS8Q7Eq8wvKEKwNPdsxVHUl/EAFucOjd2gs +LozoklOpBlOu670k/FBQZyApR33hJPyQmzXSdaIzME+hJOf8WfghWmisf0/5Vt6+nXQffAiHlIp+ +VJsggmW/0X3Qlr8Ksmgtadm2UFOeV8RQHUG7PHW6+muLn195v+FOejr3nCflghd7zhRaFZvW6NOz +nvMhklAeO+moK2rVynGn0XOmCFfQ+2739betla5Dh8l+yeS2rZfurfxP5b4teunf7rk+vNFz0UzX +kUHPk07RVn/4AZvpT/yhKQj7F3PcgKYUDjXHqEbm3NINRspeN9GCKVXrzOKMjoXzeTahkzUqj3Jx +Vr0uWluKkJR8Nuv1zhZKNxkChdBSq8rOrNk1GTFAI2ZveRbTL8+3It+f6eQ54FAFPb3pgSYTPK6j +4QpICjWevjDqOikJtwohRVjey8JkfqbZaHo1083M7/f1r/T5Dvd+lLkWEPZO71LOyPXcy2CLvR8y +rKTujt55Wzwvdd2bu5C/RHv4mV184WIKWFpdXMGy9je6mw93381iAS9u7MmRXaty9l0UxSboaNFE +IGk4apXI83Swij+Be0jUapn166tFvGcjOU3wIbrNRF8v22BY65sm4g0FTAsTW2wWWvvK5IIBNTgZ +dYrANKHBS2BUOjM3Ez1nMppjmrLCYh0whC0hXTqq4bSdeiDur6MEAoyeODpka/stjPTddGxYsz8M +zXmOi0IrgCG5tDmsD0exy5Z+yAp2kZlGX08ZAGEXfd5MP4OcJ6PjfzZYPffZhsahDgO2K0soXmp/ +0HMST3c6EyPtaAyDrvaNw9Vz3HzMs8no+4PlYEZqdH15nQw0l+peNfDk4m5mk8VDzUadyjsDxxsl +U07bxDGHxFkohvix9+uZCE2aCb4B7EKkGscUomCtR30nxv8B7EP3nR7ubMQXz/KGgT5vTUfrRzF3 +pGHtRjqhlQM2VksuGYBBqe6DcXr0hhoTTVh/Ub66MloTveeFyfLRz0bTfqDLSisscnybnO95U92x +OX+Z03RJT58sm5QrKcO10ERXcKHfhIOig2Tek0zJubkN85oKT57swgsXO7zmdAW85pvdzoe7b2f+ +Tqs7O9ymnAG9qW7Da0xjcPryPy2McnzgPJULrkrUUNOvcioBCD1zahDBjxRsFAsFB24pL7782eKz +jRlwCJDTNtS5u7iK8boqsn4BYOriVmaT1WKejCgfIJLIHYLUjxAq0DpPAE6qoVQcQxsYeEIQu9rF +Tqkn+aDWP5nhehcrK3TU/4F35TaANYmpVUD5qbaEAXfRcZuUa/D83lA8mSp19bDauGHdDxG+blDP +jjDcZLJ88LNRpmYjl0KGrP89ADpKcJSodAoQ1ubmEbqJfyvnWX3Ms8lnBiPkqvwdwe1W7WuejQoY +waQlXOygX9zMZLF4psmGV0Pyn5jTqjQfKGSjEBd13ld/vF/9//JUSr+ANC6OTooj0ekBdAhrnazP +VyABqFjrhNOaMrQkerC6G91jdRZa0AV2qLtCV0jhMu8nuiT4UWpkCkEXFovH/gVusiZqpS0a2kX7 +ZriSmqmCaW03m4yZ5pcf4+kDmpfUmfho1l641OEkpwvIFb3ZzXy492bmTbC6r0ecxj3Z2Ov5wutJ +x1fmLnM+9nomdV9G9mped09u+FU55pyqvpbt7mzsB8rGwL96m1UEncMgsgaxR6k4gl2xWVuzUayU +bg30qQPIsE2zEcjZAFxehwvDm9ZG8JlTKSCl6EQsjbwjReEq1MxfuBLHtelP68CGjQ== + + + uTLq2XpPJAYu9zG+cTJqHRZdUmieegC4OBBXOp8A2iuJCfcaLX/ubGQ3nqFqR8f0tbURrwBsOpq0 +HFZLI14m8Qs8C99eMtJn0UJgIIycalobrT7wZHReKksjRQpMFDWl3HJVqIby1wPy05zxmVpu41Ap +dPMvgFJBcoOUcwYqPlt8XLiiyejT0sjx6w3Se3TH5Nvp1xY2TjFShgLbvF/ZrHYSHRAgYzrKCgnn +65vtnj7Dy64vPCQYmvBGMkTucai6hwExh6EwuK3TWq6ntWy+r7tnZvGFix2+b7oCvu/NbufD3bcz +f/DVnS1UoqZJSG8gIHUXJO6ffwkg7p+/DA63daO2RszWjfp1Q6l+Q2ogWzfqN+oTtm7U1o3aulH7 +pNi6UVs3autGbd2orRu1daN+ELTr1o3aulEb6rqEun6xbpSSrK8VjlrTmoac1EbVblTt7uNuVO1G +1W5U7UbVblTtRtVuVO1G1W5U7UbVblTtRtVuVO2Pn41tVO1G1W5U7UbVblTtGVX7uvDktxGnHBjc +PP78CMT9lz/+/d//77/+8W///SuEKR//7XdXpezOlEFbc0cnOzX9MZJzpVYOnNytEY6Hcwod5Z55 +GyVRhCugfA5x6oZYqUwQDO8WUjQ6x9pG5qzCwuSzdajtACF1890vjAhMZEFjeegAz3czm0xPpTRn +MlK6HBDdp4KlvX+ZbobGJhVEJVStrB7pbEDL+PRizibzyz3fxh3f6LtLUqJvfRKlvE8pEpAPbhwg +QDA/giilU2zaFZx2IA5DlbIrOKaxVhNDDxDgfyDddMl0ve8WpVTKbBLNJtdvqpT66GhIBRAikyrl +LEvZ7paldDYVADl5+4pKiRUpgCVQJKi/+fA2j1W6/DUADsWSSIehSkk/H1Fo3X4KPxQ+Lv2eAHL5 +2a78ObzbE0AuPHcfX4yQW7/c76xLGd5al3IWpCwPURugNiYW+GcgKRBiaL8dgpSeGANt9+z8wmhU +dhlPkSklxRdMUH2jdyQ/+Qyg12gwRRPyUzDIqAeK0ASj+RGhJwcGgrhx/CJn7FFn5LdoxRwYvQYu +NoHrU7anXEn+Vvm1Nrh/xOihC8YMHtPXQ4pOTkHHT8QjHBi9AoyvMgshXNDH1FoA0MOAFH9g5wIy +wUy3GMWJKM9DV0i/VmeLIRlIKQKRMpdeuoruW25TrjKEtUHX2k+M1SHKGxC9BOoQMUx/nIZU4QIy ++c2lA6IH6AQZvgIaWYcK40JgDUXQjQdET/fFAAsUBXHrjqEXnkE1/hF9l3n7BdHBj+/uMBqKlMwd +0l26gcS6QvS6byl0w6IkOXY9Q6YE5vJy1by6QJ9AenyKzuQDtPWvYCoGDfRMkAFIz5nyun6tga5f +2GQlUPoKWpLMFsqPGD1STpqX/aI/9wHc70yIOTB6XkccMD2anCxkJspA2tJHk1m/YvRo9AGydDZB +q+UITIexBukZRg/4ow9jyyiCUI5VYTFcFSCD3rkNkUkDZJaZ01GLFnwrpT/h5gqosZ6PfoZ+Um9R +26zWF0zABQJI6cGtrjIUKRntpCVUGam0MApA/bwBlNjB+QrR84bsK8r7zITJTTnYnIQnRUokUQHL +1kOR0g8l0qAjuT9C9LR2KU6XyyGPmduYppQPiF6SA49oax5CnB7MjbKh3g9EZkTZNNREp+KQ89Sf +FJ2kGnTZaUHY7o2JdgqBRV5b/PzC+w1j9M5gtnhCmJnS6i3CzEa+0EVSZEjLCKHxA8vGOLLomAs2 +EHooIQdftBVRWKR78aALawPprAGYdsdPGUSPHrJ2tOvWhtMetcEORe9RP7rA6H2rp/rwRk9l8wS0 +pIMp2qb+CNEDfq19XjdE78eA6D1C5RRrVacLGuC6M2bgfSHB1TdDDNcBD/7JbPRf6tzExbbDyEYL +OlYIbWWtBU/vteL1Gcgmk5DooHfTVy3DhGUsd4izNJOIdG8qnSIzOHuMqoImG0HTrAVLjMS0RD02 +yRVFv2JoVsUiWrU2V5GxhTaLkZmHaVRhFZzz+fXjNgjKjGLFMcszM3jQwPhaH2Tl4LB1jFcd/awQ +LYKMYx361DKButQMlC0TZuVlKuc21PGjxTgFNLXOE2ge1jCDj8BkLx1EfQQVNhEuKi2146UqL9XL +iJ2BA+PoYBxd5YzvkTE572vV6ddgQgWkqG3YF9MiK3dLh7/bKSUH4hL/QUXaIC2JmNaGEHV9ABkp +A1cMpCTfZLfzZZgofA2Fo6xZxzcxfKzb6A4+Fyb6B9reDHtMNpAuhmzQJ+JOa86bkT6zjnBT75YN +UH6FCwqOtS6vt3Njkx4IZRUTJyZgXfBHBABWsVBoaOX5HqLVKJ3NWqJk65jkpshzfMzJhJtpDEdj +4Cax0MoIk6iQVutY14l9mCBMrRBJd4PKukwUEzP1zHg/ZtLAIyiQYj6lffD+YDUGvfJmfSE9tw3M +9B6mibFBMEJ3WmEIS2HY6P8JTouc/t4Fi+IoixdEf8frQ1qbgT5AnYYJSP3stbAAjmECDJq5fIpD +Wjtu59YIwFQFRtJRpc/9uJ2TERMSFfFApyEFsTlxChICj8TcMzs97jICMuWZu2i8v/iCkbJlLSWv +l6JVxccgNrIheQoDLT3z2kgK+5krST3ETAjstClMlnyYMEIpa4U5SBHjuzO30OTDez/mZRb8RwSy +QNku0VY1HIIe4jpSU3l41ZPRAWGuH5wGBiQRs5a8MOGnKs9gMuXNxk6uLhMZSilX6L0hJcwkMVuU +8TLDxJiPWj/K6q9DJfGMnfjTWxslGl6hIbKufOZ4OXJtjXL5MVfSaaXGCI22HSA4OSflBYwNIES3 +cqW+BLMnuZuFxcd3LG99OuWbpoteF0byHziXnsfwB7+4GXaEN3l5BkrFuHyoAtWNbxeN0lIXLweQ +QmVWm7e8YfUZMHHUXZj6E174UpxQSmK0sRjqE5fX0bd0Nt4laKfn1bqh0sasBQZJ8CGW609GERCP +tmxI7fodbtZxoRABTY2JR7GtdsPK5LSr9FOz0bw/GZwbbO4Xk4AssbrLaPYZs9HwPkr6cWpKs4dR +oYqrM1FpT3v0YgWEZDPudbLYUkuJ4UCx+Ksv1DFHyZaZGeyJyGgEaGWR5v1wqTrsErXzgN8t5GhN +2bqyxpDN7+KbGfCpZ0tg9T5hBIlcP8WQ03B18Yq4DWwVDAjDzDOqsIziLIuDguilEXczmKQ4vzxw +IJ3L7bhkhZ/cF0aVmoRSdhudyoit6fRbWJzP0I/vhlGEY+aZRXscxuT+QfkpiabhkrMNoaX4nQbA +TU8MEgzIozfcVGZsaeiUXyDgWWTA0GbwPvrQjELWRwFLp2CfBvMRYYBl6FqomRUPkU9v2FJ3MFtT +pPLpGLORwfWGZoixKeCRiZKQzJBcTwizCJvsKoTxciyNQa+r8EtGWno2uk6btqzCuGxSNIr7qk76 +aDjzczBI4aPy7XROINKwCCo/MhecxpSjYJSp+yyi05TRJ6gw9LRlQG5ZnNtISWA7PRpVmJCKPzng +jnhZ8Z+Cb3qk5ZKYH8J2oHtgjzWi7jSmICl8wySRs3lmGoSQj+idKcL6XIpIuWcSO8ZiNWaxRb7W +ZPQJjD2SPHobjbnQ3Z6MSNVYs/oUaRgx/rLogT01w2FUWF76I/dKl0lnBFMGFXYz6dtMqJTrpAj5 +akIxm1Gw3nwYEyOd5Yw9h2ZAfAC9KTCJGeUgnIrWrlyeXH4giNHqYQQ6I2wSEPQwvhdDpBmcLhfF +V9fXsp/wVKvCWD22zAHp2998ZKq8DnNKlJ0tV8cqpNxlvSD5Iua4B4YCF06dir+ozCZHo4D0JzG8 +AcKzgsR6rdjMJh8B9EOxBWmbxojF+Tr6NHrqwPRh7YSxbYg8GTzaLdYEnWz1JPI1K+JhAkiUKbwp +Wx5VqU8zRDsRsFN/Y+PoC7BUmRhULuZB4JpSPi9xmLCY9Mo41d1j+FCP4kFcmADQjUyWsdmn1bvl +dRK1J20te8MlLu4G0DXeJXfzK2H5VIbMZu5xY77M6uVgof3JyEJlo6UvXjEmcAwZqMn5s/xUelyK +CFASGNWZVtcpymf1X4OW6bjOsXB0ajvHEqzRTLRPI/M8aH8eC5Dp0Sx4P2gKRR+iR8YgApUNx0Ju +AME9VVpvtReqQnpwyrTX3VDGBGEtyXE3iRHlhf5S78euiuwZFnOz94cRsMaS6ZGmY3dCk040ChgD +iolOETuYnTFTbI/3ZpVDuUgziQz1jvj8J19hDGkT/7JPpeyH6DZGGPx16XVeLz58evdfrIw+2kLt +geFFpNGgmw0X7Og16JVDejZSH0TTaNOusi3Gsw3g7E7IGiBWsxY7xVZ9Vbl1GyN5oTicmU9eOU5h +dHemTOt+mFeJ97AAXQcGzH54tiUcoUihVu0NWniBbaDlbImiM1B6h8yg7NRpzWQbdR+gazO6clCx +mdeuEFUBjQ5/ZtVYzsEIeoaAMbgc79O6ghMFGEyxz+QYB41F8Q3j5Ak6B4RbqwOgKTicNAaXM4M7 +kdTzYw2YerJGkW1eu2MaLwFeTzNQa+bjc8Ixr7pbtqnNXBiVrKxjxHst0b9IxEKFaoFNqqdzA367 +25DwRmeo61dB/pPI8Y71CTj5AbiHhYm8WCPJsPNeIZ21dM5Gn2CiKUiTp9YnjublJyNtTMr+hI6N +ps31lgEqM2NOcRoQau3CaKx8ts94cqqGlNk8n7wyIpqR4sqDGDV/fYNGOYmNmeAy4bKRCIU08vod +GAbUCN0iJpyZGexuD+S09j0r7xRJioRTwIUyW1phxjGf2VYGfTdGhenyPHl6sBVZaSsqjBkLLDV2 +sjeqNOPRkedTSK+P7qkFWTTcCMQI1Wq+6CUjPdJYT9mg8rbaOSD1UuFcDeA+khmGDjQVJ9s1wMIo +VnHSXHrXc+lHtCgV6NfV1nt1A3/Udr9udc984gxNgPCIwk0iM0D+yNvoXFhYge6q3oDOkrgwsvFI +2fQ5QKJxHShzzuJ1a/RcRuFSwQdbN1CfIlgkT0k2E9a1I3FFDENnczTm0HsT1MJDEqwhqqS0oypQ +oQ4Hi8cbFYOvTFWCL41FMPIDm6lwcMuC7xloNleWj8UIxB2gY/TdCWtQDHFkfHLtVE5H9HiO+xZG +JKqZYWp6QS2vroTTyNaUpjVlI8cJdZRuBoM1JCyYca1MrlLrHUPJZVzpSqBzgq+X19BG7pQi5Onw +lyQanSi40UdIdjuclqOv2nQGBcOxE2zbe1eaaEJQGaYl6iCJogImVgjTB9PBodgVh6kbgsSnxQnq +RibM+s3Kn5j6a1G6Dvhu65kp2XZA5Qdi7Ug7D5z2eIfMDQbslYnUDXqvVSE3UKE0dcL0Ik/Cmtb3 +pGXdzXHIlzsT0tH+wQEVa5QkQqSczUllphIHviD0n0g2iUwmaZk8jE1NbrAOM3paA8c7myzSwKVR +R3/BMjjdvY2wlXePTGUnLXzflcVA76KAaYWkRWp7NrFfCpRAaSCiJfLCdchiG7Gqsw== + + + 400mjdHKlT5+GSbBPI+ig8yHMBN5OtZ8ou3yEXSFNY/1F2Qa3LLTUslKHAsBWPfH19Ji07mod8Jj +yWcCJ6eJryWmhaDlrnApsSVYCuMEhNHXLe3QmUzvREejvI8dZeacqcTRSE807zNPPhutCiOzUXD8 +lZa2Yj+qaGsjwjaSOd9AJnDTWgboYCguqMXqOXpDpaN9E4v+L7UT/Rl3zmPUhcWoQAF2BjneR7f9 +bGR1Eb0LRAArv10WRqOyZo7nyG+nO16ZnJ7cVs/ZaK4QNy1dY8FAyPVj4LwVRhmgCEnaXzqzur1S +CzorY+isTCybZCakFseqwnmyIENRmJmVJyiGk4foq8vEaBUMNANbHeWw080cBeLAGEkkgZYFuoXR +vDBWRqfX7G0Irk4Y5Q29mrLY+WNZ+VwxhE2n9XX1PT9ahB0i0aKjGbRaYJ+s6UalBu0eEoHVj1Xj +yhPPJXBOq1temEwrY2G0aFVMRtM+HTct14M+IPlyX+x3Ht4kIO3I8GXhNby5VOJq70faOTmf0WBA +ikzxpY65vHJjn4ZRDiQIhRxm4Q7NxDqECcWtuHCqi0bX7JxZP4Rs0JVTsfxkvg5eVf+Tke5qfnFS +LE3OJ85sNJ1ctpqpUHnYw8YePZ9/cE0UKwKtoZ+9OkbHUiVxSzq7EZ1cHsgeL+Zs2ixkz7Q82j3R +c9HZHxCoq20RJAyjitKY96PdM8UaWhXEiom6Z7Ih0xaxhDKgbDC9uAgSo7pF8pRF4MNzUanS2Ya4 +gnWEphDqkxnpgPTg/BSqjkAMfEI2hYo6dqCeHjE8Zc/k7lM4xxts0WrdseRl7DgSc7mOkC3uot68 +iB3xLXxkeczaTIZtClXHiidr9eDOHNGjRbzUAGjpkdpYN0w7r9M+iOScU9zsRylUmzpGSkHL+NtH +j1ChFn2UNzT1iXMcjwBEZ9YuWCqw6XM2cEdW8fGe1OOTgVhGUWJR+ItA0El7E/q24PvKg+HcG5V2 +K7SdTDDQS9LST7bHKkcjnXcYm+RFZAUFkGizTugInhn3nKkxa0NbdNiVLeu9d/AUhcJWJnYwhMPA +s5IzOvkXCrsUfAwlmYEdFP0dL1dpKFq6hcoq1DDWmpk4xnp3CopUq1F9lc+skXY2joz6cdACVjCj +12/4R3IvuaQMkDXbgs3jjNXujWgpGKM3UIehgoartBXEeHQ07eBwxfl8nyzG+Q4DEW0BYH+ry7CA +aOUl1BEIVqebAadgLkIJKWTn5UOxWuWQQpUXpQexeDcGZ2B0d2FaOH2Y6Q0bAotUkNHpIay+1LFR +qd6Qq1+1cW6/+SczQlKwEqZbm31aO2ZCOumQXiB1Py+/RUX0ZDFKr9qioeHRbQeurqLXC2EuuQHd +wYJqFgLC9GAxQSkVnqzC1FHqzJyzlMQqzYmjviRrCq/d2uN4PteMV15AIF2gSuJ4AiyeYnIrsCgQ +K6Cv5YjW5tL12eTjO2oq+gB0nDLLeWFE6SjiA60RGcPibrQ5qfZSuHZAbpZPRe1fzlJvTt8u9rR4 +O2jkITiCk/DLz/C6s/l4h0PCfS1KMToz4Vkm6tWAsX561wGwQDqxfkRaGRFQWVgGyNoImJ0iWaBw +an3ZQH2JVi8iwrGPBqdRo5tBYsvwuhWFB5JsbcBs0qkyoklrO6TTna+UT2jeRDkUmxlvHQwgZ7Eg +A54voxRInOvDABLBsI4A/Yzoa50RYO8R5AJC1tR/iWjoMco/AM0imKOvwMuCY++bQajQBvfs80Lg +YYoYSKyAq6rJwDuNTU3525lYib8sypdnE462qRB6NkLfRLEtIDWFYUzbWBhRc+104AugAlOK55ZD +o5SnTwi0SSYETQosemyHBMrto4+6NpgOD3OspdVL/GRGOqHlLCh6xLb4FtwyXYxEtzmX8dnh3ikj +bCihFqsB06wwIGEOfbkyqNcjrwxP2/ujXCEL7RRPcdYj1KcnbXJuCA5baWlap3es94/3bIpP92Gm +PQIs1qCzltHAbUKZo7+bM8s5rCQS8N10yw2Iq5SqmciKPqirhsHTp0gE4oD4UrDmRQU0SBGV8EiB +NAUyE/HSjnTmY5FqIcxWnuiNBgGKuStcohOTLTksF74ZYA8tVOrL+Z6feq+rmNAzMwAUMxuKOdsE +A7L6fsyf/16P9eGNHkuRhFX9EJUuSB9U7QhjUbD7CUJuYMxvM+jnNXrxlw75eSIXf+GEnzO1eA/6 +2UM99qCfXyU79Tc0vmEP+vmN+oQ96GcP+tmDfvZJsQf97EE/e9DPHvSzB/3sQT8/iIjAHvSzB/1s +FYGlisAXqEXFXzLh59lMny1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyx +gi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVbrGCLFWyxgi1WsMUKtljBFivYYgVb +rGCLFWyxgi1WsMUKfo9iBd9iNnq+BDZRjrfqBf/7n/7xjz//5d/+/hWz0a//9DuPRqeOIY/JQU0h +YT0a/Wy0GI0OGgjgDF8gGZdkGo1OR0L5ObNTq1V5FqPRgcxBmWvFSL8LI4C6yioaw0HT+m5mk8Uw +8dloGo1+vpl5NPrpkVaj0U8vZh6Nfn6582j0V7/Rdx+NDor6NBp9miGeL+fB3jycYyJroStv+ck0 +Gj0eo9Hl6oHCVZrciRnitM7ABBPLhbt+S+mTFQQCoVXkvKDP/kDvlL5qxCedZ6NPo9H7XT9FQQ5Q +uDLmSEPpxdHov/yxuD0F1+SiAPLSaTZ69j8UpXjPRv9ZTrF75j++fDZ6+BFmo6dvPxv9JdbozWz0 +54Tm1XjqE6H5pSHXS0bz88noN5TmR0Lz01z054RmC7HmsegvMpqfj0V/gdF8MxZ9zWi+mVf+nNGc +83os+g2juayvsmA031jcMJr9ei76c0Zzrqu56DeM5ryci/4CWfl2LvqrRmdG82CeT3PRbxjN4YVV +9criXHOa63ou+prT/MzmOacZ0sViMPoNpzkanGYejH7DaS7GGTgPRr/lNMf+xGl+Gox+Q2m+8ozP +g9FfojQ/m3p+Q2l+yWRNab4ZjH5DaV4NWL+lNBsLex6M/gKl+XYw+nNKc22rweg3lOa0Goy+pDSf +BqMvKc03Y89XlOaTwc8vvN81pdlPjNw4kX/LI/n3OkO83VKalT1HXfoZ+TfJVfe7fusZp1kPQ0nn +SmoOvNMyMtrv9lwf3ui5Tqzmsmej/3is5udx1yAem7Og4c4JYs1078lJwFDC4CtWeYYqrGWnBRqT +H2yykxEVYxwjx3m2jKgrcQHDrxzHNWgWs0njM1Qa1xRkO352Nir42R6hNHjD0s53Y/0l2hzR9WQ8 +zempJpOPi0fPphRFHxNWoYEfegRM5/kUCTzqwoi8uDqQUDqUrSkG54kyPB1dOBALk8Wjz0YgP7VJ +k6XoqV7mm7FnUD5hHDQAE4vveTbRIRO8Ha7UemFVrK4Tic2Uyup4CiaUcr6Z2WJ6JsrXxcigAIsM +3DbZfJptppVDug24g/5RjRapn9ffHev4rlOPxrbiuwYmlGomm87qMYnOKpgUeUc9AhSkVJ1D72VR +PHHWTSpKPhQnNWJs5OVAbkCnoLsEhQCVUUOOGFqWniP0Uflr0DVyW4qgYrPup5c347Ezf+mMqNea +ogMOpajDw2cDllMWuOgdKrBtZDDaJqHc81vvqeg/QJVozlD4BfQCJCAABfzSh8/f76k+vNFTUX3S +NnVE59DNkGODVEuDOYByfXYk/euLOeof3gFm0JbXs4OLMthWMgEBOroeLDlOEracwrZO6tWNR3w2 +MneSKbIboNbO/smoU0c3haACFtGuA56I5FLvGCzzyoQvAWlEiWnvo5l6tglGpXc1wQa1fnXrpAWZ +mgTSIwZnpHmjw4Ww1JcLXasAyFr7Smmv1b6KIc2U/mX62Beg+bUCngHPyOKRn0b2jm6QlktMo8/X +kdLV8Qo3z8q4hAdw/+ETFm6nZthCFVYw6P8ykpQo3+8quNfUL/TTA+0gBfn6/TBMLAPR99FxGUFD +RJBw4AsUP/XxU3p5dMNYBmkw2qiEQtDxnbUsfyG3U+09eCouMOygY4KpV0DQwwEx5HWCFjDSjCxg +eALE12u17N/DdjSgEr3SQu1VUZWDf64Pks0kGO2o49L6oNJGud8KrEr5qKGtlKDQiER6UB+XriMh +GIdeAj5AJkjLheYusCQdacoEFSEGvi0Xd4b57w/oPATbyZESJAKVo2/j0aGyhgtoTP5Av9wPxDY0 +SvB8mVLtwuhgIyOIVQBxHvSBW6ME77oYO7ixUoztQOMZPDt53cJCEQ6inU0HhJKpMlietzYg0wLg +NoXFfnSIJxvKpnrnPER2FPPn2zVwfaH1iUBYbpf5sScTfSmnKDda2taNkDvZ6Etp70FQSjp6dBe4 +08hGC1pNLPWWLyVYVJM46Cgm4XEfoE+gMK0PBksd0iXkV4/TcaaG9MBmVdgNP82ONIUaVHI8UTjU +Ql3H6cdNlRrq5cDNlwcjdwcwnFya+6EVrX+JtkU1vrs5/wIyAMERnouKOMewnLOSAt2PZ41SDEh2 +RjT438pEadi1dKxjq4knJNBMLwDEa6C9nZu+qr2e+T2vjQoqL3pDvteyWBnGB4AH72CUFHMGNKNp +c4B8BASIUdK1E7jlaM1fFmFA+cbB4IKY+gkivxwDRKt08Bg68qTJaF058Gx8Zi/PgJJhNsy7d7zp +0MDPBQB3fAu5QGcuroGGZBMD1iSRauz9AeVvkSpaAVZpRonjryPWmqJt9UwGr3de4CkfAhn5IZLP +67fAIA2+kaeZHyguZHx3VHCVAA/oUiRpcvDAoXD6AD+j6wMojNIUYZsOcoN+U8HKtaJ9QKg0jABM +gTRB/QEjlCCATcAsNV4SUZnCK/kVVCXkZ+msENcVuHHeDpP0gO6NUhQUVeKl68/wi+T3dEpejwrF +Us4EaUo8FDAA1/ENFSekYZNp9qILOzzzbHM6AD8tD22cHzhv1FmNyICRNt2gvlrtzH5METi8/NoG +sjK4B2q7mT9bgcjumlNe/5LGuhmhygEBA4BTHg8fUBAFMQ4SloPTDc1Z1A7yeIO+VM861N+gIaJV +H1Kt+tLVjWen64ZkYqNPZDF1QIe20tNHcCAf3xSRTWclWQODOjCMQNohkVm5j0q1HBIeWs7C0GrI +pwAqBwMVDhkMbWYPIMxEQriSjjyPC5JzrSYLo/VKbxH9s9YOtHWVE1RQT2vLWbHd8Whah0leb+xo +A9EXyGhG3axjBxnqgJPbYNJUuBUlaLHKd40jBW5ohaELFulCrKh/UqhyU1Mbu5moVWvKxJSGLJO1 +4vQvmymSLNyCqVZ56nlkMAdAfGUUTe+3OZNeWZ099nMsnwQmIi29md22xWP6ii7lw3niu7SfSqnp +gPkChYdKli2CxAeD7+W8Qa/YAOkVdBK0NzccedQ/94heMI/gwPjCmNdWNMp1MeZxTg== + + + w52M1NdUQoDm02XEU2WrhXMvDcrsdXmwusmyqTcY9Nbw2XrxqF+060JjqWr30Au7vI8A8iq9ax2/ ++vyW4Q1pDq3EDPf1PUw39PMcQo4j0Wbp66WToieg0GbEKi9UV6M5KnYQCpt+YGYBA7MzIxD+6k1k +yrYhVSc5/AyY+z1VfqIjWLc68bIJ9RTQ8DoC5C3oSQOid7wJ0K/JQKyTY5CRVm5XrJwK4Myl92BD +a2nbXdc+HNUpK8BERy6wTPlKu87kzfgtvHEzKk7j2c11euNSEAIMo0JVF+WwsVdB0+ipgbWyRMN4 +eI8sJ8ra6H6MjjQZiEJz4wLzCpNJXZhOSb7oONBLANvXQI+28SU4dXQ+cXSVASfWQgF5W8nIh1El +V4ss3aFQwQkFWZlyfDXVEZyQP+SCYjGutMXHWjENT2SiwciMsCoTOT/9J4vET3E2dBttTKD/Cejp +ZQrWIUJQKdH+HCUfi/kTETcND5MGzzwFdU1Ux42dZNkDqQU6SYXSYOhG5+JYiRzkPFgAC5zBb6J7 +ilF7MN0GT5JTIbJGU+DTUuVQoLUvE0efq+j166SKF2MVwynS49uvYwLdIUPXItSgICb/VnEkEZUP +GiFmBJqtGzjTWMWBjrIngczHzQRncGfeSLpY9uU5dyH/k4PooQJdryTnD+mTT2q0bEAZldBVSwMs +pOJF63tAPP6EInvupsGkF5rNpiBVotDboNsdCGqhXNIhgACyjNYGRGENMtyAl50y00hsAwWITk4a +DOfJaN5as4nO90xIZirtMlqk2wQFxQ39MrKoRdp+Nvm4iiXORp+sqoYykoNzEQ0UdTaykEkxG6RR +dGQWt7wwuX3wIfFxa8ILRDqJ4o0/XKX+ypvok8KG4ztA25PzTHj9cCHVj/bhtBx7HCYIG3SisQgq +0tvatyoMZZZsS6KDQlK8JycUhzYaPCrUvRQeVVvGtrjguCkAqjkfkNk60tR89DFZpFr8ugg4pzTw +sHLAFNmgdy9WOqeNNgPHaOsmVjOZfLYjCfUBBZge0P3C6D/eoa1ApR/lHpg0yx8LeAe8Iv24Nm65 +gHpMkNQQKU4olDEZyEG+bQtnMcRL0K0wv0wf39wOSiEexEwa34vEHPECRfvFMliO6AzG0aHjEg8t +EJYT+V5iE8MGawj7wJMkkVqYgKEl4iUjV+hnXdPJSC8eiWc5DcDYxa6jzIwmKZxiIwEhjOhwFtSq +LtwvmE5wa8m0q8xr00dNsNWGVgb6mDi37AzXbLFIgFcTUNxRbGphBnUNxLijKfDJKFhIR8vGm6Qu +5BAwGiZrQ6ZDTkf3WB6GEHiYdORt0LShD71K3eeQb5G7Q0FkqhPNBlbmwsiocSFajkfut6g2zCZT +4HhQ7G6MFjnuwuhcRJlvearELKLduexjLxGylcPHGdZ8LvtgpOVtcPTCc1BjqhSZIPmjRT/4hZCJ +fY3jIDFwMFhu/TwR7oWVkexsyhaTWb5ApbnAha/pum9QH4CzHUepzwpnWrJyYQor7GtRsAcpB1Kl +HbqMzi6CxkQf+jhyeABpjOZyreJFw49CqbuMHcqCjM6kXkctMCIcN1jx80YfNUU4gkBl+iH6Qk0j +svNNeUChLZ145GCdQu12GV6nG42yZlOslAlHJ1dK7CtzXpS4s45dSxLNAv0uRiT4q4MDcBEQ3BpQ +llub/3g3nKlerd4dvMHFL5lHptOkMySn43blsqFYUAuKl+HZeW5nmKOjaKu96sh6S7qmo3g6BSjo +uxwpdIfmEMBPDE5zQFCQxUX0Wq9lZDgmCDrJPVz4V4EuQOD4sfomtWjk6iIpgUlsng8+q2mjdeih +kw3C0mw01wYWNqca++I0P1fq72gL3Im0kNtLBhAG6hKXTacAbh79LmoThNevNJ1qOLVnwqU3GmLK ++hCbylfBnGDSQBElnWCgM1hj4BNjSWMRO+oY2QQFlUiOnlOgC6qMKxqt6KJ7hSTuafd3ZHXu+a0c +QdcBpqKW6kfXKTxQowVtBqhg6jp9u8f68EaPBZ2C0CgOIRxQUzDoBqyN+OLnmk6Lv3iL2Yuv0Re+ +dPbiI3nhC0cv7pmLe77anrn460a9/4Ymae2Zi79Rn7BnLu6Zi3vm4j4p9szFPXNxz1zcMxf3zMU9 +c/FXQ1DaMxf3zMXfMzvpC8jo+ZeMXvwfCzqUof03JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVq +U6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2JWpTojYlalOiNiVqU6I2Jeo7UKJen/Dy +tVNg/um//vHf/vR//O2Pf/6PP/3t3b/9/Y//80+XP/7lL6Bb//T/6L+5/Nvf/vT3f/z1b3+6/P3f +//r/8jf6J1fzf/qn/+UP/+Xd/w8Un1kg + + + diff --git a/sample/radio_qml/package/package.pro b/sample/radio_qml/package/package.pro new file mode 100644 index 0000000..b9b85a1 --- /dev/null +++ b/sample/radio_qml/package/package.pro @@ -0,0 +1,19 @@ + +DISTFILES = icon.svg config.xml + +copy_icon.target = $$OUT_PWD/root/icon.svg +copy_icon.depends = $$_PRO_FILE_PWD_/icon.svg +copy_icon.commands = $(COPY_FILE) \"$$replace(copy_icon.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_icon.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_icon +PRE_TARGETDEPS += $$copy_icon.target + +copy_config.target = $$OUT_PWD/root/config.xml +copy_config.depends = $$_PRO_FILE_PWD_/config.xml +copy_config.commands = $(COPY_FILE) \"$$replace(copy_config.depends, /, $$QMAKE_DIR_SEP)\" \"$$replace(copy_config.target, /, $$QMAKE_DIR_SEP)\" +QMAKE_EXTRA_TARGETS += copy_config +PRE_TARGETDEPS += $$copy_config.target + +wgt.target = package +wgt.commands = wgtpkg-pack -f -o radio.wgt root + +QMAKE_EXTRA_TARGETS += wgt diff --git a/sample/radio_qml/radio.pro b/sample/radio_qml/radio.pro new file mode 100644 index 0000000..80f6d6c --- /dev/null +++ b/sample/radio_qml/radio.pro @@ -0,0 +1,3 @@ +TEMPLATE = subdirs +SUBDIRS = app binding package +package.depends += app binding diff --git a/soundmanager.pc.in b/soundmanager.pc.in new file mode 100644 index 0000000..a02286c --- /dev/null +++ b/soundmanager.pc.in @@ -0,0 +1,12 @@ +includedir=@PROJECT_INCLUDEDIR@ +libdir=@PROJECT_LIBDIR@ +binding_install_dir=@binding_install_dir@ + +Name: @PROJECT_PRETTY_NAME@ +Description: @PROJECT_DESCRIPTION@ +Version: @PROJECT_VERSION@ +URL: @PROJECT_URL@ + +Requires: json-c afb-daemon audiomanager +Cflags: -I${includedir} +Libs: -L${libdir} -lsoundmanager \ No newline at end of file diff --git a/soundmanager_binging/CMakeLists.txt b/soundmanager_binging/CMakeLists.txt new file mode 100644 index 0000000..003c394 --- /dev/null +++ b/soundmanager_binging/CMakeLists.txt @@ -0,0 +1,54 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +cmake_minimum_required(VERSION 3.0) + +set(TARGETS_SMBINDER soundmanager-binding) + +INCLUDE(FindThreads) +FIND_PACKAGE(Threads) + +pkg_check_modules(sm_binding_depends afb-daemon glib-2.0 gio-2.0 gio-unix-2.0 json-c) +set(binding_sm_sources + soundmanager.c + sm-helper.c + dbus/audio_manager_interface.c) + +include_directories(dbus) +link_libraries(-Wl,--as-needed -Wl,--gc-sections -Wl,--no-undefined) + +add_library(${TARGETS_SMBINDER} MODULE ${binding_sm_sources}) + +target_compile_options(${TARGETS_SMBINDER} PRIVATE ${sm_binding_depends_CFLAGS}) +if(DEFINED DEBUGMODE) + target_compile_options(${TARGETS_SMBINDER} PRIVATE -g -O0) +else(DEFINED DEBUGMODE) + target_compile_options(${TARGETS_SMBINDER} PRIVATE -g -O2) +endif(DEFINED DEBUGMODE) + +target_include_directories(${TARGETS_SMBINDER} PRIVATE ${sm_binding_depends_INCLUDE_DIRS}) +target_link_libraries(${TARGETS_SMBINDER} ${CMAKE_THREAD_LIBS_INIT} ${link_libraries} ${sm_binding_depends_LIBRARIES}) + +# Binder exposes a unique public entry point + +set_target_properties(${TARGETS_SMBINDER} PROPERTIES + PREFIX "" + LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/export.map" + ) + +# installation directory +INSTALL(TARGETS ${TARGETS_SMBINDER} + LIBRARY DESTINATION ${binding_install_dir}) diff --git a/soundmanager_binging/dbus/audio_manager_interface.c b/soundmanager_binging/dbus/audio_manager_interface.c new file mode 100644 index 0000000..3b1604e --- /dev/null +++ b/soundmanager_binging/dbus/audio_manager_interface.c @@ -0,0 +1,9360 @@ +/* + * Generated by gdbus-codegen 2.48.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "audio_manager_interface.h" + +#include +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface org.genivi.audiomanager.commandinterface + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:AudiomanagerCommandinterface + * @title: AudiomanagerCommandinterface + * @short_description: Generated C code for the org.genivi.audiomanager.commandinterface D-Bus interface + * + * This section contains code for working with the org.genivi.audiomanager.commandinterface D-Bus interface in C. + */ + +/* ---- Introspection data for org.genivi.audiomanager.commandinterface ---- */ + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_connect_IN_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_connect_IN_ARG_sourceID, + &_audiomanager_commandinterface_method_info_connect_IN_ARG_sinkID, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_connect_OUT_ARG_mainConnectionID = +{ + { + -1, + (gchar *) "mainConnectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_connect_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_connect_OUT_ARG_result, + &_audiomanager_commandinterface_method_info_connect_OUT_ARG_mainConnectionID, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_connect = +{ + { + -1, + (gchar *) "Connect", + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_connect_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_connect_OUT_ARG_pointers, + NULL + }, + "handle-connect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_disconnect_IN_ARG_mainConnectionID = +{ + { + -1, + (gchar *) "mainConnectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_disconnect_IN_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_disconnect_IN_ARG_mainConnectionID, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_disconnect_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_disconnect_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_disconnect_OUT_ARG_result, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_disconnect = +{ + { + -1, + (gchar *) "Disconnect", + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_disconnect_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_disconnect_OUT_ARG_pointers, + NULL + }, + "handle-disconnect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_IN_ARG_volume = +{ + { + -1, + (gchar *) "volume", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_volume_IN_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_sinkID, + &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_volume, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_volume_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_volume_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_set_volume_OUT_ARG_result, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_set_volume = +{ + { + -1, + (gchar *) "SetVolume", + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_volume_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_volume_OUT_ARG_pointers, + NULL + }, + "handle-set-volume", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_IN_ARG_volumeStep = +{ + { + -1, + (gchar *) "volumeStep", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_volume_step_IN_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_sinkID, + &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_volumeStep, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_volume_step_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_volume_step_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_volume_step_OUT_ARG_result, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_volume_step = +{ + { + -1, + (gchar *) "VolumeStep", + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_volume_step_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_volume_step_OUT_ARG_pointers, + NULL + }, + "handle-volume-step", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_muteState = +{ + { + -1, + (gchar *) "muteState", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_sinkID, + &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_muteState, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_result, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_set_sink_mute_state = +{ + { + -1, + (gchar *) "SetSinkMuteState", + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_sink_mute_state_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_set_sink_mute_state_OUT_ARG_pointers, + NULL + }, + "handle-set-sink-mute-state", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_result = +{ + { + -1, + (gchar *) "result", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_listConnections = +{ + { + -1, + (gchar *) "listConnections", + (gchar *) "a(qqqnn)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_pointers[] = +{ + &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_result, + &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_listConnections, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_commandinterface_method_info_get_list_main_connections = +{ + { + -1, + (gchar *) "GetListMainConnections", + NULL, + (GDBusArgInfo **) &_audiomanager_commandinterface_method_info_get_list_main_connections_OUT_ARG_pointers, + NULL + }, + "handle-get-list-main-connections", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _audiomanager_commandinterface_method_info_pointers[] = +{ + &_audiomanager_commandinterface_method_info_connect, + &_audiomanager_commandinterface_method_info_disconnect, + &_audiomanager_commandinterface_method_info_set_volume, + &_audiomanager_commandinterface_method_info_volume_step, + &_audiomanager_commandinterface_method_info_set_sink_mute_state, + &_audiomanager_commandinterface_method_info_get_list_main_connections, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_new_main_connection_ARG_mainConnection = +{ + { + -1, + (gchar *) "mainConnection", + (gchar *) "(qqqnn)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_new_main_connection_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_new_main_connection_ARG_mainConnection, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_new_main_connection = +{ + { + -1, + (gchar *) "NewMainConnection", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_new_main_connection_ARG_pointers, + NULL + }, + "new-main-connection" +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_removed_main_connection_ARG_mainConnectionId = +{ + { + -1, + (gchar *) "mainConnectionId", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_removed_main_connection_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_removed_main_connection_ARG_mainConnectionId, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_removed_main_connection = +{ + { + -1, + (gchar *) "RemovedMainConnection", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_removed_main_connection_ARG_pointers, + NULL + }, + "removed-main-connection" +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionID = +{ + { + -1, + (gchar *) "connectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionState = +{ + { + -1, + (gchar *) "connectionState", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionID, + &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_connectionState, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_main_connection_state_changed = +{ + { + -1, + (gchar *) "MainConnectionStateChanged", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_main_connection_state_changed_ARG_pointers, + NULL + }, + "main-connection-state-changed" +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_volume_changed_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_volume_changed_ARG_volume = +{ + { + -1, + (gchar *) "volume", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_volume_changed_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_volume_changed_ARG_sinkID, + &_audiomanager_commandinterface_signal_info_volume_changed_ARG_volume, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_volume_changed = +{ + { + -1, + (gchar *) "VolumeChanged", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_volume_changed_ARG_pointers, + NULL + }, + "volume-changed" +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_muteState = +{ + { + -1, + (gchar *) "muteState", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_sinkID, + &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_muteState, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_sink_mute_state_changed = +{ + { + -1, + (gchar *) "SinkMuteStateChanged", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_sink_mute_state_changed_ARG_pointers, + NULL + }, + "sink-mute-state-changed" +}; + +static const _ExtendedGDBusArgInfo _audiomanager_commandinterface_signal_info_system_property_changed_ARG_SystemProperty = +{ + { + -1, + (gchar *) "SystemProperty", + (gchar *) "(nn)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_commandinterface_signal_info_system_property_changed_ARG_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_system_property_changed_ARG_SystemProperty, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_commandinterface_signal_info_system_property_changed = +{ + { + -1, + (gchar *) "SystemPropertyChanged", + (GDBusArgInfo **) &_audiomanager_commandinterface_signal_info_system_property_changed_ARG_pointers, + NULL + }, + "system-property-changed" +}; + +static const _ExtendedGDBusSignalInfo * const _audiomanager_commandinterface_signal_info_pointers[] = +{ + &_audiomanager_commandinterface_signal_info_new_main_connection, + &_audiomanager_commandinterface_signal_info_removed_main_connection, + &_audiomanager_commandinterface_signal_info_main_connection_state_changed, + &_audiomanager_commandinterface_signal_info_volume_changed, + &_audiomanager_commandinterface_signal_info_sink_mute_state_changed, + &_audiomanager_commandinterface_signal_info_system_property_changed, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _audiomanager_commandinterface_interface_info = +{ + { + -1, + (gchar *) "org.genivi.audiomanager.commandinterface", + (GDBusMethodInfo **) &_audiomanager_commandinterface_method_info_pointers, + (GDBusSignalInfo **) &_audiomanager_commandinterface_signal_info_pointers, + NULL, + NULL + }, + "audiomanager-commandinterface", +}; + + +/** + * audiomanager_commandinterface_interface_info: + * + * Gets a machine-readable description of the org.genivi.audiomanager.commandinterface D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +audiomanager_commandinterface_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct; +} + +/** + * audiomanager_commandinterface_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #AudiomanagerCommandinterface interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +audiomanager_commandinterface_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * AudiomanagerCommandinterface: + * + * Abstract interface type for the D-Bus interface org.genivi.audiomanager.commandinterface. + */ + +/** + * AudiomanagerCommandinterfaceIface: + * @parent_iface: The parent interface. + * @handle_connect: Handler for the #AudiomanagerCommandinterface::handle-connect signal. + * @handle_disconnect: Handler for the #AudiomanagerCommandinterface::handle-disconnect signal. + * @handle_get_list_main_connections: Handler for the #AudiomanagerCommandinterface::handle-get-list-main-connections signal. + * @handle_set_sink_mute_state: Handler for the #AudiomanagerCommandinterface::handle-set-sink-mute-state signal. + * @handle_set_volume: Handler for the #AudiomanagerCommandinterface::handle-set-volume signal. + * @handle_volume_step: Handler for the #AudiomanagerCommandinterface::handle-volume-step signal. + * @main_connection_state_changed: Handler for the #AudiomanagerCommandinterface::main-connection-state-changed signal. + * @new_main_connection: Handler for the #AudiomanagerCommandinterface::new-main-connection signal. + * @removed_main_connection: Handler for the #AudiomanagerCommandinterface::removed-main-connection signal. + * @sink_mute_state_changed: Handler for the #AudiomanagerCommandinterface::sink-mute-state-changed signal. + * @system_property_changed: Handler for the #AudiomanagerCommandinterface::system-property-changed signal. + * @volume_changed: Handler for the #AudiomanagerCommandinterface::volume-changed signal. + * + * Virtual table for the D-Bus interface org.genivi.audiomanager.commandinterface. + */ + +typedef AudiomanagerCommandinterfaceIface AudiomanagerCommandinterfaceInterface; +G_DEFINE_INTERFACE (AudiomanagerCommandinterface, audiomanager_commandinterface, G_TYPE_OBJECT); + +static void +audiomanager_commandinterface_default_init (AudiomanagerCommandinterfaceIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * AudiomanagerCommandinterface::handle-connect: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sourceID: Argument passed by remote caller. + * @arg_sinkID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the Connect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_connect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-connect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_connect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerCommandinterface::handle-disconnect: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_mainConnectionID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the Disconnect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_disconnect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-disconnect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_disconnect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerCommandinterface::handle-set-volume: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sinkID: Argument passed by remote caller. + * @arg_volume: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the SetVolume() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_set_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-set-volume", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_set_volume), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::handle-volume-step: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sinkID: Argument passed by remote caller. + * @arg_volumeStep: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the VolumeStep() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_volume_step() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-volume-step", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_volume_step), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::handle-set-sink-mute-state: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sinkID: Argument passed by remote caller. + * @arg_muteState: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the SetSinkMuteState() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_set_sink_mute_state() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-set-sink-mute-state", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_set_sink_mute_state), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::handle-get-list-main-connections: + * @object: A #AudiomanagerCommandinterface. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetListMainConnections() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_commandinterface_complete_get_list_main_connections() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-list-main-connections", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, handle_get_list_main_connections), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /* GObject signals for received D-Bus signals: */ + /** + * AudiomanagerCommandinterface::new-main-connection: + * @object: A #AudiomanagerCommandinterface. + * @arg_mainConnection: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "NewMainConnection" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("new-main-connection", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, new_main_connection), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_VARIANT); + + /** + * AudiomanagerCommandinterface::removed-main-connection: + * @object: A #AudiomanagerCommandinterface. + * @arg_mainConnectionId: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "RemovedMainConnection" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("removed-main-connection", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, removed_main_connection), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_UINT); + + /** + * AudiomanagerCommandinterface::main-connection-state-changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_connectionID: Argument. + * @arg_connectionState: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "MainConnectionStateChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("main-connection-state-changed", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, main_connection_state_changed), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 2, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::volume-changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_sinkID: Argument. + * @arg_volume: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "VolumeChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("volume-changed", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, volume_changed), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 2, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::sink-mute-state-changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_sinkID: Argument. + * @arg_muteState: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "SinkMuteStateChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("sink-mute-state-changed", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, sink_mute_state_changed), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 2, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerCommandinterface::system-property-changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_SystemProperty: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "SystemPropertyChanged" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("system-property-changed", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerCommandinterfaceIface, system_property_changed), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_VARIANT); + +} + +/** + * audiomanager_commandinterface_emit_new_main_connection: + * @object: A #AudiomanagerCommandinterface. + * @arg_mainConnection: Argument to pass with the signal. + * + * Emits the "NewMainConnection" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_new_main_connection ( + AudiomanagerCommandinterface *object, + GVariant *arg_mainConnection) +{ + g_signal_emit_by_name (object, "new-main-connection", arg_mainConnection); +} + +/** + * audiomanager_commandinterface_emit_removed_main_connection: + * @object: A #AudiomanagerCommandinterface. + * @arg_mainConnectionId: Argument to pass with the signal. + * + * Emits the "RemovedMainConnection" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_removed_main_connection ( + AudiomanagerCommandinterface *object, + guint16 arg_mainConnectionId) +{ + g_signal_emit_by_name (object, "removed-main-connection", arg_mainConnectionId); +} + +/** + * audiomanager_commandinterface_emit_main_connection_state_changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_connectionID: Argument to pass with the signal. + * @arg_connectionState: Argument to pass with the signal. + * + * Emits the "MainConnectionStateChanged" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_main_connection_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_connectionID, + gint16 arg_connectionState) +{ + g_signal_emit_by_name (object, "main-connection-state-changed", arg_connectionID, arg_connectionState); +} + +/** + * audiomanager_commandinterface_emit_volume_changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_sinkID: Argument to pass with the signal. + * @arg_volume: Argument to pass with the signal. + * + * Emits the "VolumeChanged" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_volume_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_volume) +{ + g_signal_emit_by_name (object, "volume-changed", arg_sinkID, arg_volume); +} + +/** + * audiomanager_commandinterface_emit_sink_mute_state_changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_sinkID: Argument to pass with the signal. + * @arg_muteState: Argument to pass with the signal. + * + * Emits the "SinkMuteStateChanged" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_sink_mute_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_muteState) +{ + g_signal_emit_by_name (object, "sink-mute-state-changed", arg_sinkID, arg_muteState); +} + +/** + * audiomanager_commandinterface_emit_system_property_changed: + * @object: A #AudiomanagerCommandinterface. + * @arg_SystemProperty: Argument to pass with the signal. + * + * Emits the "SystemPropertyChanged" D-Bus signal. + */ +void +audiomanager_commandinterface_emit_system_property_changed ( + AudiomanagerCommandinterface *object, + GVariant *arg_SystemProperty) +{ + g_signal_emit_by_name (object, "system-property-changed", arg_SystemProperty); +} + +/** + * audiomanager_commandinterface_call_connect: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Connect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_connect_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_connect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_connect ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sourceID, + guint16 arg_sinkID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Connect", + g_variant_new ("(qq)", + arg_sourceID, + arg_sinkID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_connect_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @out_mainConnectionID: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_connect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_connect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_connect_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + guint16 *out_mainConnectionID, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(nq)", + out_result, + out_mainConnectionID); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_connect_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @out_mainConnectionID: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Connect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_connect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_connect_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint16 *out_result, + guint16 *out_mainConnectionID, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Connect", + g_variant_new ("(qq)", + arg_sourceID, + arg_sinkID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(nq)", + out_result, + out_mainConnectionID); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_disconnect: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_mainConnectionID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Disconnect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_disconnect_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_disconnect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_disconnect ( + AudiomanagerCommandinterface *proxy, + guint16 arg_mainConnectionID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Disconnect", + g_variant_new ("(q)", + arg_mainConnectionID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_disconnect_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_disconnect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_disconnect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_disconnect_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_disconnect_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_mainConnectionID: Argument to pass with the method invocation. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Disconnect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_disconnect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_disconnect_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_mainConnectionID, + gint16 *out_result, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Disconnect", + g_variant_new ("(q)", + arg_mainConnectionID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_set_volume: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the SetVolume() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_set_volume_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_set_volume_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_set_volume ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volume, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "SetVolume", + g_variant_new ("(qn)", + arg_sinkID, + arg_volume), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_set_volume_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_set_volume(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_set_volume(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_set_volume_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_set_volume_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the SetVolume() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_set_volume() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_set_volume_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 *out_result, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "SetVolume", + g_variant_new ("(qn)", + arg_sinkID, + arg_volume), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_volume_step: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volumeStep: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the VolumeStep() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_volume_step_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_volume_step_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_volume_step ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volumeStep, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "VolumeStep", + g_variant_new ("(qn)", + arg_sinkID, + arg_volumeStep), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_volume_step_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_volume_step(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_volume_step(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_volume_step_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_volume_step_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volumeStep: Argument to pass with the method invocation. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the VolumeStep() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_volume_step() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_volume_step_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volumeStep, + gint16 *out_result, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "VolumeStep", + g_variant_new ("(qn)", + arg_sinkID, + arg_volumeStep), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_set_sink_mute_state: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_muteState: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the SetSinkMuteState() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_set_sink_mute_state_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_set_sink_mute_state_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_set_sink_mute_state ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_muteState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "SetSinkMuteState", + g_variant_new ("(qn)", + arg_sinkID, + arg_muteState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_set_sink_mute_state_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_set_sink_mute_state(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_set_sink_mute_state(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_set_sink_mute_state_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_set_sink_mute_state_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_muteState: Argument to pass with the method invocation. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the SetSinkMuteState() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_set_sink_mute_state() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_set_sink_mute_state_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_muteState, + gint16 *out_result, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "SetSinkMuteState", + g_variant_new ("(qn)", + arg_sinkID, + arg_muteState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_result); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_get_list_main_connections: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetListMainConnections() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_call_get_list_main_connections_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_call_get_list_main_connections_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_commandinterface_call_get_list_main_connections ( + AudiomanagerCommandinterface *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetListMainConnections", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_commandinterface_call_get_list_main_connections_finish: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @out_listConnections: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_call_get_list_main_connections(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_commandinterface_call_get_list_main_connections(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_get_list_main_connections_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GVariant **out_listConnections, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n@a(qqqnn))", + out_result, + out_listConnections); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_call_get_list_main_connections_sync: + * @proxy: A #AudiomanagerCommandinterfaceProxy. + * @out_result: (out): Return location for return parameter or %NULL to ignore. + * @out_listConnections: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetListMainConnections() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_call_get_list_main_connections() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_commandinterface_call_get_list_main_connections_sync ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GVariant **out_listConnections, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetListMainConnections", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n@a(qqqnn))", + out_result, + out_listConnections); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_commandinterface_complete_connect: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * @mainConnectionID: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the Connect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_connect ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result, + guint16 mainConnectionID) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(nq)", + result, + mainConnectionID)); +} + +/** + * audiomanager_commandinterface_complete_disconnect: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the Disconnect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_disconnect ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n)", + result)); +} + +/** + * audiomanager_commandinterface_complete_set_volume: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the SetVolume() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_set_volume ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n)", + result)); +} + +/** + * audiomanager_commandinterface_complete_volume_step: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the VolumeStep() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_volume_step ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n)", + result)); +} + +/** + * audiomanager_commandinterface_complete_set_sink_mute_state: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the SetSinkMuteState() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_set_sink_mute_state ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n)", + result)); +} + +/** + * audiomanager_commandinterface_complete_get_list_main_connections: + * @object: A #AudiomanagerCommandinterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @result: Parameter to return. + * @listConnections: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetListMainConnections() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_commandinterface_complete_get_list_main_connections ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result, + GVariant *listConnections) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n@a(qqqnn))", + result, + listConnections)); +} + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerCommandinterfaceProxy: + * + * The #AudiomanagerCommandinterfaceProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerCommandinterfaceProxyClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerCommandinterfaceProxy. + */ + +struct _AudiomanagerCommandinterfaceProxyPrivate +{ + GData *qdata; +}; + +static void audiomanager_commandinterface_proxy_iface_init (AudiomanagerCommandinterfaceIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceProxy, audiomanager_commandinterface_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (AudiomanagerCommandinterfaceProxy) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceProxy, audiomanager_commandinterface_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_proxy_iface_init)); + +#endif +static void +audiomanager_commandinterface_proxy_finalize (GObject *object) +{ + AudiomanagerCommandinterfaceProxy *proxy = AUDIOMANAGER_COMMANDINTERFACE_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (audiomanager_commandinterface_proxy_parent_class)->finalize (object); +} + +static void +audiomanager_commandinterface_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_commandinterface_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_commandinterface_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_AUDIOMANAGER_COMMANDINTERFACE); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_COMMANDINTERFACE); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +audiomanager_commandinterface_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + AudiomanagerCommandinterfaceProxy *proxy = AUDIOMANAGER_COMMANDINTERFACE_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +audiomanager_commandinterface_proxy_init (AudiomanagerCommandinterfaceProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = audiomanager_commandinterface_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_commandinterface_interface_info ()); +} + +static void +audiomanager_commandinterface_proxy_class_init (AudiomanagerCommandinterfaceProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_commandinterface_proxy_finalize; + gobject_class->get_property = audiomanager_commandinterface_proxy_get_property; + gobject_class->set_property = audiomanager_commandinterface_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = audiomanager_commandinterface_proxy_g_signal; + proxy_class->g_properties_changed = audiomanager_commandinterface_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerCommandinterfaceProxyPrivate)); +#endif +} + +static void +audiomanager_commandinterface_proxy_iface_init (AudiomanagerCommandinterfaceIface *iface) +{ +} + +/** + * audiomanager_commandinterface_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.commandinterface. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_proxy_new_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_commandinterface_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL); +} + +/** + * audiomanager_commandinterface_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_commandinterface_proxy_new(). + * + * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerCommandinterface * +audiomanager_commandinterface_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_COMMANDINTERFACE (ret); + else + return NULL; +} + +/** + * audiomanager_commandinterface_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.commandinterface. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerCommandinterface * +audiomanager_commandinterface_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL); + if (ret != NULL) + return AUDIOMANAGER_COMMANDINTERFACE (ret); + else + return NULL; +} + + +/** + * audiomanager_commandinterface_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like audiomanager_commandinterface_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_commandinterface_proxy_new_for_bus_finish() to get the result of the operation. + * + * See audiomanager_commandinterface_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_commandinterface_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL); +} + +/** + * audiomanager_commandinterface_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_commandinterface_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_commandinterface_proxy_new_for_bus(). + * + * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerCommandinterface * +audiomanager_commandinterface_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_COMMANDINTERFACE (ret); + else + return NULL; +} + +/** + * audiomanager_commandinterface_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like audiomanager_commandinterface_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_commandinterface_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerCommandinterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerCommandinterface * +audiomanager_commandinterface_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.commandinterface", NULL); + if (ret != NULL) + return AUDIOMANAGER_COMMANDINTERFACE (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerCommandinterfaceSkeleton: + * + * The #AudiomanagerCommandinterfaceSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerCommandinterfaceSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerCommandinterfaceSkeleton. + */ + +struct _AudiomanagerCommandinterfaceSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_audiomanager_commandinterface_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_AUDIOMANAGER_COMMANDINTERFACE); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_COMMANDINTERFACE); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_audiomanager_commandinterface_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_audiomanager_commandinterface_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_commandinterface_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _audiomanager_commandinterface_skeleton_vtable = +{ + _audiomanager_commandinterface_skeleton_handle_method_call, + _audiomanager_commandinterface_skeleton_handle_get_property, + _audiomanager_commandinterface_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +audiomanager_commandinterface_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return audiomanager_commandinterface_interface_info (); +} + +static GDBusInterfaceVTable * +audiomanager_commandinterface_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_audiomanager_commandinterface_skeleton_vtable; +} + +static GVariant * +audiomanager_commandinterface_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_audiomanager_commandinterface_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _audiomanager_commandinterface_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _audiomanager_commandinterface_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _audiomanager_commandinterface_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +audiomanager_commandinterface_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void +_audiomanager_commandinterface_on_signal_new_main_connection ( + AudiomanagerCommandinterface *object, + GVariant *arg_mainConnection) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(@(qqqnn))", + arg_mainConnection)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "NewMainConnection", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_commandinterface_on_signal_removed_main_connection ( + AudiomanagerCommandinterface *object, + guint16 arg_mainConnectionId) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(q)", + arg_mainConnectionId)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "RemovedMainConnection", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_commandinterface_on_signal_main_connection_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_connectionID, + gint16 arg_connectionState) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(qn)", + arg_connectionID, + arg_connectionState)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "MainConnectionStateChanged", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_commandinterface_on_signal_volume_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_volume) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(qn)", + arg_sinkID, + arg_volume)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "VolumeChanged", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_commandinterface_on_signal_sink_mute_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_muteState) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(qn)", + arg_sinkID, + arg_muteState)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "SinkMuteStateChanged", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_commandinterface_on_signal_system_property_changed ( + AudiomanagerCommandinterface *object, + GVariant *arg_SystemProperty) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(@(nn))", + arg_SystemProperty)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.commandinterface", "SystemPropertyChanged", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void audiomanager_commandinterface_skeleton_iface_init (AudiomanagerCommandinterfaceIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceSkeleton, audiomanager_commandinterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (AudiomanagerCommandinterfaceSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerCommandinterfaceSkeleton, audiomanager_commandinterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_COMMANDINTERFACE, audiomanager_commandinterface_skeleton_iface_init)); + +#endif +static void +audiomanager_commandinterface_skeleton_finalize (GObject *object) +{ + AudiomanagerCommandinterfaceSkeleton *skeleton = AUDIOMANAGER_COMMANDINTERFACE_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (audiomanager_commandinterface_skeleton_parent_class)->finalize (object); +} + +static void +audiomanager_commandinterface_skeleton_init (AudiomanagerCommandinterfaceSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = audiomanager_commandinterface_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +audiomanager_commandinterface_skeleton_class_init (AudiomanagerCommandinterfaceSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_commandinterface_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = audiomanager_commandinterface_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = audiomanager_commandinterface_skeleton_dbus_interface_get_properties; + skeleton_class->flush = audiomanager_commandinterface_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = audiomanager_commandinterface_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerCommandinterfaceSkeletonPrivate)); +#endif +} + +static void +audiomanager_commandinterface_skeleton_iface_init (AudiomanagerCommandinterfaceIface *iface) +{ + iface->new_main_connection = _audiomanager_commandinterface_on_signal_new_main_connection; + iface->removed_main_connection = _audiomanager_commandinterface_on_signal_removed_main_connection; + iface->main_connection_state_changed = _audiomanager_commandinterface_on_signal_main_connection_state_changed; + iface->volume_changed = _audiomanager_commandinterface_on_signal_volume_changed; + iface->sink_mute_state_changed = _audiomanager_commandinterface_on_signal_sink_mute_state_changed; + iface->system_property_changed = _audiomanager_commandinterface_on_signal_system_property_changed; +} + +/** + * audiomanager_commandinterface_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.genivi.audiomanager.commandinterface. + * + * Returns: (transfer full) (type AudiomanagerCommandinterfaceSkeleton): The skeleton object. + */ +AudiomanagerCommandinterface * +audiomanager_commandinterface_skeleton_new (void) +{ + return AUDIOMANAGER_COMMANDINTERFACE (g_object_new (TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for interface org.genivi.audiomanager.routinginterface + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:AudiomanagerRoutinginterface + * @title: AudiomanagerRoutinginterface + * @short_description: Generated C code for the org.genivi.audiomanager.routinginterface D-Bus interface + * + * This section contains code for working with the org.genivi.audiomanager.routinginterface D-Bus interface in C. + */ + +/* ---- Introspection data for org.genivi.audiomanager.routinginterface ---- */ + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_connectionID = +{ + { + -1, + (gchar *) "connectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_connect_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_connectionID, + &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_connect = +{ + { + -1, + (gchar *) "ackConnect", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_connect_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-connect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_connectionID = +{ + { + -1, + (gchar *) "connectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_connectionID, + &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_disconnect = +{ + { + -1, + (gchar *) "ackDisconnect", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_disconnect_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-disconnect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_source_state = +{ + { + -1, + (gchar *) "ackSetSourceState", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_source_state_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-set-source-state", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_volume = +{ + { + -1, + (gchar *) "volume", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_volume, + &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_sink_volume = +{ + { + -1, + (gchar *) "ackSetSinkVolume", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_sink_volume_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-set-sink-volume", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_IN_ARG_sinkData = +{ + { + -1, + (gchar *) "sinkData", + (gchar *) "(qsqinb(ii)nna(in)aia(in)a(iin)a(iin))", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_sink_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_sink_IN_ARG_sinkData, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_sink_OUT_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_sinkID, + &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_sink = +{ + { + -1, + (gchar *) "registerSink", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_sink_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_sink_OUT_ARG_pointers, + NULL + }, + "handle-register-sink", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_sinkID, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "i", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_deregister_sink = +{ + { + -1, + (gchar *) "deregisterSink", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_sink_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_sink_OUT_ARG_pointers, + NULL + }, + "handle-deregister-sink", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_IN_ARG_sourceData = +{ + { + -1, + (gchar *) "sourceData", + (gchar *) "(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin))", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_source_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_source_IN_ARG_sourceData, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_OUT_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_source_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_source_OUT_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_sourceID, + &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_source = +{ + { + -1, + (gchar *) "registerSource", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_source_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_source_OUT_ARG_pointers, + NULL + }, + "handle-register-source", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_source_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_source_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_deregister_source_IN_ARG_sourceID, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_deregister_source = +{ + { + -1, + (gchar *) "deregisterSource", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_source_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_deregister_source_OUT_ARG_pointers, + NULL + }, + "handle-deregister-source", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_interruptState = +{ + { + -1, + (gchar *) "interruptState", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_sourceID, + &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_interruptState, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_hook_interrupt_status_change = +{ + { + -1, + (gchar *) "hookInterruptStatusChange", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_hook_interrupt_status_change_IN_ARG_pointers, + NULL, + NULL + }, + "handle-hook-interrupt-status-change", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_availability = +{ + { + -1, + (gchar *) "availability", + (gchar *) "(nn)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_sourceID, + &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_availability, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_hook_source_availablity_status_change = +{ + { + -1, + (gchar *) "hookSourceAvailablityStatusChange", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change_IN_ARG_pointers, + NULL, + NULL + }, + "handle-hook-source-availablity-status-change", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_domainID = +{ + { + -1, + (gchar *) "domainID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_domainID, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_confirm_routing_ready = +{ + { + -1, + (gchar *) "confirmRoutingReady", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_confirm_routing_ready_IN_ARG_pointers, + NULL, + NULL + }, + "handle-confirm-routing-ready", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_domainID = +{ + { + -1, + (gchar *) "domainID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_domainID, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_confirm_routing_rundown = +{ + { + -1, + (gchar *) "confirmRoutingRundown", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_confirm_routing_rundown_IN_ARG_pointers, + NULL, + NULL + }, + "handle-confirm-routing-rundown", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_listvolumes = +{ + { + -1, + (gchar *) "listvolumes", + (gchar *) "a(nqqnq)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_listvolumes, + &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_set_volumes = +{ + { + -1, + (gchar *) "ackSetVolumes", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_set_volumes_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-set-volumes", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_sink_notification_configuration = +{ + { + -1, + (gchar *) "ackSinkNotificationConfiguration", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-sink-notification-configuration", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_handle, + &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_ack_source_notification_configuration = +{ + { + -1, + (gchar *) "ackSourceNotificationConfiguration", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_ack_source_notification_configuration_IN_ARG_pointers, + NULL, + NULL + }, + "handle-ack-source-notification-configuration", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_domaindata = +{ + { + -1, + (gchar *) "domaindata", + (gchar *) "(qsssbbn)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnBusname = +{ + { + -1, + (gchar *) "returnBusname", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnPath = +{ + { + -1, + (gchar *) "returnPath", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnInterface = +{ + { + -1, + (gchar *) "returnInterface", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_domain_IN_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_domaindata, + &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnBusname, + &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnPath, + &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_returnInterface, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_domainid = +{ + { + -1, + (gchar *) "domainid", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routinginterface_method_info_register_domain_OUT_ARG_pointers[] = +{ + &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_domainid, + &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routinginterface_method_info_register_domain = +{ + { + -1, + (gchar *) "registerDomain", + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_domain_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routinginterface_method_info_register_domain_OUT_ARG_pointers, + NULL + }, + "handle-register-domain", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _audiomanager_routinginterface_method_info_pointers[] = +{ + &_audiomanager_routinginterface_method_info_ack_connect, + &_audiomanager_routinginterface_method_info_ack_disconnect, + &_audiomanager_routinginterface_method_info_ack_set_source_state, + &_audiomanager_routinginterface_method_info_ack_set_sink_volume, + &_audiomanager_routinginterface_method_info_register_sink, + &_audiomanager_routinginterface_method_info_deregister_sink, + &_audiomanager_routinginterface_method_info_register_source, + &_audiomanager_routinginterface_method_info_deregister_source, + &_audiomanager_routinginterface_method_info_hook_interrupt_status_change, + &_audiomanager_routinginterface_method_info_hook_source_availablity_status_change, + &_audiomanager_routinginterface_method_info_confirm_routing_ready, + &_audiomanager_routinginterface_method_info_confirm_routing_rundown, + &_audiomanager_routinginterface_method_info_ack_set_volumes, + &_audiomanager_routinginterface_method_info_ack_sink_notification_configuration, + &_audiomanager_routinginterface_method_info_ack_source_notification_configuration, + &_audiomanager_routinginterface_method_info_register_domain, + NULL +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_routinginterface_signal_info_set_routing_ready = +{ + { + -1, + (gchar *) "setRoutingReady", + NULL, + NULL + }, + "set-routing-ready" +}; + +static const _ExtendedGDBusSignalInfo _audiomanager_routinginterface_signal_info_set_routing_rundown = +{ + { + -1, + (gchar *) "setRoutingRundown", + NULL, + NULL + }, + "set-routing-rundown" +}; + +static const _ExtendedGDBusSignalInfo * const _audiomanager_routinginterface_signal_info_pointers[] = +{ + &_audiomanager_routinginterface_signal_info_set_routing_ready, + &_audiomanager_routinginterface_signal_info_set_routing_rundown, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _audiomanager_routinginterface_interface_info = +{ + { + -1, + (gchar *) "org.genivi.audiomanager.routinginterface", + (GDBusMethodInfo **) &_audiomanager_routinginterface_method_info_pointers, + (GDBusSignalInfo **) &_audiomanager_routinginterface_signal_info_pointers, + NULL, + NULL + }, + "audiomanager-routinginterface", +}; + + +/** + * audiomanager_routinginterface_interface_info: + * + * Gets a machine-readable description of the org.genivi.audiomanager.routinginterface D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +audiomanager_routinginterface_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct; +} + +/** + * audiomanager_routinginterface_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #AudiomanagerRoutinginterface interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +audiomanager_routinginterface_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * AudiomanagerRoutinginterface: + * + * Abstract interface type for the D-Bus interface org.genivi.audiomanager.routinginterface. + */ + +/** + * AudiomanagerRoutinginterfaceIface: + * @parent_iface: The parent interface. + * @handle_ack_connect: Handler for the #AudiomanagerRoutinginterface::handle-ack-connect signal. + * @handle_ack_disconnect: Handler for the #AudiomanagerRoutinginterface::handle-ack-disconnect signal. + * @handle_ack_set_sink_volume: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-sink-volume signal. + * @handle_ack_set_source_state: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-source-state signal. + * @handle_ack_set_volumes: Handler for the #AudiomanagerRoutinginterface::handle-ack-set-volumes signal. + * @handle_ack_sink_notification_configuration: Handler for the #AudiomanagerRoutinginterface::handle-ack-sink-notification-configuration signal. + * @handle_ack_source_notification_configuration: Handler for the #AudiomanagerRoutinginterface::handle-ack-source-notification-configuration signal. + * @handle_confirm_routing_ready: Handler for the #AudiomanagerRoutinginterface::handle-confirm-routing-ready signal. + * @handle_confirm_routing_rundown: Handler for the #AudiomanagerRoutinginterface::handle-confirm-routing-rundown signal. + * @handle_deregister_sink: Handler for the #AudiomanagerRoutinginterface::handle-deregister-sink signal. + * @handle_deregister_source: Handler for the #AudiomanagerRoutinginterface::handle-deregister-source signal. + * @handle_hook_interrupt_status_change: Handler for the #AudiomanagerRoutinginterface::handle-hook-interrupt-status-change signal. + * @handle_hook_source_availablity_status_change: Handler for the #AudiomanagerRoutinginterface::handle-hook-source-availablity-status-change signal. + * @handle_register_domain: Handler for the #AudiomanagerRoutinginterface::handle-register-domain signal. + * @handle_register_sink: Handler for the #AudiomanagerRoutinginterface::handle-register-sink signal. + * @handle_register_source: Handler for the #AudiomanagerRoutinginterface::handle-register-source signal. + * @set_routing_ready: Handler for the #AudiomanagerRoutinginterface::set-routing-ready signal. + * @set_routing_rundown: Handler for the #AudiomanagerRoutinginterface::set-routing-rundown signal. + * + * Virtual table for the D-Bus interface org.genivi.audiomanager.routinginterface. + */ + +typedef AudiomanagerRoutinginterfaceIface AudiomanagerRoutinginterfaceInterface; +G_DEFINE_INTERFACE (AudiomanagerRoutinginterface, audiomanager_routinginterface, G_TYPE_OBJECT); + +static void +audiomanager_routinginterface_default_init (AudiomanagerRoutinginterfaceIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * AudiomanagerRoutinginterface::handle-ack-connect: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_connectionID: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackConnect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_connect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-connect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_connect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-disconnect: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_connectionID: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackDisconnect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_disconnect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-disconnect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_disconnect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-set-source-state: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackSetSourceState() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_set_source_state() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-set-source-state", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_source_state), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-set-sink-volume: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_volume: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackSetSinkVolume() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_set_sink_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-set-sink-volume", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_sink_volume), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_INT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-register-sink: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sinkData: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the registerSink() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_register_sink() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-register-sink", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_sink), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT); + + /** + * AudiomanagerRoutinginterface::handle-deregister-sink: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sinkID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the deregisterSink() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_deregister_sink() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-deregister-sink", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_deregister_sink), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-register-source: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sourceData: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the registerSource() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_register_source() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-register-source", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_source), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT); + + /** + * AudiomanagerRoutinginterface::handle-deregister-source: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sourceID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the deregisterSource() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_deregister_source() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-deregister-source", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_deregister_source), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-hook-interrupt-status-change: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sourceID: Argument passed by remote caller. + * @arg_interruptState: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the hookInterruptStatusChange() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_hook_interrupt_status_change() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-hook-interrupt-status-change", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_hook_interrupt_status_change), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-hook-source-availablity-status-change: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_sourceID: Argument passed by remote caller. + * @arg_availability: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the hookSourceAvailablityStatusChange() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_hook_source_availablity_status_change() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-hook-source-availablity-status-change", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_hook_source_availablity_status_change), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT); + + /** + * AudiomanagerRoutinginterface::handle-confirm-routing-ready: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_domainID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the confirmRoutingReady() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_confirm_routing_ready() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-confirm-routing-ready", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_confirm_routing_ready), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-confirm-routing-rundown: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_domainID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the confirmRoutingRundown() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_confirm_routing_rundown() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-confirm-routing-rundown", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_confirm_routing_rundown), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-set-volumes: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_listvolumes: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackSetVolumes() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_set_volumes() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-set-volumes", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_set_volumes), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-sink-notification-configuration: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackSinkNotificationConfiguration() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_sink_notification_configuration() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-sink-notification-configuration", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_sink_notification_configuration), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-ack-source-notification-configuration: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_error: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ackSourceNotificationConfiguration() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_ack_source_notification_configuration() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-ack-source-notification-configuration", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_ack_source_notification_configuration), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutinginterface::handle-register-domain: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: A #GDBusMethodInvocation. + * @arg_domaindata: Argument passed by remote caller. + * @arg_returnBusname: Argument passed by remote caller. + * @arg_returnPath: Argument passed by remote caller. + * @arg_returnInterface: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the registerDomain() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routinginterface_complete_register_domain() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-register-domain", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, handle_register_domain), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 5, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + + /* GObject signals for received D-Bus signals: */ + /** + * AudiomanagerRoutinginterface::set-routing-ready: + * @object: A #AudiomanagerRoutinginterface. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "setRoutingReady" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("set-routing-ready", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, set_routing_ready), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 0); + + /** + * AudiomanagerRoutinginterface::set-routing-rundown: + * @object: A #AudiomanagerRoutinginterface. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "setRoutingRundown" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("set-routing-rundown", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutinginterfaceIface, set_routing_rundown), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 0); + +} + +/** + * audiomanager_routinginterface_emit_set_routing_ready: + * @object: A #AudiomanagerRoutinginterface. + * + * Emits the "setRoutingReady" D-Bus signal. + */ +void +audiomanager_routinginterface_emit_set_routing_ready ( + AudiomanagerRoutinginterface *object) +{ + g_signal_emit_by_name (object, "set-routing-ready"); +} + +/** + * audiomanager_routinginterface_emit_set_routing_rundown: + * @object: A #AudiomanagerRoutinginterface. + * + * Emits the "setRoutingRundown" D-Bus signal. + */ +void +audiomanager_routinginterface_emit_set_routing_rundown ( + AudiomanagerRoutinginterface *object) +{ + g_signal_emit_by_name (object, "set-routing-rundown"); +} + +/** + * audiomanager_routinginterface_call_ack_connect: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackConnect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_connect_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_connect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_connect ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackConnect", + g_variant_new ("(qqq)", + arg_handle, + arg_connectionID, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_connect_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_connect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_connect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_connect_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_connect_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackConnect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_connect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_connect_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackConnect", + g_variant_new ("(qqq)", + arg_handle, + arg_connectionID, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_disconnect: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackDisconnect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_disconnect_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_disconnect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_disconnect ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackDisconnect", + g_variant_new ("(qqq)", + arg_handle, + arg_connectionID, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_disconnect_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_disconnect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_disconnect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_disconnect_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_disconnect_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackDisconnect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_disconnect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_disconnect_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackDisconnect", + g_variant_new ("(qqq)", + arg_handle, + arg_connectionID, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_source_state: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackSetSourceState() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_set_source_state_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_set_source_state_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_set_source_state ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackSetSourceState", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_set_source_state_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_source_state(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_set_source_state(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_source_state_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_source_state_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackSetSourceState() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_set_source_state() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_source_state_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackSetSourceState", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_sink_volume: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackSetSinkVolume() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_set_sink_volume_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_set_sink_volume_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_set_sink_volume ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + gint16 arg_volume, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackSetSinkVolume", + g_variant_new ("(qnq)", + arg_handle, + arg_volume, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_set_sink_volume_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_sink_volume(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_set_sink_volume(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_sink_volume_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_sink_volume_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackSetSinkVolume() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_set_sink_volume() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_sink_volume_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + gint16 arg_volume, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackSetSinkVolume", + g_variant_new ("(qnq)", + arg_handle, + arg_volume, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_sink: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sinkData: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the registerSink() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_register_sink_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_register_sink_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_register_sink ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sinkData, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "registerSink", + g_variant_new ("(@(qsqinb(ii)nna(in)aia(in)a(iin)a(iin)))", + arg_sinkData), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_register_sink_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @out_sinkID: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_sink(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_register_sink(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_sink_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_sinkID, + guint16 *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_sinkID, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_sink_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sinkData: Argument to pass with the method invocation. + * @out_sinkID: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the registerSink() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_register_sink() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_sink_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sinkData, + guint16 *out_sinkID, + guint16 *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "registerSink", + g_variant_new ("(@(qsqinb(ii)nna(in)aia(in)a(iin)a(iin)))", + arg_sinkData), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_sinkID, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_deregister_sink: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the deregisterSink() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_deregister_sink_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_deregister_sink_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_deregister_sink ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sinkID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "deregisterSink", + g_variant_new ("(q)", + arg_sinkID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_deregister_sink_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_deregister_sink(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_deregister_sink(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_deregister_sink_finish ( + AudiomanagerRoutinginterface *proxy, + gint *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(i)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_deregister_sink_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sinkID: Argument to pass with the method invocation. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the deregisterSink() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_deregister_sink() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_deregister_sink_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sinkID, + gint *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "deregisterSink", + g_variant_new ("(q)", + arg_sinkID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(i)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_source: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceData: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the registerSource() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_register_source_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_register_source_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_register_source ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sourceData, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "registerSource", + g_variant_new ("(@(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin)))", + arg_sourceData), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_register_source_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @out_sourceID: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_source(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_register_source(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_source_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_sourceID, + guint16 *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_sourceID, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_source_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceData: Argument to pass with the method invocation. + * @out_sourceID: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the registerSource() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_register_source() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_source_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sourceData, + guint16 *out_sourceID, + guint16 *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "registerSource", + g_variant_new ("(@(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin)))", + arg_sourceData), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_sourceID, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_deregister_source: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the deregisterSource() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_deregister_source_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_deregister_source_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_deregister_source ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "deregisterSource", + g_variant_new ("(q)", + arg_sourceID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_deregister_source_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_deregister_source(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_deregister_source(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_deregister_source_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(q)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_deregister_source_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the deregisterSource() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_deregister_source() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_deregister_source_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "deregisterSource", + g_variant_new ("(q)", + arg_sourceID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(q)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_hook_interrupt_status_change: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_interruptState: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the hookInterruptStatusChange() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_hook_interrupt_status_change_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_hook_interrupt_status_change_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_hook_interrupt_status_change ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 arg_interruptState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "hookInterruptStatusChange", + g_variant_new ("(qq)", + arg_sourceID, + arg_interruptState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_hook_interrupt_status_change_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_hook_interrupt_status_change(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_hook_interrupt_status_change(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_hook_interrupt_status_change_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_hook_interrupt_status_change_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_interruptState: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the hookInterruptStatusChange() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_hook_interrupt_status_change() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_hook_interrupt_status_change_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 arg_interruptState, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "hookInterruptStatusChange", + g_variant_new ("(qq)", + arg_sourceID, + arg_interruptState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_hook_source_availablity_status_change: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_availability: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the hookSourceAvailablityStatusChange() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_hook_source_availablity_status_change_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_hook_source_availablity_status_change_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_hook_source_availablity_status_change ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GVariant *arg_availability, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "hookSourceAvailablityStatusChange", + g_variant_new ("(q@(nn))", + arg_sourceID, + arg_availability), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_hook_source_availablity_status_change_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_hook_source_availablity_status_change(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_hook_source_availablity_status_change(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_hook_source_availablity_status_change_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_hook_source_availablity_status_change_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_availability: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the hookSourceAvailablityStatusChange() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_hook_source_availablity_status_change() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_hook_source_availablity_status_change_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GVariant *arg_availability, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "hookSourceAvailablityStatusChange", + g_variant_new ("(q@(nn))", + arg_sourceID, + arg_availability), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_confirm_routing_ready: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domainID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the confirmRoutingReady() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_confirm_routing_ready_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_confirm_routing_ready_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_confirm_routing_ready ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "confirmRoutingReady", + g_variant_new ("(q)", + arg_domainID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_confirm_routing_ready_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_confirm_routing_ready(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_confirm_routing_ready(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_confirm_routing_ready_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_confirm_routing_ready_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domainID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the confirmRoutingReady() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_confirm_routing_ready() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_confirm_routing_ready_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "confirmRoutingReady", + g_variant_new ("(q)", + arg_domainID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_confirm_routing_rundown: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domainID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the confirmRoutingRundown() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_confirm_routing_rundown_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_confirm_routing_rundown_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_confirm_routing_rundown ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "confirmRoutingRundown", + g_variant_new ("(q)", + arg_domainID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_confirm_routing_rundown_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_confirm_routing_rundown(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_confirm_routing_rundown(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_confirm_routing_rundown_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_confirm_routing_rundown_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domainID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the confirmRoutingRundown() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_confirm_routing_rundown() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_confirm_routing_rundown_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "confirmRoutingRundown", + g_variant_new ("(q)", + arg_domainID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_volumes: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_listvolumes: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackSetVolumes() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_set_volumes_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_set_volumes_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_set_volumes ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + GVariant *arg_listvolumes, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackSetVolumes", + g_variant_new ("(q@a(nqqnq)q)", + arg_handle, + arg_listvolumes, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_set_volumes_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_set_volumes(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_set_volumes(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_volumes_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_set_volumes_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_listvolumes: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackSetVolumes() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_set_volumes() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_set_volumes_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + GVariant *arg_listvolumes, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackSetVolumes", + g_variant_new ("(q@a(nqqnq)q)", + arg_handle, + arg_listvolumes, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_sink_notification_configuration: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackSinkNotificationConfiguration() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_sink_notification_configuration_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_sink_notification_configuration_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_sink_notification_configuration ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackSinkNotificationConfiguration", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_sink_notification_configuration_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_sink_notification_configuration(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_sink_notification_configuration(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_sink_notification_configuration_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_sink_notification_configuration_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackSinkNotificationConfiguration() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_sink_notification_configuration() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_sink_notification_configuration_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackSinkNotificationConfiguration", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_source_notification_configuration: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ackSourceNotificationConfiguration() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_ack_source_notification_configuration_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_ack_source_notification_configuration_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_ack_source_notification_configuration ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ackSourceNotificationConfiguration", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_ack_source_notification_configuration_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_ack_source_notification_configuration(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_ack_source_notification_configuration(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_source_notification_configuration_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_ack_source_notification_configuration_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_error: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ackSourceNotificationConfiguration() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_ack_source_notification_configuration() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_ack_source_notification_configuration_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ackSourceNotificationConfiguration", + g_variant_new ("(qq)", + arg_handle, + arg_error), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_domain: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domaindata: Argument to pass with the method invocation. + * @arg_returnBusname: Argument to pass with the method invocation. + * @arg_returnPath: Argument to pass with the method invocation. + * @arg_returnInterface: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the registerDomain() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_call_register_domain_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_call_register_domain_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routinginterface_call_register_domain ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_domaindata, + const gchar *arg_returnBusname, + const gchar *arg_returnPath, + const gchar *arg_returnInterface, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "registerDomain", + g_variant_new ("(@(qsssbbn)sss)", + arg_domaindata, + arg_returnBusname, + arg_returnPath, + arg_returnInterface), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routinginterface_call_register_domain_finish: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @out_domainid: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_call_register_domain(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routinginterface_call_register_domain(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_domain_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_domainid, + guint16 *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_domainid, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_call_register_domain_sync: + * @proxy: A #AudiomanagerRoutinginterfaceProxy. + * @arg_domaindata: Argument to pass with the method invocation. + * @arg_returnBusname: Argument to pass with the method invocation. + * @arg_returnPath: Argument to pass with the method invocation. + * @arg_returnInterface: Argument to pass with the method invocation. + * @out_domainid: (out): Return location for return parameter or %NULL to ignore. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the registerDomain() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_call_register_domain() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routinginterface_call_register_domain_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_domaindata, + const gchar *arg_returnBusname, + const gchar *arg_returnPath, + const gchar *arg_returnInterface, + guint16 *out_domainid, + guint16 *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "registerDomain", + g_variant_new ("(@(qsssbbn)sss)", + arg_domaindata, + arg_returnBusname, + arg_returnPath, + arg_returnInterface), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(qq)", + out_domainid, + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routinginterface_complete_ack_connect: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackConnect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_connect ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_disconnect: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackDisconnect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_disconnect ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_set_source_state: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackSetSourceState() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_set_source_state ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_set_sink_volume: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackSetSinkVolume() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_set_sink_volume ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_register_sink: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @sinkID: Parameter to return. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the registerSink() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_register_sink ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 sinkID, + guint16 error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(qq)", + sinkID, + error)); +} + +/** + * audiomanager_routinginterface_complete_deregister_sink: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the deregisterSink() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_deregister_sink ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + gint error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(i)", + error)); +} + +/** + * audiomanager_routinginterface_complete_register_source: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @sourceID: Parameter to return. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the registerSource() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_register_source ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 sourceID, + guint16 error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(qq)", + sourceID, + error)); +} + +/** + * audiomanager_routinginterface_complete_deregister_source: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the deregisterSource() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_deregister_source ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(q)", + error)); +} + +/** + * audiomanager_routinginterface_complete_hook_interrupt_status_change: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the hookInterruptStatusChange() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_hook_interrupt_status_change ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_hook_source_availablity_status_change: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the hookSourceAvailablityStatusChange() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_hook_source_availablity_status_change ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_confirm_routing_ready: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the confirmRoutingReady() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_confirm_routing_ready ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_confirm_routing_rundown: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the confirmRoutingRundown() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_confirm_routing_rundown ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_set_volumes: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackSetVolumes() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_set_volumes ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_sink_notification_configuration: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackSinkNotificationConfiguration() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_sink_notification_configuration ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_ack_source_notification_configuration: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the ackSourceNotificationConfiguration() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_ack_source_notification_configuration ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routinginterface_complete_register_domain: + * @object: A #AudiomanagerRoutinginterface. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @domainid: Parameter to return. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the registerDomain() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routinginterface_complete_register_domain ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 domainid, + guint16 error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(qq)", + domainid, + error)); +} + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerRoutinginterfaceProxy: + * + * The #AudiomanagerRoutinginterfaceProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerRoutinginterfaceProxyClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerRoutinginterfaceProxy. + */ + +struct _AudiomanagerRoutinginterfaceProxyPrivate +{ + GData *qdata; +}; + +static void audiomanager_routinginterface_proxy_iface_init (AudiomanagerRoutinginterfaceIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceProxy, audiomanager_routinginterface_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (AudiomanagerRoutinginterfaceProxy) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceProxy, audiomanager_routinginterface_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_proxy_iface_init)); + +#endif +static void +audiomanager_routinginterface_proxy_finalize (GObject *object) +{ + AudiomanagerRoutinginterfaceProxy *proxy = AUDIOMANAGER_ROUTINGINTERFACE_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (audiomanager_routinginterface_proxy_parent_class)->finalize (object); +} + +static void +audiomanager_routinginterface_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_routinginterface_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_routinginterface_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_AUDIOMANAGER_ROUTINGINTERFACE); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTINGINTERFACE); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +audiomanager_routinginterface_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + AudiomanagerRoutinginterfaceProxy *proxy = AUDIOMANAGER_ROUTINGINTERFACE_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +audiomanager_routinginterface_proxy_init (AudiomanagerRoutinginterfaceProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = audiomanager_routinginterface_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_routinginterface_interface_info ()); +} + +static void +audiomanager_routinginterface_proxy_class_init (AudiomanagerRoutinginterfaceProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_routinginterface_proxy_finalize; + gobject_class->get_property = audiomanager_routinginterface_proxy_get_property; + gobject_class->set_property = audiomanager_routinginterface_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = audiomanager_routinginterface_proxy_g_signal; + proxy_class->g_properties_changed = audiomanager_routinginterface_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerRoutinginterfaceProxyPrivate)); +#endif +} + +static void +audiomanager_routinginterface_proxy_iface_init (AudiomanagerRoutinginterfaceIface *iface) +{ +} + +/** + * audiomanager_routinginterface_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.routinginterface. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_proxy_new_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_routinginterface_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL); +} + +/** + * audiomanager_routinginterface_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_routinginterface_proxy_new(). + * + * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutinginterface * +audiomanager_routinginterface_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_ROUTINGINTERFACE (ret); + else + return NULL; +} + +/** + * audiomanager_routinginterface_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.routinginterface. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutinginterface * +audiomanager_routinginterface_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL); + if (ret != NULL) + return AUDIOMANAGER_ROUTINGINTERFACE (ret); + else + return NULL; +} + + +/** + * audiomanager_routinginterface_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like audiomanager_routinginterface_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routinginterface_proxy_new_for_bus_finish() to get the result of the operation. + * + * See audiomanager_routinginterface_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_routinginterface_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL); +} + +/** + * audiomanager_routinginterface_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routinginterface_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_routinginterface_proxy_new_for_bus(). + * + * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutinginterface * +audiomanager_routinginterface_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_ROUTINGINTERFACE (ret); + else + return NULL; +} + +/** + * audiomanager_routinginterface_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like audiomanager_routinginterface_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_routinginterface_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerRoutinginterfaceProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutinginterface * +audiomanager_routinginterface_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routinginterface", NULL); + if (ret != NULL) + return AUDIOMANAGER_ROUTINGINTERFACE (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerRoutinginterfaceSkeleton: + * + * The #AudiomanagerRoutinginterfaceSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerRoutinginterfaceSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerRoutinginterfaceSkeleton. + */ + +struct _AudiomanagerRoutinginterfaceSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_audiomanager_routinginterface_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_AUDIOMANAGER_ROUTINGINTERFACE); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTINGINTERFACE); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_audiomanager_routinginterface_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_audiomanager_routinginterface_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routinginterface_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _audiomanager_routinginterface_skeleton_vtable = +{ + _audiomanager_routinginterface_skeleton_handle_method_call, + _audiomanager_routinginterface_skeleton_handle_get_property, + _audiomanager_routinginterface_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +audiomanager_routinginterface_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return audiomanager_routinginterface_interface_info (); +} + +static GDBusInterfaceVTable * +audiomanager_routinginterface_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_audiomanager_routinginterface_skeleton_vtable; +} + +static GVariant * +audiomanager_routinginterface_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_audiomanager_routinginterface_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _audiomanager_routinginterface_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _audiomanager_routinginterface_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _audiomanager_routinginterface_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routinginterface", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +audiomanager_routinginterface_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void +_audiomanager_routinginterface_on_signal_set_routing_ready ( + AudiomanagerRoutinginterface *object) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("()")); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routinginterface", "setRoutingReady", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_audiomanager_routinginterface_on_signal_set_routing_rundown ( + AudiomanagerRoutinginterface *object) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("()")); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routinginterface", "setRoutingRundown", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void audiomanager_routinginterface_skeleton_iface_init (AudiomanagerRoutinginterfaceIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceSkeleton, audiomanager_routinginterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (AudiomanagerRoutinginterfaceSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutinginterfaceSkeleton, audiomanager_routinginterface_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTINGINTERFACE, audiomanager_routinginterface_skeleton_iface_init)); + +#endif +static void +audiomanager_routinginterface_skeleton_finalize (GObject *object) +{ + AudiomanagerRoutinginterfaceSkeleton *skeleton = AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (audiomanager_routinginterface_skeleton_parent_class)->finalize (object); +} + +static void +audiomanager_routinginterface_skeleton_init (AudiomanagerRoutinginterfaceSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = audiomanager_routinginterface_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +audiomanager_routinginterface_skeleton_class_init (AudiomanagerRoutinginterfaceSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_routinginterface_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = audiomanager_routinginterface_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = audiomanager_routinginterface_skeleton_dbus_interface_get_properties; + skeleton_class->flush = audiomanager_routinginterface_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = audiomanager_routinginterface_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerRoutinginterfaceSkeletonPrivate)); +#endif +} + +static void +audiomanager_routinginterface_skeleton_iface_init (AudiomanagerRoutinginterfaceIface *iface) +{ + iface->set_routing_ready = _audiomanager_routinginterface_on_signal_set_routing_ready; + iface->set_routing_rundown = _audiomanager_routinginterface_on_signal_set_routing_rundown; +} + +/** + * audiomanager_routinginterface_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.genivi.audiomanager.routinginterface. + * + * Returns: (transfer full) (type AudiomanagerRoutinginterfaceSkeleton): The skeleton object. + */ +AudiomanagerRoutinginterface * +audiomanager_routinginterface_skeleton_new (void) +{ + return AUDIOMANAGER_ROUTINGINTERFACE (g_object_new (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for interface org.genivi.audiomanager.routing.soundmanager + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:AudiomanagerRoutingSoundmanager + * @title: AudiomanagerRoutingSoundmanager + * @short_description: Generated C code for the org.genivi.audiomanager.routing.soundmanager D-Bus interface + * + * This section contains code for working with the org.genivi.audiomanager.routing.soundmanager D-Bus interface in C. + */ + +/* ---- Introspection data for org.genivi.audiomanager.routing.soundmanager ---- */ + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_handle, + NULL +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_error = +{ + { + -1, + (gchar *) "error", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_error, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_abort = +{ + { + -1, + (gchar *) "asyncAbort", + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_abort_IN_ARG_pointers, + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_abort_OUT_ARG_pointers, + NULL + }, + "handle-async-abort", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionID = +{ + { + -1, + (gchar *) "connectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionFormat = +{ + { + -1, + (gchar *) "connectionFormat", + (gchar *) "i", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_handle, + &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionID, + &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sourceID, + &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_sinkID, + &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_connectionFormat, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_connect = +{ + { + -1, + (gchar *) "asyncConnect", + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_connect_IN_ARG_pointers, + NULL, + NULL + }, + "handle-async-connect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_connectionID = +{ + { + -1, + (gchar *) "connectionID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_handle, + &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_connectionID, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_disconnect = +{ + { + -1, + (gchar *) "asyncDisconnect", + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_disconnect_IN_ARG_pointers, + NULL, + NULL + }, + "handle-async-disconnect", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_sinkID = +{ + { + -1, + (gchar *) "sinkID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_volume = +{ + { + -1, + (gchar *) "volume", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_ramp = +{ + { + -1, + (gchar *) "ramp", + (gchar *) "n", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_time = +{ + { + -1, + (gchar *) "time", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_handle, + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_sinkID, + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_volume, + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_ramp, + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_time, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_set_sink_volume = +{ + { + -1, + (gchar *) "asyncSetSinkVolume", + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume_IN_ARG_pointers, + NULL, + NULL + }, + "handle-async-set-sink-volume", + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_handle = +{ + { + -1, + (gchar *) "handle", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceID = +{ + { + -1, + (gchar *) "sourceID", + (gchar *) "q", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceState = +{ + { + -1, + (gchar *) "sourceState", + (gchar *) "i", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_handle, + &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceID, + &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_sourceState, + NULL +}; + +static const _ExtendedGDBusMethodInfo _audiomanager_routing_soundmanager_method_info_async_set_source_state = +{ + { + -1, + (gchar *) "asyncSetSourceState", + (GDBusArgInfo **) &_audiomanager_routing_soundmanager_method_info_async_set_source_state_IN_ARG_pointers, + NULL, + NULL + }, + "handle-async-set-source-state", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _audiomanager_routing_soundmanager_method_info_pointers[] = +{ + &_audiomanager_routing_soundmanager_method_info_async_abort, + &_audiomanager_routing_soundmanager_method_info_async_connect, + &_audiomanager_routing_soundmanager_method_info_async_disconnect, + &_audiomanager_routing_soundmanager_method_info_async_set_sink_volume, + &_audiomanager_routing_soundmanager_method_info_async_set_source_state, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _audiomanager_routing_soundmanager_interface_info = +{ + { + -1, + (gchar *) "org.genivi.audiomanager.routing.soundmanager", + (GDBusMethodInfo **) &_audiomanager_routing_soundmanager_method_info_pointers, + NULL, + NULL, + NULL + }, + "audiomanager-routing-soundmanager", +}; + + +/** + * audiomanager_routing_soundmanager_interface_info: + * + * Gets a machine-readable description of the org.genivi.audiomanager.routing.soundmanager D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +audiomanager_routing_soundmanager_interface_info (void) +{ + return (GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct; +} + +/** + * audiomanager_routing_soundmanager_override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #AudiomanagerRoutingSoundmanager interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +audiomanager_routing_soundmanager_override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * AudiomanagerRoutingSoundmanager: + * + * Abstract interface type for the D-Bus interface org.genivi.audiomanager.routing.soundmanager. + */ + +/** + * AudiomanagerRoutingSoundmanagerIface: + * @parent_iface: The parent interface. + * @handle_async_abort: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-abort signal. + * @handle_async_connect: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-connect signal. + * @handle_async_disconnect: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-disconnect signal. + * @handle_async_set_sink_volume: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-set-sink-volume signal. + * @handle_async_set_source_state: Handler for the #AudiomanagerRoutingSoundmanager::handle-async-set-source-state signal. + * + * Virtual table for the D-Bus interface org.genivi.audiomanager.routing.soundmanager. + */ + +typedef AudiomanagerRoutingSoundmanagerIface AudiomanagerRoutingSoundmanagerInterface; +G_DEFINE_INTERFACE (AudiomanagerRoutingSoundmanager, audiomanager_routing_soundmanager, G_TYPE_OBJECT); + +static void +audiomanager_routing_soundmanager_default_init (AudiomanagerRoutingSoundmanagerIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * AudiomanagerRoutingSoundmanager::handle-async-abort: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the asyncAbort() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routing_soundmanager_complete_async_abort() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-async-abort", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_abort), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * AudiomanagerRoutingSoundmanager::handle-async-connect: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_connectionID: Argument passed by remote caller. + * @arg_sourceID: Argument passed by remote caller. + * @arg_sinkID: Argument passed by remote caller. + * @arg_connectionFormat: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the asyncConnect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routing_soundmanager_complete_async_connect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-async-connect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_connect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 6, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT); + + /** + * AudiomanagerRoutingSoundmanager::handle-async-disconnect: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_connectionID: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the asyncDisconnect() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routing_soundmanager_complete_async_disconnect() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-async-disconnect", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_disconnect), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT); + + /** + * AudiomanagerRoutingSoundmanager::handle-async-set-sink-volume: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_sinkID: Argument passed by remote caller. + * @arg_volume: Argument passed by remote caller. + * @arg_ramp: Argument passed by remote caller. + * @arg_time: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the asyncSetSinkVolume() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routing_soundmanager_complete_async_set_sink_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-async-set-sink-volume", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_set_sink_volume), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 6, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT, G_TYPE_INT, G_TYPE_UINT); + + /** + * AudiomanagerRoutingSoundmanager::handle-async-set-source-state: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: A #GDBusMethodInvocation. + * @arg_handle: Argument passed by remote caller. + * @arg_sourceID: Argument passed by remote caller. + * @arg_sourceState: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the asyncSetSourceState() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call audiomanager_routing_soundmanager_complete_async_set_source_state() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-async-set-source-state", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (AudiomanagerRoutingSoundmanagerIface, handle_async_set_source_state), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT); + +} + +/** + * audiomanager_routing_soundmanager_call_async_abort: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the asyncAbort() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_call_async_abort_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_call_async_abort_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routing_soundmanager_call_async_abort ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "asyncAbort", + g_variant_new ("(q)", + arg_handle), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routing_soundmanager_call_async_abort_finish: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_abort(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routing_soundmanager_call_async_abort(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_abort_finish ( + AudiomanagerRoutingSoundmanager *proxy, + gint16 *out_error, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_abort_sync: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @out_error: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the asyncAbort() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_call_async_abort() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_abort_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + gint16 *out_error, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "asyncAbort", + g_variant_new ("(q)", + arg_handle), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(n)", + out_error); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_connect: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_connectionFormat: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the asyncConnect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_call_async_connect_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_call_async_connect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routing_soundmanager_call_async_connect ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "asyncConnect", + g_variant_new ("(qqqqi)", + arg_handle, + arg_connectionID, + arg_sourceID, + arg_sinkID, + arg_connectionFormat), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routing_soundmanager_call_async_connect_finish: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_connect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routing_soundmanager_call_async_connect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_connect_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_connect_sync: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_connectionFormat: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the asyncConnect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_call_async_connect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_connect_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "asyncConnect", + g_variant_new ("(qqqqi)", + arg_handle, + arg_connectionID, + arg_sourceID, + arg_sinkID, + arg_connectionFormat), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_disconnect: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the asyncDisconnect() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_call_async_disconnect_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_call_async_disconnect_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routing_soundmanager_call_async_disconnect ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "asyncDisconnect", + g_variant_new ("(qq)", + arg_handle, + arg_connectionID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routing_soundmanager_call_async_disconnect_finish: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_disconnect(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routing_soundmanager_call_async_disconnect(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_disconnect_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_disconnect_sync: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_connectionID: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the asyncDisconnect() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_call_async_disconnect() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_disconnect_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "asyncDisconnect", + g_variant_new ("(qq)", + arg_handle, + arg_connectionID), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_set_sink_volume: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @arg_ramp: Argument to pass with the method invocation. + * @arg_time: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the asyncSetSinkVolume() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_call_async_set_sink_volume_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_call_async_set_sink_volume_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routing_soundmanager_call_async_set_sink_volume ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "asyncSetSinkVolume", + g_variant_new ("(qqnnq)", + arg_handle, + arg_sinkID, + arg_volume, + arg_ramp, + arg_time), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routing_soundmanager_call_async_set_sink_volume_finish: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_set_sink_volume(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routing_soundmanager_call_async_set_sink_volume(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_set_sink_volume_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_set_sink_volume_sync: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_sinkID: Argument to pass with the method invocation. + * @arg_volume: Argument to pass with the method invocation. + * @arg_ramp: Argument to pass with the method invocation. + * @arg_time: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the asyncSetSinkVolume() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_call_async_set_sink_volume() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_set_sink_volume_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "asyncSetSinkVolume", + g_variant_new ("(qqnnq)", + arg_handle, + arg_sinkID, + arg_volume, + arg_ramp, + arg_time), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_set_source_state: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sourceState: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the asyncSetSourceState() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_call_async_set_source_state_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_call_async_set_source_state_sync() for the synchronous, blocking version of this method. + */ +void +audiomanager_routing_soundmanager_call_async_set_source_state ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "asyncSetSourceState", + g_variant_new ("(qqi)", + arg_handle, + arg_sourceID, + arg_sourceState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * audiomanager_routing_soundmanager_call_async_set_source_state_finish: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_call_async_set_source_state(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with audiomanager_routing_soundmanager_call_async_set_source_state(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_set_source_state_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_call_async_set_source_state_sync: + * @proxy: A #AudiomanagerRoutingSoundmanagerProxy. + * @arg_handle: Argument to pass with the method invocation. + * @arg_sourceID: Argument to pass with the method invocation. + * @arg_sourceState: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the asyncSetSourceState() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_call_async_set_source_state() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +audiomanager_routing_soundmanager_call_async_set_source_state_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "asyncSetSourceState", + g_variant_new ("(qqi)", + arg_handle, + arg_sourceID, + arg_sourceState), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * audiomanager_routing_soundmanager_complete_async_abort: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @error: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the asyncAbort() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routing_soundmanager_complete_async_abort ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + gint16 error) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(n)", + error)); +} + +/** + * audiomanager_routing_soundmanager_complete_async_connect: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the asyncConnect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routing_soundmanager_complete_async_connect ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routing_soundmanager_complete_async_disconnect: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the asyncDisconnect() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routing_soundmanager_complete_async_disconnect ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routing_soundmanager_complete_async_set_sink_volume: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the asyncSetSinkVolume() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routing_soundmanager_complete_async_set_sink_volume ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * audiomanager_routing_soundmanager_complete_async_set_source_state: + * @object: A #AudiomanagerRoutingSoundmanager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the asyncSetSourceState() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +audiomanager_routing_soundmanager_complete_async_set_source_state ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerRoutingSoundmanagerProxy: + * + * The #AudiomanagerRoutingSoundmanagerProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerRoutingSoundmanagerProxyClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerRoutingSoundmanagerProxy. + */ + +struct _AudiomanagerRoutingSoundmanagerProxyPrivate +{ + GData *qdata; +}; + +static void audiomanager_routing_soundmanager_proxy_iface_init (AudiomanagerRoutingSoundmanagerIface *iface); + +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerProxy, audiomanager_routing_soundmanager_proxy, G_TYPE_DBUS_PROXY, + G_ADD_PRIVATE (AudiomanagerRoutingSoundmanagerProxy) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_proxy_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerProxy, audiomanager_routing_soundmanager_proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_proxy_iface_init)); + +#endif +static void +audiomanager_routing_soundmanager_proxy_finalize (GObject *object) +{ + AudiomanagerRoutingSoundmanagerProxy *proxy = AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (audiomanager_routing_soundmanager_proxy_parent_class)->finalize (object); +} + +static void +audiomanager_routing_soundmanager_proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_routing_soundmanager_proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec G_GNUC_UNUSED) +{ +} + +static void +audiomanager_routing_soundmanager_proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name G_GNUC_UNUSED, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +audiomanager_routing_soundmanager_proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + AudiomanagerRoutingSoundmanagerProxy *proxy = AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +audiomanager_routing_soundmanager_proxy_init (AudiomanagerRoutingSoundmanagerProxy *proxy) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + proxy->priv = audiomanager_routing_soundmanager_proxy_get_instance_private (proxy); +#else + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyPrivate); +#endif + + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), audiomanager_routing_soundmanager_interface_info ()); +} + +static void +audiomanager_routing_soundmanager_proxy_class_init (AudiomanagerRoutingSoundmanagerProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_routing_soundmanager_proxy_finalize; + gobject_class->get_property = audiomanager_routing_soundmanager_proxy_get_property; + gobject_class->set_property = audiomanager_routing_soundmanager_proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = audiomanager_routing_soundmanager_proxy_g_signal; + proxy_class->g_properties_changed = audiomanager_routing_soundmanager_proxy_g_properties_changed; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerRoutingSoundmanagerProxyPrivate)); +#endif +} + +static void +audiomanager_routing_soundmanager_proxy_iface_init (AudiomanagerRoutingSoundmanagerIface *iface) +{ +} + +/** + * audiomanager_routing_soundmanager_proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.routing.soundmanager. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_proxy_new_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_routing_soundmanager_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL); +} + +/** + * audiomanager_routing_soundmanager_proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_routing_soundmanager_proxy_new(). + * + * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutingSoundmanager * +audiomanager_routing_soundmanager_proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); + else + return NULL; +} + +/** + * audiomanager_routing_soundmanager_proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.genivi.audiomanager.routing.soundmanager. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutingSoundmanager * +audiomanager_routing_soundmanager_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL); + if (ret != NULL) + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); + else + return NULL; +} + + +/** + * audiomanager_routing_soundmanager_proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like audiomanager_routing_soundmanager_proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call audiomanager_routing_soundmanager_proxy_new_for_bus_finish() to get the result of the operation. + * + * See audiomanager_routing_soundmanager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +audiomanager_routing_soundmanager_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL); +} + +/** + * audiomanager_routing_soundmanager_proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to audiomanager_routing_soundmanager_proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with audiomanager_routing_soundmanager_proxy_new_for_bus(). + * + * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutingSoundmanager * +audiomanager_routing_soundmanager_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); + else + return NULL; +} + +/** + * audiomanager_routing_soundmanager_proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like audiomanager_routing_soundmanager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See audiomanager_routing_soundmanager_proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerProxy): The constructed proxy object or %NULL if @error is set. + */ +AudiomanagerRoutingSoundmanager * +audiomanager_routing_soundmanager_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.genivi.audiomanager.routing.soundmanager", NULL); + if (ret != NULL) + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * AudiomanagerRoutingSoundmanagerSkeleton: + * + * The #AudiomanagerRoutingSoundmanagerSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * AudiomanagerRoutingSoundmanagerSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #AudiomanagerRoutingSoundmanagerSkeleton. + */ + +struct _AudiomanagerRoutingSoundmanagerSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_audiomanager_routing_soundmanager_skeleton_handle_method_call ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_audiomanager_routing_soundmanager_skeleton_handle_get_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_audiomanager_routing_soundmanager_skeleton_handle_set_property ( + GDBusConnection *connection G_GNUC_UNUSED, + const gchar *sender G_GNUC_UNUSED, + const gchar *object_path G_GNUC_UNUSED, + const gchar *interface_name G_GNUC_UNUSED, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_audiomanager_routing_soundmanager_interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _audiomanager_routing_soundmanager_skeleton_vtable = +{ + _audiomanager_routing_soundmanager_skeleton_handle_method_call, + _audiomanager_routing_soundmanager_skeleton_handle_get_property, + _audiomanager_routing_soundmanager_skeleton_handle_set_property, + {NULL} +}; + +static GDBusInterfaceInfo * +audiomanager_routing_soundmanager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return audiomanager_routing_soundmanager_interface_info (); +} + +static GDBusInterfaceVTable * +audiomanager_routing_soundmanager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED) +{ + return (GDBusInterfaceVTable *) &_audiomanager_routing_soundmanager_skeleton_vtable; +} + +static GVariant * +audiomanager_routing_soundmanager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_audiomanager_routing_soundmanager_interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _audiomanager_routing_soundmanager_interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _audiomanager_routing_soundmanager_interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _audiomanager_routing_soundmanager_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.genivi.audiomanager.routing.soundmanager", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +audiomanager_routing_soundmanager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void audiomanager_routing_soundmanager_skeleton_iface_init (AudiomanagerRoutingSoundmanagerIface *iface); +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerSkeleton, audiomanager_routing_soundmanager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_ADD_PRIVATE (AudiomanagerRoutingSoundmanagerSkeleton) + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_skeleton_iface_init)); + +#else +G_DEFINE_TYPE_WITH_CODE (AudiomanagerRoutingSoundmanagerSkeleton, audiomanager_routing_soundmanager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, audiomanager_routing_soundmanager_skeleton_iface_init)); + +#endif +static void +audiomanager_routing_soundmanager_skeleton_finalize (GObject *object) +{ + AudiomanagerRoutingSoundmanagerSkeleton *skeleton = AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (audiomanager_routing_soundmanager_skeleton_parent_class)->finalize (object); +} + +static void +audiomanager_routing_soundmanager_skeleton_init (AudiomanagerRoutingSoundmanagerSkeleton *skeleton) +{ +#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38 + skeleton->priv = audiomanager_routing_soundmanager_skeleton_get_instance_private (skeleton); +#else + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonPrivate); +#endif + + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +audiomanager_routing_soundmanager_skeleton_class_init (AudiomanagerRoutingSoundmanagerSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = audiomanager_routing_soundmanager_skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_info; + skeleton_class->get_properties = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_properties; + skeleton_class->flush = audiomanager_routing_soundmanager_skeleton_dbus_interface_flush; + skeleton_class->get_vtable = audiomanager_routing_soundmanager_skeleton_dbus_interface_get_vtable; + +#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38 + g_type_class_add_private (klass, sizeof (AudiomanagerRoutingSoundmanagerSkeletonPrivate)); +#endif +} + +static void +audiomanager_routing_soundmanager_skeleton_iface_init (AudiomanagerRoutingSoundmanagerIface *iface) +{ +} + +/** + * audiomanager_routing_soundmanager_skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.genivi.audiomanager.routing.soundmanager. + * + * Returns: (transfer full) (type AudiomanagerRoutingSoundmanagerSkeleton): The skeleton object. + */ +AudiomanagerRoutingSoundmanager * +audiomanager_routing_soundmanager_skeleton_new (void) +{ + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (g_object_new (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, NULL)); +} + +/* ------------------------------------------------------------------------ + * Code for Object, ObjectProxy and ObjectSkeleton + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:Object + * @title: Object + * @short_description: Specialized GDBusObject types + * + * This section contains the #Object, #ObjectProxy, and #ObjectSkeleton types which make it easier to work with objects implementing generated types for D-Bus interfaces. + */ + +/** + * Object: + * + * The #Object type is a specialized container of interfaces. + */ + +/** + * ObjectIface: + * @parent_iface: The parent interface. + * + * Virtual table for the #Object interface. + */ + +typedef ObjectIface ObjectInterface; +G_DEFINE_INTERFACE_WITH_CODE (Object, object, G_TYPE_OBJECT, g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_DBUS_OBJECT)); + +static void +object_default_init (ObjectIface *iface) +{ + /** + * Object:audiomanager-commandinterface: + * + * The #AudiomanagerCommandinterface instance corresponding to the D-Bus interface org.genivi.audiomanager.commandinterface, if any. + * + * Connect to the #GObject::notify signal to get informed of property changes. + */ + g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-commandinterface", "audiomanager-commandinterface", "audiomanager-commandinterface", TYPE_AUDIOMANAGER_COMMANDINTERFACE, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS)); + + /** + * Object:audiomanager-routinginterface: + * + * The #AudiomanagerRoutinginterface instance corresponding to the D-Bus interface org.genivi.audiomanager.routinginterface, if any. + * + * Connect to the #GObject::notify signal to get informed of property changes. + */ + g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-routinginterface", "audiomanager-routinginterface", "audiomanager-routinginterface", TYPE_AUDIOMANAGER_ROUTINGINTERFACE, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS)); + + /** + * Object:audiomanager-routing-soundmanager: + * + * The #AudiomanagerRoutingSoundmanager instance corresponding to the D-Bus interface org.genivi.audiomanager.routing.soundmanager, if any. + * + * Connect to the #GObject::notify signal to get informed of property changes. + */ + g_object_interface_install_property (iface, g_param_spec_object ("audiomanager-routing-soundmanager", "audiomanager-routing-soundmanager", "audiomanager-routing-soundmanager", TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS)); + +} + +/** + * object_get_audiomanager_commandinterface: + * @object: A #Object. + * + * Gets the #AudiomanagerCommandinterface instance for the D-Bus interface org.genivi.audiomanager.commandinterface on @object, if any. + * + * Returns: (transfer full): A #AudiomanagerCommandinterface that must be freed with g_object_unref() or %NULL if @object does not implement the interface. + */ +AudiomanagerCommandinterface *object_get_audiomanager_commandinterface (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface"); + if (ret == NULL) + return NULL; + return AUDIOMANAGER_COMMANDINTERFACE (ret); +} + +/** + * object_get_audiomanager_routinginterface: + * @object: A #Object. + * + * Gets the #AudiomanagerRoutinginterface instance for the D-Bus interface org.genivi.audiomanager.routinginterface on @object, if any. + * + * Returns: (transfer full): A #AudiomanagerRoutinginterface that must be freed with g_object_unref() or %NULL if @object does not implement the interface. + */ +AudiomanagerRoutinginterface *object_get_audiomanager_routinginterface (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface"); + if (ret == NULL) + return NULL; + return AUDIOMANAGER_ROUTINGINTERFACE (ret); +} + +/** + * object_get_audiomanager_routing_soundmanager: + * @object: A #Object. + * + * Gets the #AudiomanagerRoutingSoundmanager instance for the D-Bus interface org.genivi.audiomanager.routing.soundmanager on @object, if any. + * + * Returns: (transfer full): A #AudiomanagerRoutingSoundmanager that must be freed with g_object_unref() or %NULL if @object does not implement the interface. + */ +AudiomanagerRoutingSoundmanager *object_get_audiomanager_routing_soundmanager (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager"); + if (ret == NULL) + return NULL; + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); +} + + +/** + * object_peek_audiomanager_commandinterface: (skip) + * @object: A #Object. + * + * Like object_get_audiomanager_commandinterface() but doesn't increase the reference count on the returned object. + * + * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running. + * + * Returns: (transfer none): A #AudiomanagerCommandinterface or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object. + */ +AudiomanagerCommandinterface *object_peek_audiomanager_commandinterface (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface"); + if (ret == NULL) + return NULL; + g_object_unref (ret); + return AUDIOMANAGER_COMMANDINTERFACE (ret); +} + +/** + * object_peek_audiomanager_routinginterface: (skip) + * @object: A #Object. + * + * Like object_get_audiomanager_routinginterface() but doesn't increase the reference count on the returned object. + * + * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running. + * + * Returns: (transfer none): A #AudiomanagerRoutinginterface or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object. + */ +AudiomanagerRoutinginterface *object_peek_audiomanager_routinginterface (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface"); + if (ret == NULL) + return NULL; + g_object_unref (ret); + return AUDIOMANAGER_ROUTINGINTERFACE (ret); +} + +/** + * object_peek_audiomanager_routing_soundmanager: (skip) + * @object: A #Object. + * + * Like object_get_audiomanager_routing_soundmanager() but doesn't increase the reference count on the returned object. + * + * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running. + * + * Returns: (transfer none): A #AudiomanagerRoutingSoundmanager or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object. + */ +AudiomanagerRoutingSoundmanager *object_peek_audiomanager_routing_soundmanager (Object *object) +{ + GDBusInterface *ret; + ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager"); + if (ret == NULL) + return NULL; + g_object_unref (ret); + return AUDIOMANAGER_ROUTING_SOUNDMANAGER (ret); +} + + +static void +object_notify (GDBusObject *object, GDBusInterface *interface) +{ + _ExtendedGDBusInterfaceInfo *info = (_ExtendedGDBusInterfaceInfo *) g_dbus_interface_get_info (interface); + /* info can be NULL if the other end is using a D-Bus interface we don't know + * anything about, for example old generated code in this process talking to + * newer generated code in the other process. */ + if (info != NULL) + g_object_notify (G_OBJECT (object), info->hyphen_name); +} + +/** + * ObjectProxy: + * + * The #ObjectProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * ObjectProxyClass: + * @parent_class: The parent class. + * + * Class structure for #ObjectProxy. + */ + +static void +object_proxy__object_iface_init (ObjectIface *iface G_GNUC_UNUSED) +{ +} + +static void +object_proxy__g_dbus_object_iface_init (GDBusObjectIface *iface) +{ + iface->interface_added = object_notify; + iface->interface_removed = object_notify; +} + + +G_DEFINE_TYPE_WITH_CODE (ObjectProxy, object_proxy, G_TYPE_DBUS_OBJECT_PROXY, + G_IMPLEMENT_INTERFACE (TYPE_OBJECT, object_proxy__object_iface_init) + G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, object_proxy__g_dbus_object_iface_init)); + +static void +object_proxy_init (ObjectProxy *object G_GNUC_UNUSED) +{ +} + +static void +object_proxy_set_property (GObject *gobject, + guint prop_id, + const GValue *value G_GNUC_UNUSED, + GParamSpec *pspec) +{ + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); +} + +static void +object_proxy_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + ObjectProxy *object = OBJECT_PROXY (gobject); + GDBusInterface *interface; + + switch (prop_id) + { + case 1: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface"); + g_value_take_object (value, interface); + break; + + case 2: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface"); + g_value_take_object (value, interface); + break; + + case 3: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager"); + g_value_take_object (value, interface); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + break; + } +} + +static void +object_proxy_class_init (ObjectProxyClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = object_proxy_set_property; + gobject_class->get_property = object_proxy_get_property; + + g_object_class_override_property (gobject_class, 1, "audiomanager-commandinterface"); + g_object_class_override_property (gobject_class, 2, "audiomanager-routinginterface"); + g_object_class_override_property (gobject_class, 3, "audiomanager-routing-soundmanager"); +} + +/** + * object_proxy_new: + * @connection: A #GDBusConnection. + * @object_path: An object path. + * + * Creates a new proxy object. + * + * Returns: (transfer full): The proxy object. + */ +ObjectProxy * +object_proxy_new (GDBusConnection *connection, + const gchar *object_path) +{ + g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL); + g_return_val_if_fail (g_variant_is_object_path (object_path), NULL); + return OBJECT_PROXY (g_object_new (TYPE_OBJECT_PROXY, "g-connection", connection, "g-object-path", object_path, NULL)); +} + +/** + * ObjectSkeleton: + * + * The #ObjectSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * ObjectSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #ObjectSkeleton. + */ + +static void +object_skeleton__object_iface_init (ObjectIface *iface G_GNUC_UNUSED) +{ +} + + +static void +object_skeleton__g_dbus_object_iface_init (GDBusObjectIface *iface) +{ + iface->interface_added = object_notify; + iface->interface_removed = object_notify; +} + +G_DEFINE_TYPE_WITH_CODE (ObjectSkeleton, object_skeleton, G_TYPE_DBUS_OBJECT_SKELETON, + G_IMPLEMENT_INTERFACE (TYPE_OBJECT, object_skeleton__object_iface_init) + G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, object_skeleton__g_dbus_object_iface_init)); + +static void +object_skeleton_init (ObjectSkeleton *object G_GNUC_UNUSED) +{ +} + +static void +object_skeleton_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + ObjectSkeleton *object = OBJECT_SKELETON (gobject); + GDBusInterfaceSkeleton *interface; + + switch (prop_id) + { + case 1: + interface = g_value_get_object (value); + if (interface != NULL) + { + g_warn_if_fail (IS_AUDIOMANAGER_COMMANDINTERFACE (interface)); + g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface); + } + else + { + g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.commandinterface"); + } + break; + + case 2: + interface = g_value_get_object (value); + if (interface != NULL) + { + g_warn_if_fail (IS_AUDIOMANAGER_ROUTINGINTERFACE (interface)); + g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface); + } + else + { + g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.routinginterface"); + } + break; + + case 3: + interface = g_value_get_object (value); + if (interface != NULL) + { + g_warn_if_fail (IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER (interface)); + g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface); + } + else + { + g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.genivi.audiomanager.routing.soundmanager"); + } + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + break; + } +} + +static void +object_skeleton_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + ObjectSkeleton *object = OBJECT_SKELETON (gobject); + GDBusInterface *interface; + + switch (prop_id) + { + case 1: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.commandinterface"); + g_value_take_object (value, interface); + break; + + case 2: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routinginterface"); + g_value_take_object (value, interface); + break; + + case 3: + interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.genivi.audiomanager.routing.soundmanager"); + g_value_take_object (value, interface); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + break; + } +} + +static void +object_skeleton_class_init (ObjectSkeletonClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = object_skeleton_set_property; + gobject_class->get_property = object_skeleton_get_property; + + g_object_class_override_property (gobject_class, 1, "audiomanager-commandinterface"); + g_object_class_override_property (gobject_class, 2, "audiomanager-routinginterface"); + g_object_class_override_property (gobject_class, 3, "audiomanager-routing-soundmanager"); +} + +/** + * object_skeleton_new: + * @object_path: An object path. + * + * Creates a new skeleton object. + * + * Returns: (transfer full): The skeleton object. + */ +ObjectSkeleton * +object_skeleton_new (const gchar *object_path) +{ + g_return_val_if_fail (g_variant_is_object_path (object_path), NULL); + return OBJECT_SKELETON (g_object_new (TYPE_OBJECT_SKELETON, "g-object-path", object_path, NULL)); +} + +/** + * object_skeleton_set_audiomanager_commandinterface: + * @object: A #ObjectSkeleton. + * @interface_: (allow-none): A #AudiomanagerCommandinterface or %NULL to clear the interface. + * + * Sets the #AudiomanagerCommandinterface instance for the D-Bus interface org.genivi.audiomanager.commandinterface on @object. + */ +void object_skeleton_set_audiomanager_commandinterface (ObjectSkeleton *object, AudiomanagerCommandinterface *interface_) +{ + g_object_set (G_OBJECT (object), "audiomanager-commandinterface", interface_, NULL); +} + +/** + * object_skeleton_set_audiomanager_routinginterface: + * @object: A #ObjectSkeleton. + * @interface_: (allow-none): A #AudiomanagerRoutinginterface or %NULL to clear the interface. + * + * Sets the #AudiomanagerRoutinginterface instance for the D-Bus interface org.genivi.audiomanager.routinginterface on @object. + */ +void object_skeleton_set_audiomanager_routinginterface (ObjectSkeleton *object, AudiomanagerRoutinginterface *interface_) +{ + g_object_set (G_OBJECT (object), "audiomanager-routinginterface", interface_, NULL); +} + +/** + * object_skeleton_set_audiomanager_routing_soundmanager: + * @object: A #ObjectSkeleton. + * @interface_: (allow-none): A #AudiomanagerRoutingSoundmanager or %NULL to clear the interface. + * + * Sets the #AudiomanagerRoutingSoundmanager instance for the D-Bus interface org.genivi.audiomanager.routing.soundmanager on @object. + */ +void object_skeleton_set_audiomanager_routing_soundmanager (ObjectSkeleton *object, AudiomanagerRoutingSoundmanager *interface_) +{ + g_object_set (G_OBJECT (object), "audiomanager-routing-soundmanager", interface_, NULL); +} + + +/* ------------------------------------------------------------------------ + * Code for ObjectManager client + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:ObjectManagerClient + * @title: ObjectManagerClient + * @short_description: Generated GDBusObjectManagerClient type + * + * This section contains a #GDBusObjectManagerClient that uses object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. + */ + +/** + * ObjectManagerClient: + * + * The #ObjectManagerClient structure contains only private data and should only be accessed using the provided API. + */ + +/** + * ObjectManagerClientClass: + * @parent_class: The parent class. + * + * Class structure for #ObjectManagerClient. + */ + +G_DEFINE_TYPE (ObjectManagerClient, object_manager_client, G_TYPE_DBUS_OBJECT_MANAGER_CLIENT); + +static void +object_manager_client_init (ObjectManagerClient *manager G_GNUC_UNUSED) +{ +} + +static void +object_manager_client_class_init (ObjectManagerClientClass *klass G_GNUC_UNUSED) +{ +} + +/** + * object_manager_client_get_proxy_type: + * @manager: A #GDBusObjectManagerClient. + * @object_path: The object path of the remote object (unused). + * @interface_name: (allow-none): Interface name of the remote object or %NULL to get the object proxy #GType. + * @user_data: User data (unused). + * + * A #GDBusProxyTypeFunc that maps @interface_name to the generated #GDBusObjectProxy- and #GDBusProxy-derived types. + * + * Returns: A #GDBusProxy-derived #GType if @interface_name is not %NULL, otherwise the #GType for #ObjectProxy. + */ +GType +object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager G_GNUC_UNUSED, const gchar *object_path G_GNUC_UNUSED, const gchar *interface_name, gpointer user_data G_GNUC_UNUSED) +{ + static gsize once_init_value = 0; + static GHashTable *lookup_hash; + GType ret; + + if (interface_name == NULL) + return TYPE_OBJECT_PROXY; + if (g_once_init_enter (&once_init_value)) + { + lookup_hash = g_hash_table_new (g_str_hash, g_str_equal); + g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.commandinterface", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY)); + g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.routinginterface", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY)); + g_hash_table_insert (lookup_hash, (gpointer) "org.genivi.audiomanager.routing.soundmanager", GSIZE_TO_POINTER (TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY)); + g_once_init_leave (&once_init_value, 1); + } + ret = (GType) GPOINTER_TO_SIZE (g_hash_table_lookup (lookup_hash, interface_name)); + if (ret == (GType) 0) + ret = G_TYPE_DBUS_PROXY; + return ret; +} + +/** + * object_manager_client_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates #GDBusObjectManagerClient using object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call object_manager_client_new_finish() to get the result of the operation. + * + * See object_manager_client_new_sync() for the synchronous, blocking version of this constructor. + */ +void +object_manager_client_new ( + GDBusConnection *connection, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL); +} + +/** + * object_manager_client_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to object_manager_client_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with object_manager_client_new(). + * + * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set. + */ +GDBusObjectManager * +object_manager_client_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return G_DBUS_OBJECT_MANAGER (ret); + else + return NULL; +} + +/** + * object_manager_client_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates #GDBusObjectManagerClient using object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See object_manager_client_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set. + */ +GDBusObjectManager * +object_manager_client_new_sync ( + GDBusConnection *connection, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL); + if (ret != NULL) + return G_DBUS_OBJECT_MANAGER (ret); + else + return NULL; +} + + +/** + * object_manager_client_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like object_manager_client_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call object_manager_client_new_for_bus_finish() to get the result of the operation. + * + * See object_manager_client_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +object_manager_client_new_for_bus ( + GBusType bus_type, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL); +} + +/** + * object_manager_client_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to object_manager_client_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with object_manager_client_new_for_bus(). + * + * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set. + */ +GDBusObjectManager * +object_manager_client_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return G_DBUS_OBJECT_MANAGER (ret); + else + return NULL; +} + +/** + * object_manager_client_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like object_manager_client_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See object_manager_client_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type ObjectManagerClient): The constructed object manager client or %NULL if @error is set. + */ +GDBusObjectManager * +object_manager_client_new_for_bus_sync ( + GBusType bus_type, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", object_manager_client_get_proxy_type, NULL); + if (ret != NULL) + return G_DBUS_OBJECT_MANAGER (ret); + else + return NULL; +} + + diff --git a/soundmanager_binging/dbus/audio_manager_interface.h b/soundmanager_binging/dbus/audio_manager_interface.h new file mode 100644 index 0000000..b90455f --- /dev/null +++ b/soundmanager_binging/dbus/audio_manager_interface.h @@ -0,0 +1,1525 @@ +/* + * Generated by gdbus-codegen 2.48.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __AUDIO_MANAGER_INTERFACE_H__ +#define __AUDIO_MANAGER_INTERFACE_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.genivi.audiomanager.commandinterface */ + +#define TYPE_AUDIOMANAGER_COMMANDINTERFACE (audiomanager_commandinterface_get_type ()) +#define AUDIOMANAGER_COMMANDINTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE, AudiomanagerCommandinterface)) +#define IS_AUDIOMANAGER_COMMANDINTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE)) +#define AUDIOMANAGER_COMMANDINTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE, AudiomanagerCommandinterfaceIface)) + +struct _AudiomanagerCommandinterface; +typedef struct _AudiomanagerCommandinterface AudiomanagerCommandinterface; +typedef struct _AudiomanagerCommandinterfaceIface AudiomanagerCommandinterfaceIface; + +struct _AudiomanagerCommandinterfaceIface +{ + GTypeInterface parent_iface; + + + gboolean (*handle_connect) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sourceID, + guint16 arg_sinkID); + + gboolean (*handle_disconnect) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_mainConnectionID); + + gboolean (*handle_get_list_main_connections) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_set_sink_mute_state) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sinkID, + gint16 arg_muteState); + + gboolean (*handle_set_volume) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sinkID, + gint16 arg_volume); + + gboolean (*handle_volume_step) ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sinkID, + gint16 arg_volumeStep); + + void (*main_connection_state_changed) ( + AudiomanagerCommandinterface *object, + guint16 arg_connectionID, + gint16 arg_connectionState); + + void (*new_main_connection) ( + AudiomanagerCommandinterface *object, + GVariant *arg_mainConnection); + + void (*removed_main_connection) ( + AudiomanagerCommandinterface *object, + guint16 arg_mainConnectionId); + + void (*sink_mute_state_changed) ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_muteState); + + void (*system_property_changed) ( + AudiomanagerCommandinterface *object, + GVariant *arg_SystemProperty); + + void (*volume_changed) ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_volume); + +}; + +GType audiomanager_commandinterface_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *audiomanager_commandinterface_interface_info (void); +guint audiomanager_commandinterface_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void audiomanager_commandinterface_complete_connect ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result, + guint16 mainConnectionID); + +void audiomanager_commandinterface_complete_disconnect ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result); + +void audiomanager_commandinterface_complete_set_volume ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result); + +void audiomanager_commandinterface_complete_volume_step ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result); + +void audiomanager_commandinterface_complete_set_sink_mute_state ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result); + +void audiomanager_commandinterface_complete_get_list_main_connections ( + AudiomanagerCommandinterface *object, + GDBusMethodInvocation *invocation, + gint16 result, + GVariant *listConnections); + + + +/* D-Bus signal emissions functions: */ +void audiomanager_commandinterface_emit_new_main_connection ( + AudiomanagerCommandinterface *object, + GVariant *arg_mainConnection); + +void audiomanager_commandinterface_emit_removed_main_connection ( + AudiomanagerCommandinterface *object, + guint16 arg_mainConnectionId); + +void audiomanager_commandinterface_emit_main_connection_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_connectionID, + gint16 arg_connectionState); + +void audiomanager_commandinterface_emit_volume_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_volume); + +void audiomanager_commandinterface_emit_sink_mute_state_changed ( + AudiomanagerCommandinterface *object, + guint16 arg_sinkID, + gint16 arg_muteState); + +void audiomanager_commandinterface_emit_system_property_changed ( + AudiomanagerCommandinterface *object, + GVariant *arg_SystemProperty); + + + +/* D-Bus method calls: */ +void audiomanager_commandinterface_call_connect ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sourceID, + guint16 arg_sinkID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_connect_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + guint16 *out_mainConnectionID, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_connect_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint16 *out_result, + guint16 *out_mainConnectionID, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_call_disconnect ( + AudiomanagerCommandinterface *proxy, + guint16 arg_mainConnectionID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_disconnect_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_disconnect_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_mainConnectionID, + gint16 *out_result, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_call_set_volume ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volume, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_set_volume_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_set_volume_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 *out_result, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_call_volume_step ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volumeStep, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_volume_step_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_volume_step_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_volumeStep, + gint16 *out_result, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_call_set_sink_mute_state ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_muteState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_set_sink_mute_state_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_set_sink_mute_state_sync ( + AudiomanagerCommandinterface *proxy, + guint16 arg_sinkID, + gint16 arg_muteState, + gint16 *out_result, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_call_get_list_main_connections ( + AudiomanagerCommandinterface *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_commandinterface_call_get_list_main_connections_finish ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GVariant **out_listConnections, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_commandinterface_call_get_list_main_connections_sync ( + AudiomanagerCommandinterface *proxy, + gint16 *out_result, + GVariant **out_listConnections, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY (audiomanager_commandinterface_proxy_get_type ()) +#define AUDIOMANAGER_COMMANDINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxy)) +#define AUDIOMANAGER_COMMANDINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyClass)) +#define AUDIOMANAGER_COMMANDINTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY, AudiomanagerCommandinterfaceProxyClass)) +#define IS_AUDIOMANAGER_COMMANDINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY)) +#define IS_AUDIOMANAGER_COMMANDINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_PROXY)) + +typedef struct _AudiomanagerCommandinterfaceProxy AudiomanagerCommandinterfaceProxy; +typedef struct _AudiomanagerCommandinterfaceProxyClass AudiomanagerCommandinterfaceProxyClass; +typedef struct _AudiomanagerCommandinterfaceProxyPrivate AudiomanagerCommandinterfaceProxyPrivate; + +struct _AudiomanagerCommandinterfaceProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + AudiomanagerCommandinterfaceProxyPrivate *priv; +}; + +struct _AudiomanagerCommandinterfaceProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType audiomanager_commandinterface_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerCommandinterfaceProxy, g_object_unref) +#endif + +void audiomanager_commandinterface_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void audiomanager_commandinterface_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerCommandinterface *audiomanager_commandinterface_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON (audiomanager_commandinterface_skeleton_get_type ()) +#define AUDIOMANAGER_COMMANDINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeleton)) +#define AUDIOMANAGER_COMMANDINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonClass)) +#define AUDIOMANAGER_COMMANDINTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON, AudiomanagerCommandinterfaceSkeletonClass)) +#define IS_AUDIOMANAGER_COMMANDINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON)) +#define IS_AUDIOMANAGER_COMMANDINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_COMMANDINTERFACE_SKELETON)) + +typedef struct _AudiomanagerCommandinterfaceSkeleton AudiomanagerCommandinterfaceSkeleton; +typedef struct _AudiomanagerCommandinterfaceSkeletonClass AudiomanagerCommandinterfaceSkeletonClass; +typedef struct _AudiomanagerCommandinterfaceSkeletonPrivate AudiomanagerCommandinterfaceSkeletonPrivate; + +struct _AudiomanagerCommandinterfaceSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + AudiomanagerCommandinterfaceSkeletonPrivate *priv; +}; + +struct _AudiomanagerCommandinterfaceSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType audiomanager_commandinterface_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerCommandinterfaceSkeleton, g_object_unref) +#endif + +AudiomanagerCommandinterface *audiomanager_commandinterface_skeleton_new (void); + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.genivi.audiomanager.routinginterface */ + +#define TYPE_AUDIOMANAGER_ROUTINGINTERFACE (audiomanager_routinginterface_get_type ()) +#define AUDIOMANAGER_ROUTINGINTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE, AudiomanagerRoutinginterface)) +#define IS_AUDIOMANAGER_ROUTINGINTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE)) +#define AUDIOMANAGER_ROUTINGINTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE, AudiomanagerRoutinginterfaceIface)) + +struct _AudiomanagerRoutinginterface; +typedef struct _AudiomanagerRoutinginterface AudiomanagerRoutinginterface; +typedef struct _AudiomanagerRoutinginterfaceIface AudiomanagerRoutinginterfaceIface; + +struct _AudiomanagerRoutinginterfaceIface +{ + GTypeInterface parent_iface; + + + gboolean (*handle_ack_connect) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error); + + gboolean (*handle_ack_disconnect) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error); + + gboolean (*handle_ack_set_sink_volume) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + gint16 arg_volume, + guint16 arg_error); + + gboolean (*handle_ack_set_source_state) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_error); + + gboolean (*handle_ack_set_volumes) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + GVariant *arg_listvolumes, + guint16 arg_error); + + gboolean (*handle_ack_sink_notification_configuration) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_error); + + gboolean (*handle_ack_source_notification_configuration) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_error); + + gboolean (*handle_confirm_routing_ready) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_domainID); + + gboolean (*handle_confirm_routing_rundown) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_domainID); + + gboolean (*handle_deregister_sink) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sinkID); + + gboolean (*handle_deregister_source) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sourceID); + + gboolean (*handle_hook_interrupt_status_change) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sourceID, + guint16 arg_interruptState); + + gboolean (*handle_hook_source_availablity_status_change) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 arg_sourceID, + GVariant *arg_availability); + + gboolean (*handle_register_domain) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + GVariant *arg_domaindata, + const gchar *arg_returnBusname, + const gchar *arg_returnPath, + const gchar *arg_returnInterface); + + gboolean (*handle_register_sink) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + GVariant *arg_sinkData); + + gboolean (*handle_register_source) ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + GVariant *arg_sourceData); + + void (*set_routing_ready) ( + AudiomanagerRoutinginterface *object); + + void (*set_routing_rundown) ( + AudiomanagerRoutinginterface *object); + +}; + +GType audiomanager_routinginterface_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *audiomanager_routinginterface_interface_info (void); +guint audiomanager_routinginterface_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void audiomanager_routinginterface_complete_ack_connect ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_disconnect ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_set_source_state ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_set_sink_volume ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_register_sink ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 sinkID, + guint16 error); + +void audiomanager_routinginterface_complete_deregister_sink ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + gint error); + +void audiomanager_routinginterface_complete_register_source ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 sourceID, + guint16 error); + +void audiomanager_routinginterface_complete_deregister_source ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 error); + +void audiomanager_routinginterface_complete_hook_interrupt_status_change ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_hook_source_availablity_status_change ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_confirm_routing_ready ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_confirm_routing_rundown ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_set_volumes ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_sink_notification_configuration ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_ack_source_notification_configuration ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routinginterface_complete_register_domain ( + AudiomanagerRoutinginterface *object, + GDBusMethodInvocation *invocation, + guint16 domainid, + guint16 error); + + + +/* D-Bus signal emissions functions: */ +void audiomanager_routinginterface_emit_set_routing_ready ( + AudiomanagerRoutinginterface *object); + +void audiomanager_routinginterface_emit_set_routing_rundown ( + AudiomanagerRoutinginterface *object); + + + +/* D-Bus method calls: */ +void audiomanager_routinginterface_call_ack_connect ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_connect_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_connect_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_disconnect ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_disconnect_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_disconnect_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_set_source_state ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_set_source_state_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_set_source_state_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_set_sink_volume ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + gint16 arg_volume, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_set_sink_volume_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_set_sink_volume_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + gint16 arg_volume, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_register_sink ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sinkData, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_register_sink_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_sinkID, + guint16 *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_register_sink_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sinkData, + guint16 *out_sinkID, + guint16 *out_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_deregister_sink ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sinkID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_deregister_sink_finish ( + AudiomanagerRoutinginterface *proxy, + gint *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_deregister_sink_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sinkID, + gint *out_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_register_source ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sourceData, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_register_source_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_sourceID, + guint16 *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_register_source_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_sourceData, + guint16 *out_sourceID, + guint16 *out_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_deregister_source ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_deregister_source_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_deregister_source_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 *out_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_hook_interrupt_status_change ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 arg_interruptState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_hook_interrupt_status_change_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_hook_interrupt_status_change_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + guint16 arg_interruptState, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_hook_source_availablity_status_change ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GVariant *arg_availability, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_hook_source_availablity_status_change_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_hook_source_availablity_status_change_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_sourceID, + GVariant *arg_availability, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_confirm_routing_ready ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_confirm_routing_ready_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_confirm_routing_ready_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_confirm_routing_rundown ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_confirm_routing_rundown_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_confirm_routing_rundown_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_domainID, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_set_volumes ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + GVariant *arg_listvolumes, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_set_volumes_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_set_volumes_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + GVariant *arg_listvolumes, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_sink_notification_configuration ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_sink_notification_configuration_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_sink_notification_configuration_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_ack_source_notification_configuration ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_ack_source_notification_configuration_finish ( + AudiomanagerRoutinginterface *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_ack_source_notification_configuration_sync ( + AudiomanagerRoutinginterface *proxy, + guint16 arg_handle, + guint16 arg_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_call_register_domain ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_domaindata, + const gchar *arg_returnBusname, + const gchar *arg_returnPath, + const gchar *arg_returnInterface, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routinginterface_call_register_domain_finish ( + AudiomanagerRoutinginterface *proxy, + guint16 *out_domainid, + guint16 *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routinginterface_call_register_domain_sync ( + AudiomanagerRoutinginterface *proxy, + GVariant *arg_domaindata, + const gchar *arg_returnBusname, + const gchar *arg_returnPath, + const gchar *arg_returnInterface, + guint16 *out_domainid, + guint16 *out_error, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY (audiomanager_routinginterface_proxy_get_type ()) +#define AUDIOMANAGER_ROUTINGINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxy)) +#define AUDIOMANAGER_ROUTINGINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyClass)) +#define AUDIOMANAGER_ROUTINGINTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY, AudiomanagerRoutinginterfaceProxyClass)) +#define IS_AUDIOMANAGER_ROUTINGINTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY)) +#define IS_AUDIOMANAGER_ROUTINGINTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_PROXY)) + +typedef struct _AudiomanagerRoutinginterfaceProxy AudiomanagerRoutinginterfaceProxy; +typedef struct _AudiomanagerRoutinginterfaceProxyClass AudiomanagerRoutinginterfaceProxyClass; +typedef struct _AudiomanagerRoutinginterfaceProxyPrivate AudiomanagerRoutinginterfaceProxyPrivate; + +struct _AudiomanagerRoutinginterfaceProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + AudiomanagerRoutinginterfaceProxyPrivate *priv; +}; + +struct _AudiomanagerRoutinginterfaceProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType audiomanager_routinginterface_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutinginterfaceProxy, g_object_unref) +#endif + +void audiomanager_routinginterface_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void audiomanager_routinginterface_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerRoutinginterface *audiomanager_routinginterface_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON (audiomanager_routinginterface_skeleton_get_type ()) +#define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeleton)) +#define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonClass)) +#define AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON, AudiomanagerRoutinginterfaceSkeletonClass)) +#define IS_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON)) +#define IS_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTINGINTERFACE_SKELETON)) + +typedef struct _AudiomanagerRoutinginterfaceSkeleton AudiomanagerRoutinginterfaceSkeleton; +typedef struct _AudiomanagerRoutinginterfaceSkeletonClass AudiomanagerRoutinginterfaceSkeletonClass; +typedef struct _AudiomanagerRoutinginterfaceSkeletonPrivate AudiomanagerRoutinginterfaceSkeletonPrivate; + +struct _AudiomanagerRoutinginterfaceSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + AudiomanagerRoutinginterfaceSkeletonPrivate *priv; +}; + +struct _AudiomanagerRoutinginterfaceSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType audiomanager_routinginterface_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutinginterfaceSkeleton, g_object_unref) +#endif + +AudiomanagerRoutinginterface *audiomanager_routinginterface_skeleton_new (void); + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.genivi.audiomanager.routing.soundmanager */ + +#define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER (audiomanager_routing_soundmanager_get_type ()) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, AudiomanagerRoutingSoundmanager)) +#define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER)) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER, AudiomanagerRoutingSoundmanagerIface)) + +struct _AudiomanagerRoutingSoundmanager; +typedef struct _AudiomanagerRoutingSoundmanager AudiomanagerRoutingSoundmanager; +typedef struct _AudiomanagerRoutingSoundmanagerIface AudiomanagerRoutingSoundmanagerIface; + +struct _AudiomanagerRoutingSoundmanagerIface +{ + GTypeInterface parent_iface; + + gboolean (*handle_async_abort) ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle); + + gboolean (*handle_async_connect) ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat); + + gboolean (*handle_async_disconnect) ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID); + + gboolean (*handle_async_set_sink_volume) ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time); + + gboolean (*handle_async_set_source_state) ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState); + +}; + +GType audiomanager_routing_soundmanager_get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *audiomanager_routing_soundmanager_interface_info (void); +guint audiomanager_routing_soundmanager_override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void audiomanager_routing_soundmanager_complete_async_abort ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + gint16 error); + +void audiomanager_routing_soundmanager_complete_async_connect ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routing_soundmanager_complete_async_disconnect ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routing_soundmanager_complete_async_set_sink_volume ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation); + +void audiomanager_routing_soundmanager_complete_async_set_source_state ( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation); + + + +/* D-Bus method calls: */ +void audiomanager_routing_soundmanager_call_async_abort ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routing_soundmanager_call_async_abort_finish ( + AudiomanagerRoutingSoundmanager *proxy, + gint16 *out_error, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routing_soundmanager_call_async_abort_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + gint16 *out_error, + GCancellable *cancellable, + GError **error); + +void audiomanager_routing_soundmanager_call_async_connect ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routing_soundmanager_call_async_connect_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routing_soundmanager_call_async_connect_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat, + GCancellable *cancellable, + GError **error); + +void audiomanager_routing_soundmanager_call_async_disconnect ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routing_soundmanager_call_async_disconnect_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routing_soundmanager_call_async_disconnect_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_connectionID, + GCancellable *cancellable, + GError **error); + +void audiomanager_routing_soundmanager_call_async_set_sink_volume ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routing_soundmanager_call_async_set_sink_volume_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routing_soundmanager_call_async_set_sink_volume_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time, + GCancellable *cancellable, + GError **error); + +void audiomanager_routing_soundmanager_call_async_set_source_state ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean audiomanager_routing_soundmanager_call_async_set_source_state_finish ( + AudiomanagerRoutingSoundmanager *proxy, + GAsyncResult *res, + GError **error); + +gboolean audiomanager_routing_soundmanager_call_async_set_source_state_sync ( + AudiomanagerRoutingSoundmanager *proxy, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY (audiomanager_routing_soundmanager_proxy_get_type ()) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxy)) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyClass)) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY, AudiomanagerRoutingSoundmanagerProxyClass)) +#define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY)) +#define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_PROXY)) + +typedef struct _AudiomanagerRoutingSoundmanagerProxy AudiomanagerRoutingSoundmanagerProxy; +typedef struct _AudiomanagerRoutingSoundmanagerProxyClass AudiomanagerRoutingSoundmanagerProxyClass; +typedef struct _AudiomanagerRoutingSoundmanagerProxyPrivate AudiomanagerRoutingSoundmanagerProxyPrivate; + +struct _AudiomanagerRoutingSoundmanagerProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + AudiomanagerRoutingSoundmanagerProxyPrivate *priv; +}; + +struct _AudiomanagerRoutingSoundmanagerProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType audiomanager_routing_soundmanager_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutingSoundmanagerProxy, g_object_unref) +#endif + +void audiomanager_routing_soundmanager_proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void audiomanager_routing_soundmanager_proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON (audiomanager_routing_soundmanager_skeleton_get_type ()) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeleton)) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonClass)) +#define AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON, AudiomanagerRoutingSoundmanagerSkeletonClass)) +#define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON)) +#define IS_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_AUDIOMANAGER_ROUTING_SOUNDMANAGER_SKELETON)) + +typedef struct _AudiomanagerRoutingSoundmanagerSkeleton AudiomanagerRoutingSoundmanagerSkeleton; +typedef struct _AudiomanagerRoutingSoundmanagerSkeletonClass AudiomanagerRoutingSoundmanagerSkeletonClass; +typedef struct _AudiomanagerRoutingSoundmanagerSkeletonPrivate AudiomanagerRoutingSoundmanagerSkeletonPrivate; + +struct _AudiomanagerRoutingSoundmanagerSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + AudiomanagerRoutingSoundmanagerSkeletonPrivate *priv; +}; + +struct _AudiomanagerRoutingSoundmanagerSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType audiomanager_routing_soundmanager_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (AudiomanagerRoutingSoundmanagerSkeleton, g_object_unref) +#endif + +AudiomanagerRoutingSoundmanager *audiomanager_routing_soundmanager_skeleton_new (void); + + +/* ---- */ + +#define TYPE_OBJECT (object_get_type ()) +#define OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT, Object)) +#define IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT)) +#define OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_OBJECT, Object)) + +struct _Object; +typedef struct _Object Object; +typedef struct _ObjectIface ObjectIface; + +struct _ObjectIface +{ + GTypeInterface parent_iface; +}; + +GType object_get_type (void) G_GNUC_CONST; + +AudiomanagerCommandinterface *object_get_audiomanager_commandinterface (Object *object); +AudiomanagerRoutinginterface *object_get_audiomanager_routinginterface (Object *object); +AudiomanagerRoutingSoundmanager *object_get_audiomanager_routing_soundmanager (Object *object); +AudiomanagerCommandinterface *object_peek_audiomanager_commandinterface (Object *object); +AudiomanagerRoutinginterface *object_peek_audiomanager_routinginterface (Object *object); +AudiomanagerRoutingSoundmanager *object_peek_audiomanager_routing_soundmanager (Object *object); + +#define TYPE_OBJECT_PROXY (object_proxy_get_type ()) +#define OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_PROXY, ObjectProxy)) +#define OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_PROXY, ObjectProxyClass)) +#define OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_PROXY, ObjectProxyClass)) +#define IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_PROXY)) +#define IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_PROXY)) + +typedef struct _ObjectProxy ObjectProxy; +typedef struct _ObjectProxyClass ObjectProxyClass; +typedef struct _ObjectProxyPrivate ObjectProxyPrivate; + +struct _ObjectProxy +{ + /*< private >*/ + GDBusObjectProxy parent_instance; + ObjectProxyPrivate *priv; +}; + +struct _ObjectProxyClass +{ + GDBusObjectProxyClass parent_class; +}; + +GType object_proxy_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectProxy, g_object_unref) +#endif + +ObjectProxy *object_proxy_new (GDBusConnection *connection, const gchar *object_path); + +#define TYPE_OBJECT_SKELETON (object_skeleton_get_type ()) +#define OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_SKELETON, ObjectSkeleton)) +#define OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_SKELETON, ObjectSkeletonClass)) +#define OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_SKELETON, ObjectSkeletonClass)) +#define IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_SKELETON)) +#define IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_SKELETON)) + +typedef struct _ObjectSkeleton ObjectSkeleton; +typedef struct _ObjectSkeletonClass ObjectSkeletonClass; +typedef struct _ObjectSkeletonPrivate ObjectSkeletonPrivate; + +struct _ObjectSkeleton +{ + /*< private >*/ + GDBusObjectSkeleton parent_instance; + ObjectSkeletonPrivate *priv; +}; + +struct _ObjectSkeletonClass +{ + GDBusObjectSkeletonClass parent_class; +}; + +GType object_skeleton_get_type (void) G_GNUC_CONST; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectSkeleton, g_object_unref) +#endif + +ObjectSkeleton *object_skeleton_new (const gchar *object_path); +void object_skeleton_set_audiomanager_commandinterface (ObjectSkeleton *object, AudiomanagerCommandinterface *interface_); +void object_skeleton_set_audiomanager_routinginterface (ObjectSkeleton *object, AudiomanagerRoutinginterface *interface_); +void object_skeleton_set_audiomanager_routing_soundmanager (ObjectSkeleton *object, AudiomanagerRoutingSoundmanager *interface_); + +/* ---- */ + +#define TYPE_OBJECT_MANAGER_CLIENT (object_manager_client_get_type ()) +#define OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClient)) +#define OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass)) +#define OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass)) +#define IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_MANAGER_CLIENT)) +#define IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_MANAGER_CLIENT)) + +typedef struct _ObjectManagerClient ObjectManagerClient; +typedef struct _ObjectManagerClientClass ObjectManagerClientClass; +typedef struct _ObjectManagerClientPrivate ObjectManagerClientPrivate; + +struct _ObjectManagerClient +{ + /*< private >*/ + GDBusObjectManagerClient parent_instance; + ObjectManagerClientPrivate *priv; +}; + +struct _ObjectManagerClientClass +{ + GDBusObjectManagerClientClass parent_class; +}; + +#if GLIB_CHECK_VERSION(2, 44, 0) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectManagerClient, g_object_unref) +#endif + +GType object_manager_client_get_type (void) G_GNUC_CONST; + +GType object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager, const gchar *object_path, const gchar *interface_name, gpointer user_data); + +void object_manager_client_new ( + GDBusConnection *connection, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +GDBusObjectManager *object_manager_client_new_finish ( + GAsyncResult *res, + GError **error); +GDBusObjectManager *object_manager_client_new_sync ( + GDBusConnection *connection, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void object_manager_client_new_for_bus ( + GBusType bus_type, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +GDBusObjectManager *object_manager_client_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +GDBusObjectManager *object_manager_client_new_for_bus_sync ( + GBusType bus_type, + GDBusObjectManagerClientFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +G_END_DECLS + +#endif /* __AUDIO_MANAGER_INTERFACE_H__ */ diff --git a/soundmanager_binging/dbus/command_interface.xml b/soundmanager_binging/dbus/command_interface.xml new file mode 100644 index 0000000..f3e242a --- /dev/null +++ b/soundmanager_binging/dbus/command_interface.xml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/soundmanager_binging/dbus/generate_dbus.sh b/soundmanager_binging/dbus/generate_dbus.sh new file mode 100755 index 0000000..cacf518 --- /dev/null +++ b/soundmanager_binging/dbus/generate_dbus.sh @@ -0,0 +1,24 @@ +# +# Copyright (c) 2017 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +#!/bin/sh +echo "generate dbus c code" +gdbus-codegen \ + --interface-prefix org.genivi. \ + --generate-c-code audio_manager_interface \ + --c-generate-object-manager \ + command_interface.xml routing_interface.xml sound_manager_interface.xml + +echo "end generate dbus c code" diff --git a/soundmanager_binging/dbus/routing_interface.xml b/soundmanager_binging/dbus/routing_interface.xml new file mode 100644 index 0000000..a91d6eb --- /dev/null +++ b/soundmanager_binging/dbus/routing_interface.xml @@ -0,0 +1,85 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/soundmanager_binging/dbus/sound_manager_interface.xml b/soundmanager_binging/dbus/sound_manager_interface.xml new file mode 100644 index 0000000..df7df04 --- /dev/null +++ b/soundmanager_binging/dbus/sound_manager_interface.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/soundmanager_binging/export.map b/soundmanager_binging/export.map new file mode 100644 index 0000000..f3961c0 --- /dev/null +++ b/soundmanager_binging/export.map @@ -0,0 +1 @@ +{ global: afbBindingV*; local: *; }; \ No newline at end of file diff --git a/soundmanager_binging/sm-error.h b/soundmanager_binging/sm-error.h new file mode 100644 index 0000000..a963d47 --- /dev/null +++ b/soundmanager_binging/sm-error.h @@ -0,0 +1,52 @@ +#ifndef SM_ERROR_H +#define SM_ERROR_H + +char* get_response_audiomanager_massage_error(int am_error_code) +{ + switch (am_error_code){ + case 0: + return "OK"; + case 1: + return "unknown error"; + case 2: + return "value out of range"; + case 3: + return "not used"; + case 4: + return "database error occured"; + case 5: + return "the desired object already exists"; + case 6: + return "there is no change"; + case 7: + return "the desired action is not possible"; + case 8: + return "the desired object is non existent"; + case 9: + return "the asynchronous action was aborted"; + case 10: + return "connectionFormat is not selected"; + case 11: + return "communication error"; + case 100: + return "desired event doesn't exist"; + default: + return "Audio Manager responsed unknown error number"; + } +} + +char* get_source_state_key(int am_source_state){ + switch (am_source_state){ + case 0: + return "unknown"; + case 1: + return "on"; + case 2: + return "off"; + case 3: + return "paused"; + default: + return ""; + } +} +#endif diff --git a/soundmanager_binging/sm-helper.c b/soundmanager_binging/sm-helper.c new file mode 100644 index 0000000..933c0bf --- /dev/null +++ b/soundmanager_binging/sm-helper.c @@ -0,0 +1,231 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "sm-helper.h" +#include +#include +#include +#include +#include + +REQ_ERROR get_value_uint16(const struct afb_req request, const char *source, uint16_t *out_id) +{ + char* endptr; + char* tmp = afb_req_value (request, source); + if(!tmp) + { + return REQ_FAIL; + } + long tmp_id = strtol(tmp,&endptr,10); + + /* error check of range */ + if( (tmp_id > UINT16_MAX) || (tmp_id < 0) ) + { + return OUT_RANGE; + } + if(*endptr != '\0') + { + return NOT_NUMBER; + } + + *out_id = (uint16_t)tmp_id; + return REQ_OK; +} + +REQ_ERROR get_value_int16(const struct afb_req request, const char *source, int16_t *out_id) +{ + char* endptr; + char* tmp = afb_req_value (request, source); + if(!tmp) + { + return REQ_FAIL; + } + long tmp_id = strtol(tmp,&endptr,10); + + /* error check of range */ + if( (tmp_id > INT16_MAX) || (tmp_id < INT16_MIN) ) + { + return OUT_RANGE; + } + if(*endptr != '\0') + { + return NOT_NUMBER; + } + + *out_id = (int16_t)tmp_id; + return REQ_OK; +} + +REQ_ERROR get_value_int32(const struct afb_req request, const char *source, int32_t *out_id) +{ + char* endptr; + char* tmp = afb_req_value (request, source); + if(!tmp) + { + return REQ_FAIL; + } + long tmp_id = strtol(tmp,&endptr,10); + + /* error check of range */ + if( (tmp_id > INT32_MAX) || (tmp_id < INT32_MIN) ) + { + return OUT_RANGE; + } + if(*endptr != '\0') + { + return NOT_NUMBER; + } + + *out_id = (int32_t)tmp_id; + return REQ_OK; +} + +void sm_add_object_to_json_object(struct json_object* j_obj, int count,...) +{ + va_list args; + va_start(args, count); + for(int i = 0; i < count; ++i ) + { + char *key = va_arg(args, char*); + int value = va_arg(args, int); + json_object_object_add(j_obj, key, json_object_new_int((int32_t)value)); + ++i; + } + va_end(args); +} + +void sm_add_object_to_json_object_func(struct json_object* j_obj, const char* verb_name, int count, ...) +{ + va_list args; + va_start(args, count); + + json_object_object_add(j_obj,"verb", json_object_new_string(verb_name)); + + for(int i = 0; i < count; ++i ) + { + char *key = va_arg(args, char*); + int value = va_arg(args, int); + json_object_object_add(j_obj, key, json_object_new_int((int32_t)value)); + ++i; + } + va_end(args); +} + +int sm_search_event_name_index(const char* value) +{ + size_t buf_size = 50; + size_t size = sizeof cmd_evlist / sizeof *cmd_evlist; + int ret = -1; + for(size_t i = 0 ; i < size ; ++i) + { + if(!strncmp(value, cmd_evlist[i], buf_size)) + { + ret = i; + break; + } + } + return ret; +} + +int sm_search_routing_event_name_index(const char* value) +{ + size_t buf_size = 50; + size_t size = sizeof route_evlist / sizeof *route_evlist; + int ret = -1; + for(size_t i = 0 ; i < size ; ++i) + { + if(!strncmp(value, route_evlist[i], buf_size)) + { + ret = i; + break; + } + } + return ret; +} + +GVariant* create_source_data(guint16 sourceID, guint16 domainID, const char* appname, guint16 sourceClassID, + gint32 sourceState, gint16 volume, gboolean visible, struct availability_s availables, + guint16 interrupt, struct sound_property_s soundPropertyList, gint32 connectionFormatList, + struct main_sound_property_s mainPropertyList, struct notification_config_s NConfRouting, + struct notification_config_s NConfCommand, struct afb_binding_interface* afbitf) +{ + GVariantBuilder builder; + + DEBUG(afbitf,"create sourceData %d", __LINE__); + g_variant_builder_init (&builder, G_VARIANT_TYPE ("(qqsqinb(ii)qa(in)aia(in)a(iin)a(iin))")); + g_variant_builder_add (&builder, "q", sourceID); + g_variant_builder_add (&builder, "q", domainID); + g_variant_builder_add (&builder, "s", appname); + g_variant_builder_add (&builder, "q", sourceClassID); + g_variant_builder_add (&builder, "i", sourceState); + g_variant_builder_add (&builder, "n", volume); + g_variant_builder_add (&builder, "b", visible); + g_variant_builder_add (&builder, "(ii)", availables.availability, availables.avalilable_reason); + g_variant_builder_add (&builder, "q", interrupt); + + g_variant_builder_open(&builder, G_VARIANT_TYPE("a(in)")); + g_variant_builder_open(&builder, G_VARIANT_TYPE("(in)")); + g_variant_builder_add (&builder, "i", soundPropertyList.type); + g_variant_builder_add (&builder, "n", soundPropertyList.value); + g_variant_builder_close(&builder); + g_variant_builder_close (&builder); + + g_variant_builder_open(&builder, G_VARIANT_TYPE("ai")); + g_variant_builder_add (&builder, "i", connectionFormatList); + g_variant_builder_close (&builder); + + g_variant_builder_open(&builder, G_VARIANT_TYPE("a(in)")); + g_variant_builder_open(&builder, G_VARIANT_TYPE("(in)")); + g_variant_builder_add (&builder, "i", mainPropertyList.type); + g_variant_builder_add (&builder, "n", mainPropertyList.value); + g_variant_builder_close (&builder); + g_variant_builder_close(&builder); + + g_variant_builder_open(&builder, G_VARIANT_TYPE("a(iin)")); + g_variant_builder_open(&builder, G_VARIANT_TYPE("(iin)")); + g_variant_builder_add (&builder, "i", NConfRouting.type); + g_variant_builder_add (&builder, "i", NConfRouting.status); + g_variant_builder_add (&builder, "n", NConfRouting.parameter); + g_variant_builder_close(&builder); + g_variant_builder_close (&builder); + + + g_variant_builder_open(&builder, G_VARIANT_TYPE("a(iin)")); + g_variant_builder_open(&builder, G_VARIANT_TYPE("(iin)")); + g_variant_builder_add (&builder, "i", NConfCommand.type); + g_variant_builder_add (&builder, "i", NConfCommand.status); + g_variant_builder_add (&builder, "n", NConfCommand.parameter); + g_variant_builder_close(&builder); + g_variant_builder_close (&builder); + + DEBUG(afbitf,"created sourceData %d", __LINE__); + return g_variant_builder_end (&builder); +} + +GVariant* create_domain_data(struct domain_data* data, struct afb_binding_interface* afbitf) +{ + GVariantBuilder builder; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("(qsssbbn)")); + g_variant_builder_add (&builder, "q", data->domainID); + g_variant_builder_add (&builder, "s", data->name); + g_variant_builder_add (&builder, "s", data->busname); + g_variant_builder_add (&builder, "s", data->nodename); + g_variant_builder_add (&builder, "b", data->early); + g_variant_builder_add (&builder, "b", data->complete); + g_variant_builder_add (&builder, "n", data->state); + DEBUG(afbitf,"created domainData %d", __LINE__); + return g_variant_builder_end (&builder); +} diff --git a/soundmanager_binging/sm-helper.h b/soundmanager_binging/sm-helper.h new file mode 100644 index 0000000..510ea20 --- /dev/null +++ b/soundmanager_binging/sm-helper.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AM_HELPER_H +#define AM_HELPER_H +#define _GNU_SOURCE +#include +#include +#include +#include + +typedef enum REQ_ERROR +{ + REQ_FAIL = -1, + REQ_OK=0, + NOT_NUMBER, + OUT_RANGE +}REQ_ERROR; + +static const char* cmd_evlist[] = { + "volumeChanged", + "newMainConnection", + "removedMainConnection", + "sinkMuteStateChanged", + "mainConnectionStateChanged" +}; + +static const char* route_evlist[] = { + /* Routing event*/ + "setRoutingReady", + "setRoutingRundown", + "asyncConnect", + "asyncSetSourceState", + "asyncDisconnect" +}; + +struct sound_property_s{ + guint16 type; + gint16 value; +}; +struct availability_s{ + gint32 availability; + gint32 avalilable_reason; +}; +struct notification_config_s{ + gint32 type; + gint32 status; + gint16 parameter; +}; +struct main_sound_property_s{ + gint32 type; /* am_CustomMainSoundPropertyType_t */ + gint16 value; +}; + +struct domain_data{ + guint16 domainID; + gchar* name; + gchar* busname; + gchar* nodename; + gboolean early; + gboolean complete; + gint16 state; +}; + +REQ_ERROR get_value_uint16(const struct afb_req request, const char *source, uint16_t *out_id); +REQ_ERROR get_value_int16(const struct afb_req request, const char *source, int16_t *out_id); +REQ_ERROR get_value_int32(const struct afb_req request, const char *source, int32_t *out_id); +void sm_add_object_to_json_object(struct json_object* j_obj, int count, ...); +void sm_add_object_to_json_object_func(struct json_object* j_obj, const char* verb_name, int count, ...); +int sm_search_event_name_index(const char* value); +int sm_search_routing_event_name_index(const char* value); +GVariant* create_source_data(guint16 sourceID, guint16 domainID, const char* appname, guint16 sourceClassID, + gint32 sourceState, gint16 volume, gboolean visible, struct availability_s availables, + guint16 interrupt, struct sound_property_s soundPropertyList, gint32 connectionFormatList, + struct main_sound_property_s mainPropertyList, struct notification_config_s NConfRouting, + struct notification_config_s NConfCommand, struct afb_binding_interface* afbitf); +GVariant* create_domain_data(struct domain_data*, struct afb_binding_interface* afbitf); + + +#endif /*AM_HELPER_H*/ \ No newline at end of file diff --git a/soundmanager_binging/soundmanager.c b/soundmanager_binging/soundmanager.c new file mode 100644 index 0000000..b7940ba --- /dev/null +++ b/soundmanager_binging/soundmanager.c @@ -0,0 +1,1485 @@ +/* + * Copyright (c) 2017 TOYOTA MOTOR CORPORATION + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include "sm-error.h" +#include "sm-helper.h" +#include "dbus/audio_manager_interface.h" + +#define AM_NAME "org.genivi.audiomanager" +#define AM_CMD_PATH "/org/genivi/audiomanager/commandinterface" +#define AM_ROUTE_PATH "/org/genivi/audiomanager/routinginterface" +#define AM_ROUTE_NAME "org.genivi.audiomanager.routinginterface" +#define SOUND_MANAGER_RETURN_INTERFACE "org.genivi.audiomanager.routing.soundmanager" +#define SOUND_MANAGER_BUS_NAME "org.genivi.audiomanager.routing.soundmanager" +#define SOUND_MANAGER_PATH "/org/genivi/audiomanager/routing/soundmanager" + +#define COMMAND_EVENT_NUM 10 +#define ROUTING_EVENT_NUM 10 +#define MAX_LEN_STR 100 +#define DEFAULT_SOURCE_CLASS_ID 100 +#define DYNAMIC_DOMAIN_ID 100 +#define DEFAULT_DOMAIN_ID 0 +#define DYNAMIC_SOURCE_ID 0 +#define DEFAULT_VOLUME 100 +#define EVENT_SUBSCRIBE_ERROR_CODE 100 +#define DEFAULT_AVAILABLES 1 +#define DEFAULT_CONNECTION_FORMAT 2 +#define DEFAULT_INTERRUPT 0 +#define DEFAULT_SOURCE_STATE 2 +#define DS_CONTROLLED 1 + + +const static struct afb_binding_interface *afbitf; +static AudiomanagerCommandinterface *am_cmd_bus; +static AudiomanagerRoutinginterface *am_route_bus; +static AudiomanagerRoutingSoundmanager *sm_adapter; +static AudiomanagerRoutingSoundmanagerIface* sm_itf; +static GDBusConnection* system_conn = NULL; + +static GMainLoop *loop = NULL; +static guint16 SOUNDMANAGER_DOMAIN_ID; +/* To Do hash table is better */ +struct event{ + char* name; + struct afb_event* event; + }; +static struct event command_event_list[COMMAND_EVENT_NUM]; +static struct event routing_event_list[ROUTING_EVENT_NUM]; + +static struct afb_event ev_new_connection; +static struct afb_event ev_removed_main_connection; +static struct afb_event ev_volume_changed; +static struct afb_event ev_sink_mute_state_changed; +static struct afb_event ev_main_connection_state_changed; + +/* Routing interface event */ +static struct afb_event ev_set_routing_ready; +static struct afb_event ev_set_routing_rundown; +static struct afb_event ev_async_connect; +static struct afb_event ev_async_disconnect; +static struct afb_event ev_async_set_source_state; + +static const char _source_id[] = "sourceID"; +static const char _sink_id[] = "sinkID" ; +static const char _main_connection_id[] = "mainConnectionID"; +static const char _delay[] = "delay"; +static const char _connection_state[] = "connectionState"; +static const char _connection_id[] = "connectionID"; +static const char _volume[] = "volume"; +static const char _volume_step[] = "volumeStep"; +static const char _mute_state[] = "muteState"; + +static const char _domain_id[] = "domainID"; +static const char _handle[] = "handle"; +static const char _appname[] = "appname"; +static const char _ramp[] = "ramp"; +static const char _time[] = "time"; +static const char _source_state[] = "sourceState"; +static const char _source_class_id[] = "sourceClassID"; +static const char _error[] = "error"; +static const char _sink_data[] = "sinkData"; +static const char _source_data[] = "sourceData"; +static const char _interrupt_state[] = "interruptState"; +static const char _availability[] = "availability"; +static const char _list_volumes[] = "listVolumes"; +static const char _payload[] = "payload"; +static const char _connection_format[] = "connectionFormat"; +/* +********** Method of Sound Manager (API) ********** +*/ + +/** + * Call "connect" function of Audio Manager. + * Getting resource right to output audio stream. + * Please input following keys with value into json string object in argument. + * In case of using libsoundmanager, + * json_object *jobj = json_object_new_object(); + * json_object_object_add(jobj, "sourceID", json_object_new_int(100)); + * json_object_object_add(jobj, "sinkID", json_object_new_int(100)); + * call("connect", jobj); + * + * The order of arguments is not important. + * + * #### Parameters + * Request key + * - sourceID : Source ID getting in return value in registerSource or appname. + * - sinkID : Sink ID. This should be more than 0. If no request, defalut value is set by sound manager + * + * This will be changed in near future because these arguments should be aliased like + * sinkID:100 -> sinkID:"speaker" + * + * This will be modified after integrating + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * sourceID and sinkID should be more than 0 + * + */ +static void connect (struct afb_req request) +{ + NOTICE(afbitf,"call connect"); + guint16 source_id, sink_id; + guint16 main_connectionID = 0; + gint16 ret; + REQ_ERROR req_err1, req_err2; + GError *err = NULL; + /* ToDo select appname(speaker) or sourceID(sinkID). If appname is desired, it changes to sourceID(sinkID) */ + + req_err1 = get_value_uint16(request, _source_id, &source_id); + req_err2 = get_value_uint16(request, _sink_id, &sink_id); + + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK)) + { + NOTICE(afbitf, "get_value_uint16 source ret = %d,sink ret = %d", source_id, sink_id); + NOTICE(afbitf,"wrong request"); + afb_req_fail(request,"wrong-request",NULL); + return; + } + + audiomanager_commandinterface_call_connect_sync( + am_cmd_bus, + source_id, + sink_id, + &ret, + &main_connectionID, + NULL, &err); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + /* ToDo Remember appname(key) and tie to sourceID(value) */ + + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 4, + "error", ret, + _main_connection_id, main_connectionID); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Call "disconnect" function of Audio Manager. + * Release resource right to output audio stream. + * + * #### Parameters + * Request key + * - sourceID : Source ID getting in return value in registerSource or appname. + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * sourceID should be more than 0 + * + */ +static void disconnect (struct afb_req request) +{ + NOTICE(afbitf,"call disconnect"); + + guint16 id; + gint16 ret; + REQ_ERROR req_err; + GError *err = NULL; + + req_err = get_value_uint16(request, _main_connection_id, &id); + NOTICE(afbitf, "requested %s = %d", _main_connection_id, id); + + if(req_err != REQ_OK) + { + afb_req_fail(request,"wrong-request",afb_req_value (request, _main_connection_id)); + return; + } + audiomanager_commandinterface_call_disconnect_sync( + am_cmd_bus, + id, + &ret, + NULL, &err); + NOTICE(afbitf, "ret = %d", ret); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + + afb_req_success(request, res_obj, info); /* return error num as status */ +} + +/** + * Call "setVolume" function of Audio Manager. + * Set sink volume. + * + * #### Parameters + * Request key + * - volume : volume value. The range of value should be [0-100] + * - sinkID : sinkID you would like to change volume at + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void setVolume (struct afb_req request) +{ + NOTICE(afbitf,"call setVolume"); + + guint16 sink_id, vol; + gint16 ret; + REQ_ERROR req_err1, req_err2; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _sink_id, &sink_id); + req_err2 = get_value_int16(request, _volume, &vol); + NOTICE(afbitf, "requested %s = %d, %s = %d",_sink_id, sink_id, _volume, vol); + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK)) + { + afb_req_fail(request,"wrong-request", NULL); + return; + } + + audiomanager_commandinterface_call_set_volume_sync( + am_cmd_bus, + sink_id, + vol, + &ret, + NULL, &err); + NOTICE(afbitf, "ret = %d", ret); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2, + "error", ret); + char *info = get_response_audiomanager_massage_error(ret); + + afb_req_success(request, res_obj, info); /* return error num as status */ +} + +/** + * Call "volumeStep" function of Audio Manager. + * Change volume step of sink + * + * #### Parameters + * Request key + * - sinkID : sinkID you would to change volume step + * - volumeStep : Step size of volume + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void volumeStep (struct afb_req request) +{ + NOTICE(afbitf,"call volumeStep"); + + guint16 sink_id, vol; + gint16 ret; + REQ_ERROR req_err1, req_err2; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _sink_id, &sink_id); + req_err2 = get_value_int16(request, _volume_step, &vol); + NOTICE(afbitf, "requested %s = %d, %s = %d",_sink_id, sink_id, _volume_step, vol); + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK)) + { + afb_req_fail(request,"wrong-request", NULL); + return; + } + + audiomanager_commandinterface_call_volume_step_sync( + am_cmd_bus, + sink_id, + vol, + &ret, + NULL, &err); + NOTICE(afbitf, "ret = %d", ret); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2, + "error", ret); + char *info = get_response_audiomanager_massage_error(ret); + + afb_req_success(request, res_obj, info); /* return error num as status */ +} + +/** + * Call "volumeStep" function of Audio Manager. + * Change volume step of sink + * + * #### Parameters + * Request key + * - sinkID : sinkID you would like to change mute state + * - muteState : muteState, 1 means mute, 2 means unmute. Or you can designate as "mute" or "unmute" + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void setSinkMuteState(struct afb_req request) +{ + NOTICE(afbitf,"call setSinkMuteStete"); + + guint16 sink_id, mute; + gint16 ret; + REQ_ERROR req_err1, req_err2; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _sink_id, &sink_id); + req_err2 = get_value_int16(request, _mute_state, &mute); + NOTICE(afbitf, "requested %s = %d, %s = %d",_sink_id, sink_id, _mute_state, mute); + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK)) + { + afb_req_fail(request,"wrong-request", NULL); + return; + } + + audiomanager_commandinterface_call_set_sink_mute_state_sync( + am_cmd_bus, + sink_id, + mute, + &ret, + NULL, &err); + NOTICE(afbitf, "ret = %d", ret); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object_func(res_obj, __FUNCTION__, 2, + "error", ret); + char *info = get_response_audiomanager_massage_error(ret); + + afb_req_success(request, res_obj, info); /* return error num as status */ +} + +/** + * Call "getListMainConnections" function of Audio Manager. + * Change volume step of sink + * + * #### Parameters + * Request key + * None + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. Even if there is no connection list, + * Sound Manager return success. So you should check the contents size of return json object + * + * #### Note + * + */ +static void getListMainConnections(struct afb_req request) +{ + NOTICE(afbitf,"call getListMainConnections"); + guint16 ret; + GVariant* mainConnectionList; + GError *err = NULL; + + audiomanager_commandinterface_call_get_list_main_connections_sync( + am_cmd_bus, + &ret, + &mainConnectionList, + NULL, + &err + ); + NOTICE(afbitf,"ret = %d, mainConnectionList pointer = %p", ret, &mainConnectionList); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + /* create response */ + struct json_object *array_res = json_object_new_array(); + gsize size = g_variant_n_children(mainConnectionList); + NOTICE(afbitf, "mainConnectionList size is %u",(uint16_t)size); + struct json_object *verb_obj = json_object_new_object(); + sm_add_object_to_json_object_func(verb_obj, __FUNCTION__, 0); + json_object_array_add(array_res, verb_obj); + if(size <= 0) + { + NOTICE(afbitf, "mainConnectionList size is 0"); + } + else{ + for(int i = 0; i < size; ++i) + { + guint16 mcid, srcid, sinkid; + gint16 delay, constate; + g_variant_get_child( + mainConnectionList,i,"(qqqnn)", + &mcid, &srcid, &sinkid, &delay, &constate + ); + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj,10, + _main_connection_id, mcid, + _source_id, srcid, + _sink_id, sinkid, + _delay, delay, + _connection_state, constate + ); + json_object_array_add(array_res,res_obj); + } + } + NOTICE(afbitf,"json object :%s:",json_object_to_json_string(array_res)); + afb_req_success(request, array_res, "Success to get main connection list"); +} + +/* +* +****** Routing Interface method(API) *********** +* +*/ + +/** + * Call "ackConnect" function of Audio Manager. + * Return acknowledge of connect against asyncConnect + * + * #### Parameters + * - handle : Handle id when you get on asyncConnect + * - connectionID : connection id when you got on connect return value + * - error : Error Number you would like to send. If error is 0, it means OK. + * If an application has some error, send error number in function then AM release + * resources the application got in connect. + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. Even if there is no connection list, + * Sound Manager return success. So you should check the contents size of return json object + * + * #### Note + * + */ +static void ackConnect(struct afb_req request) +{ + /* This function will be deprecated */ + NOTICE(afbitf,"call %s", __FUNCTION__); + guint16 handle, connection_id, error; + guint16 ret = 0; + REQ_ERROR req_err1, req_err2 , req_err3; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _handle, &handle); + req_err2 = get_value_uint16(request, _connection_id, &connection_id); + req_err3 = get_value_uint16(request, _error, &error); + + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK) || (req_err3 != REQ_OK)) + { + afb_req_fail(request,"wrong-request", NULL); + return; + } + if(connection_id == 0) + { + afb_req_fail(request,"wrong-request", "connectionID is more than 0"); + return; + } + + audiomanager_routinginterface_call_ack_connect_sync( + am_route_bus, + handle, + connection_id, + error, + NULL, &err); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Call "ackDisconnect" function of Audio Manager. + * Return acknowledge of disconnect against asyncDisconnect + * + * #### Parameters + * - handle : Handle id when you get on asyncDisconnect + * - connectionID : connection id when you got on connect return value + * - error : Error Number you would like to send. If error is 0, it means OK. + * If an application has some error, send error number in function then AM + * + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. Even if there is no connection list, + * Sound Manager return success. So you should check the contents size of return json object + * + * #### Note + * + */ +static void ackDisconnect(struct afb_req request) +{ + /* This function will be deprecated */ + NOTICE(afbitf,"call %s", __FUNCTION__); + guint16 handle, connection_id, error; + guint16 ret = 0; + REQ_ERROR req_err1, req_err2 , req_err3; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _handle, &handle); + req_err2 = get_value_uint16(request, _connection_id, &connection_id); + req_err3 = get_value_uint16(request, _error, &error); + + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK) || (req_err3 != REQ_OK)) + { + afb_req_fail(request,"wrong-request", "connectionID is more than 0"); + return; + } + if(connection_id == 0) + { + afb_req_fail(request,"wrong-request", "connectionID is more than 0"); + return; + } + + audiomanager_routinginterface_call_ack_disconnect_sync( + am_route_bus, + handle, + connection_id, + error, + NULL, &err); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Call "ackSetSourceState" function of Audio Manager. + * Return acknowledge of setSourceState against asyncSetSourceState. + * + * #### Parameters + * - handle : Handle id when you get on asyncSetSourceState + * - error : Error Number you would like to send. If error is 0, it means OK. + * If an application has some errors, send error number in function + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * This function is very important for applications to realise the sequence of Audio Management. + * An Application which matches with sourceID in the parameter of asyncSetSourceState has to return ack to use this function + * + */ +static void ackSetSourceState(struct afb_req request) +{ + NOTICE(afbitf,"call %s", __FUNCTION__); + guint16 handle, error; + guint16 ret = 0; + REQ_ERROR req_err1, req_err2; + GError *err = NULL; + + req_err1 = get_value_uint16(request, _handle, &handle); + req_err2 = get_value_uint16(request, _error, &error); + + if((req_err1 != REQ_OK) || (req_err2 != REQ_OK)) + { + NOTICE(afbitf,"wrong request"); + afb_req_fail(request,"wrong-request", NULL); + return; + } + + audiomanager_routinginterface_call_ack_set_source_state_sync( + am_route_bus, + handle, + error, + NULL, &err); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Call "registerSource" function of Audio Manager. + * Register source(application) to Audio Manager Policy Management + * Application must call this function on its initialization + * + * #### Parameters + * - appname : Application unieque name + * [Option] + * It is not necessary to designate following argument, because these are default value is selected y soundmanager + * If you would like to set value, please input the following key and value + * - sourceClassID : + * - sourceState : + * + * #### Return + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void registerSource(struct afb_req request) +{ + NOTICE(afbitf,"call %s", __FUNCTION__); + GError *err = NULL; + + + guint16 source_id; /* q 0 is for dynamic id*/ + guint16 domain_id; /* q */ + guint16 source_class_id; /* q */ + gint32 source_state; /* i */ + gint16 volume; /* n */ + + if(REQ_OK != get_value_uint16(request, _source_id, &source_id)){ + source_id = DYNAMIC_SOURCE_ID; /* if 0, dynamic source id will be applied */ + } + REQ_ERROR req_err = get_value_uint16(request, _domain_id, &domain_id); + if( req_err != REQ_OK){ + if(req_err == REQ_FAIL) + { + domain_id = SOUNDMANAGER_DOMAIN_ID; /* default in AGL */ + } + else{ + afb_req_fail(request,"wrong-request", "Please input domainID as uint16, otherwise no value is OK"); + return; + } + } + if(domain_id == 0) + { + afb_req_fail(request,"wrong-request", "domainID should be more than 0"); + return; + } + const gchar* name = afb_req_value(request, _appname); /* s */ + if(!name) + { + char* info = "Must specify the name. Please input json arg such as {\"appname\":\"radio\"}"; + afb_req_fail(request, NULL, info); + return; + } + if(REQ_OK != get_value_uint16(request, _source_class_id, &source_class_id)){ + source_class_id = DEFAULT_SOURCE_CLASS_ID; /* BASE */ + } + if(REQ_OK != get_value_int32(request, _source_state, &source_state)){ + source_state = DEFAULT_SOURCE_STATE; /* SS_OFF */ + } + if(REQ_OK != get_value_int16(request, _volume, &volume)){ + volume = DEFAULT_VOLUME; + } + gboolean visible = TRUE; /* b */ + struct availability_s available; /* (ii) */ + available.availability = DEFAULT_AVAILABLES; /* A_UNKNOWN */ + available.avalilable_reason = 0; /* AR_UNKNOWN */ + guint16 interrupt = DEFAULT_INTERRUPT; /* q IS_OFF */ + + struct sound_property_s sound_property_list; /* a(in) */ + sound_property_list.type = 0; + sound_property_list.value = 0; /* in reality, this is array of struct */ + + gint32 connection_format_list = DEFAULT_CONNECTION_FORMAT; /* ai */ + struct main_sound_property_s main_property_list; /* a(in) */ + main_property_list.type = 0; + main_property_list.value = 0; + + struct notification_config_s nconf_routing; + struct notification_config_s nconf_command; /* a(iin)a(iin) */ + nconf_routing.type = 0; + nconf_routing.status = 0; + nconf_routing.parameter = 0; + + nconf_command.type = 0; + nconf_command.status = 0; + nconf_command.parameter = 0; + + /* acquire data */ + guint16 acquire_source_id; + guint16 ret; + + GVariant* sourceData = create_source_data (source_id, domain_id, name, source_class_id, + source_state, volume, visible, available, interrupt, + sound_property_list, connection_format_list, main_property_list, + nconf_routing, nconf_command, afbitf); + + GVariant* input = g_variant_ref_sink(sourceData); + audiomanager_routinginterface_call_register_source_sync( + am_route_bus, + input, + &acquire_source_id, + &ret, + NULL, &err); + g_variant_unref(input); + + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 4, + _error, ret, + _source_id, acquire_source_id); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Call "deregisterSource" function of Audio Manager. + * Deregister source(application) to Audio Manager Policy Management + * + * #### Parameters + * - sourceID : sourceID returned in resisterSource + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void deregisterSource(struct afb_req request) +{ + guint16 source_id; + guint16 ret; + + GError *err = NULL; + + if(REQ_OK != get_value_uint16(request, _source_id, &source_id)){ + afb_req_fail(request, "wrong-request", NULL); + } + audiomanager_routinginterface_call_deregister_source_sync( + am_route_bus, + source_id, + &ret, + NULL, &err + ); + if(err != NULL) + { + afb_req_fail_f(request, "failed", "Unable to call %s", __FUNCTION__); + return; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); + +} + +/** + * Subscribe event + * + * #### Parameters + * - event : Event name. Event list is written in libsoundmanager.hpp + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void subscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "event"); + NOTICE(afbitf, "value is %s", value); + int ret = 0; + if(value) { + int index = sm_search_event_name_index(value); + if(index < 0) + { + index = sm_search_routing_event_name_index(value); + if(index < 0) + { + NOTICE(afbitf, "dedicated event doesn't exist"); + ret = EVENT_SUBSCRIBE_ERROR_CODE; + } + else + { + afb_req_subscribe(request, *routing_event_list[index].event); + } + } + else + { + afb_req_subscribe(request, *command_event_list[index].event); + } + } + else{ + NOTICE(afbitf, "Please input event name"); + ret = EVENT_SUBSCRIBE_ERROR_CODE; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/** + * Unsubscribe event + * + * #### Parameters + * - event : Event name. Event list is written in libsoundmanager.hpp + * + * #### Rreturn + * - error : Error status number. If error is 0, it means the request is accepted, otherwise error message is attached with error code in reply message. + * + * #### Note + * + */ +static void unsubscribe(struct afb_req request) +{ + const char *value = afb_req_value(request, "event"); + NOTICE(afbitf, "value is %s", value); + int ret = 0; + if(value) { + int index = sm_search_event_name_index(value); + if(index < 0) + { + index = sm_search_routing_event_name_index(value); + if(index < 0) + { + NOTICE(afbitf, "dedicated event doesn't exist"); + ret = EVENT_SUBSCRIBE_ERROR_CODE; + } + else + { + afb_req_unsubscribe(request, *routing_event_list[index].event); + } + } + else + { + afb_req_unsubscribe(request, *command_event_list[index].event); + } + } + else{ + NOTICE(afbitf, "Please input event name"); + ret = EVENT_SUBSCRIBE_ERROR_CODE; + } + /*create response json object*/ + struct json_object *res = json_object_new_object(); + sm_add_object_to_json_object_func(res, __FUNCTION__, 2, + _error, ret); + char *info = get_response_audiomanager_massage_error(ret); + afb_req_success(request, res, info); +} + +/* +********** Callback Function invoked by Audio Manager ********** +*/ + +static void on_new_main_connection(AudiomanagerCommandinterface* interface, + GVariant* mainConnection) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + + guint16 mcid, srcid, sinkid; + gint16 delay, constate; + g_variant_get( + mainConnection,"(qqqnn)", &mcid, &srcid, &sinkid, &delay, &constate); + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj,10, + _main_connection_id, mcid, + _source_id, srcid, + _sink_id, sinkid, + _delay, delay, + _connection_state, constate + ); + NOTICE(afbitf,"json object :%s:",json_object_to_json_string(res_obj)); + + afb_event_push(ev_new_connection, res_obj); +} + +static void on_removed_main_connection( + AudiomanagerCommandinterface* interface, guint16 mainConnectionID) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj, 2, + _main_connection_id, mainConnectionID); + afb_event_push(ev_removed_main_connection, res_obj); +} + +static void on_main_connection_state_changed( + AudiomanagerCommandinterface* interface, guint16 connectionID, gint16 connectionState) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj, 4, + _connection_id, connectionID, + _connection_state, connectionState); + afb_event_push(ev_main_connection_state_changed, res_obj); +} + +static void on_volume_changed( + AudiomanagerCommandinterface* interface, guint16 sinkID, gint16 volume) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj, 4, + _sink_id, sinkID, + _volume, volume); + afb_event_push(ev_volume_changed, res_obj); +} + +static void on_sink_mute_state_changed( + AudiomanagerCommandinterface* interface, guint16 sinkID, gint16 mute) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + struct json_object* res_obj = json_object_new_object(); + sm_add_object_to_json_object(res_obj, 4, + _sink_id, sinkID, + _mute_state, mute); + afb_event_push(ev_sink_mute_state_changed, res_obj); +} + +/* +********** Callback Function invoked by Audio Manager Routing Interface********** +*/ +static void on_set_routing_ready( + AudiomanagerRoutinginterface* interface) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + afb_event_push(ev_set_routing_ready, NULL); +} + +static void on_set_routing_rundown( + AudiomanagerRoutinginterface* interface) +{ + NOTICE(afbitf,"%s is called",__FUNCTION__); + afb_event_push(ev_set_routing_ready, NULL); +} + + + +/* +********** Callback Function invoked by Sound Manager Adapter Interface********** +* +* For now, there may be no need to send events to applications from these invocation. +* Sound Manager just sends ack to Audio Manager in charge of applications. +* +*/ +static gboolean on_async_abort( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); + /* Nothing To Do. If it is better to implement something, I will implement */ + return TRUE; +} + +static gboolean on_async_connect( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID, + guint16 arg_sourceID, + guint16 arg_sinkID, + gint arg_connectionFormat) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); + + struct json_object* ev_obj = json_object_new_object(); + sm_add_object_to_json_object(ev_obj, 10, + _handle, arg_handle, + _connection_id, arg_connectionID, + _source_id, arg_sourceID, + _sink_id, arg_sinkID, + _connection_format, arg_connectionFormat); + afb_event_push(ev_async_connect, ev_obj); + + /* GError must be initialized here because it is same as grobal errno, + so if afb_event_push is failed due to something, number will be changed */ + GError* err = NULL; + audiomanager_routinginterface_call_ack_connect_sync( + am_route_bus, + arg_handle, + arg_connectionID, + 0, + NULL, &err); + if(err != NULL) + { + NOTICE(afbitf, "Can't send ack to sound manager adapter %s", __FUNCTION__); + return FALSE; + } + return TRUE; +} + +static gboolean on_async_disconnect( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_connectionID) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); + struct json_object* ev_obj = json_object_new_object(); + sm_add_object_to_json_object(ev_obj, 4, + _handle, arg_handle, + _connection_id, arg_connectionID); + afb_event_push(ev_async_disconnect, ev_obj); + GError* err = NULL; + audiomanager_routinginterface_call_ack_disconnect_sync( + am_route_bus, + arg_handle, + arg_connectionID, + 0, + NULL, &err); + if(err != NULL) + { + NOTICE(afbitf, "Can't send ack to sound manager adapter %s", __FUNCTION__); + return FALSE; + } + return TRUE; +} + +static gboolean on_async_set_sink_volume( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_sinkID, + gint16 arg_volume, + gint16 arg_ramp, + guint16 arg_time) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); + GError* err = NULL; + audiomanager_routinginterface_call_ack_set_sink_volume_sync( + am_route_bus, + arg_handle, + arg_volume, + 0, NULL, &err); + if(err != NULL);{ + NOTICE(afbitf, "Can't send ack to sound manager adapter %s", __FUNCTION__); + return FALSE; + } + return TRUE; +} + +/** + * Event "asyncSetSourceState" + * This event is the result of Audio Management. + * + * #### Parameters + * Request key + * - sourceID : sourceID to be commanded by Audio Manager. The contents of command is sourceState + * - handle : handle is the dynamic number managed by Audio Manager. Please return this parameter to input ackSetSourceState as is + * - sourceState : "on" is the instruction that application can output sound + * "off" is the instruction that application sound right will be removed_main_connection + * "pause" is the instruction that application must stop output sound because other applications got sound right and will output sound + * + * #### Note + * This function is very important for applications to realise the sequence of Audio Management. + * An Application which matches with sourceID in the parameter of asyncSetSourceState has to return ack to use this function + * + */ +static gboolean on_async_set_source_state( + AudiomanagerRoutingSoundmanager *object, + GDBusMethodInvocation *invocation, + guint16 arg_handle, + guint16 arg_sourceID, + gint arg_sourceState) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); + struct json_object* ev_obj = json_object_new_object(); + char* ss_key = get_source_state_key(arg_sourceState); + sm_add_object_to_json_object(ev_obj, 4, + _handle, arg_handle, + _source_id, arg_sourceID); + json_object_object_add(ev_obj, _source_state, json_object_new_string(ss_key)); + afb_event_push(ev_async_set_source_state, ev_obj); + /* Applications must return ackSetSourceState to look sourceID, then Sound Manager doen't return ackSetSourceState */ + /*audiomanager_routinginterface_call_ack_set_source_state_sync( + am_route_bus, + arg_handle, + NULL, + NULL, &err);*/ +} + + +/* + * array of the verbs exported to afb-daemon + */ +static const struct afb_verb_desc_v1 binding_verbs[]= { +/* VERB'S NAME SESSION MANAGEMENT FUNCTION TO CALL SHORT DESCRIPTION */ +{ .name = "connect", .session = AFB_SESSION_NONE, .callback = connect, .info = "Connect source id and sink id" }, +{ .name = "disconnect", .session = AFB_SESSION_NONE, .callback = disconnect, .info = "Disconnect source id and sink id" }, +{ .name = "setVolume", .session = AFB_SESSION_NONE, .callback = setVolume, .info = "Set volume value" }, /* it is better to show the range*/ +{ .name = "volumeStep", .session = AFB_SESSION_NONE, .callback = volumeStep, .info = "Set volume step range" }, +{ .name = "setSinkMuteState", .session = AFB_SESSION_NONE, .callback = setSinkMuteState, .info = "Set Mute state: 1 means mute, 2 means umute. Others are invalid" }, +{ .name = "getListMainConnections", .session = AFB_SESSION_NONE, .callback = getListMainConnections, .info = "Get MainConnection List" }, +/* Routing Interface */ +{ .name = "registerSource", .session = AFB_SESSION_NONE, .callback = registerSource, .info = "Register Application" }, +{ .name = "deregisterSource", .session = AFB_SESSION_NONE, .callback = deregisterSource, .info = "Deregister Application" }, +{ .name = "ackConnect", .session = AFB_SESSION_NONE, .callback = ackConnect, .info = "Acknowledge of asyncConnect" }, +{ .name = "ackDisconnect", .session = AFB_SESSION_NONE, .callback = ackDisconnect, .info = "Acknowledge of asyncConnect" }, +{ .name = "ackSetSourceState", .session = AFB_SESSION_NONE, .callback = ackSetSourceState, .info = "Acknowledge of asyncSetSourceState" }, +{ .name = "subscribe", .session = AFB_SESSION_NONE, .callback = subscribe, .info = "Subscribe event" }, +{ .name = "unsubscribe", .session = AFB_SESSION_NONE, .callback = unsubscribe, .info = "Unsubscribe event" }, +{ .name = NULL } /* marker for end of the array */ +}; + +static const struct afb_binding binding_description = +{ + .type = AFB_BINDING_VERSION_1, + .v1 = { + .info = "Sound Manager" , + .prefix = "soundmanager" , + .verbs = binding_verbs + } +}; + +static void *dbus_event_loop_run(void *args) +{ + loop = g_main_loop_new(NULL, FALSE); + g_main_loop_run(loop); +} + + +/* +* +********** Internal Function used by Sound Manager ********** +* +*/ + +static int registerDomain() +{ + /* Default Setting of Sound Manager Domain */ + struct domain_data ddata = { + .domainID = DYNAMIC_DOMAIN_ID, + .name = "SoundManager", + .busname = SOUND_MANAGER_BUS_NAME, + .nodename = "soundmanager", + .early = FALSE, + .complete = TRUE, + .state = DS_CONTROLLED + }; + GVariant* domainData = create_domain_data(&ddata, afbitf); + gchar* retBusName = SOUND_MANAGER_BUS_NAME; + gchar* retPath = SOUND_MANAGER_PATH; + gchar* retInterface = SOUND_MANAGER_RETURN_INTERFACE; + guint16 domain_id; + GError *err = NULL; + guint16 error; + + audiomanager_routinginterface_call_register_domain_sync( + am_route_bus, + domainData, + retBusName, + retPath, + retInterface, + &domain_id, &error, + NULL, &err); + if(err != NULL){ + NOTICE(afbitf, "Failed to call %s", __FUNCTION__); + return -1; + } + if(error != 0) + { + NOTICE(afbitf, "Failed to register domain"); + return -1; + } + SOUNDMANAGER_DOMAIN_ID = domain_id; + NOTICE(afbitf, "Complete registered domain id:%d",SOUNDMANAGER_DOMAIN_ID); + return 0; +} + +static int init() +{ + int ret; + INFO(afbitf,"Initialize Dbus object"); + /* Initialize Dbus interface */ + if(am_cmd_bus || am_route_bus) + { + NOTICE(afbitf, "Dbus object to Audio Manager is already created"); + goto out; + } + am_cmd_bus = audiomanager_commandinterface_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + AM_NAME, + AM_CMD_PATH, + NULL, + NULL + ); + am_route_bus = audiomanager_routinginterface_proxy_new_for_bus_sync( + G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + AM_NAME, + AM_ROUTE_PATH, + NULL, + NULL + ); + + if(!am_cmd_bus || !am_route_bus) + { + goto out; + } + + INFO(afbitf, "Finish Initialize"); + return 0; +out: + NOTICE(afbitf,"Failed to initialize"); + return -1; +} + +static int create_adapter() +{ + GError *error = NULL; + gboolean ret; + GVariant *value; + system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); + if (error) + { + g_error_free(error); + return -1; + } + sm_adapter = audiomanager_routing_soundmanager_skeleton_new(); + sm_itf = AUDIOMANAGER_ROUTING_SOUNDMANAGER_GET_IFACE(sm_adapter); + + /* initialize sound manager adapter */ + sm_itf->handle_async_abort = on_async_abort; + sm_itf->handle_async_connect = on_async_connect; + sm_itf->handle_async_disconnect = on_async_disconnect; + sm_itf->handle_async_set_sink_volume = on_async_set_sink_volume; + sm_itf->handle_async_set_source_state = on_async_set_source_state; + + int sigret = g_signal_connect(sm_adapter, "handle-async-abort", G_CALLBACK(on_async_abort),NULL); + sigret = g_signal_connect(sm_adapter, "handle-async-connect", G_CALLBACK(on_async_connect),NULL); + sigret = g_signal_connect(sm_adapter, "handle-async-disconnect", G_CALLBACK(on_async_disconnect),NULL); + sigret = g_signal_connect(sm_adapter, "handle-async-set-sink-volume", G_CALLBACK(on_async_set_sink_volume),NULL); + sigret = g_signal_connect(sm_adapter, "handle-async-set-source-state", G_CALLBACK(on_async_set_source_state),NULL); + ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(sm_adapter), system_conn, SOUND_MANAGER_PATH, &error); + if (FALSE == ret) + { + NOTICE(afbitf, "failed to export"); + g_error_free(error); + g_object_unref(system_conn); + + return -1; + } + + return 0; +} + + +static void on_name_lost(GDBusServer *server, GDBusConnection *conn, gpointer data) +{ + NOTICE(afbitf, "%s called", __FUNCTION__); +} + + +static int sm_event_init() +{ + NOTICE(afbitf,"Initialize event receive setting"); + printf("Initialize event receive setting"); + int ret; + /* Initialize make event */ + size_t size = sizeof cmd_evlist / sizeof *cmd_evlist; + + /*create event*/ + /*ToDo Hash table is better. And event should be created in the loop + I would like to change */ + ev_volume_changed = afb_daemon_make_event(afbitf->daemon, cmd_evlist[0]); + ev_new_connection = afb_daemon_make_event(afbitf->daemon, cmd_evlist[1]); + ev_removed_main_connection = afb_daemon_make_event(afbitf->daemon, cmd_evlist[2]); + ev_sink_mute_state_changed = afb_daemon_make_event(afbitf->daemon, cmd_evlist[3]); + ev_main_connection_state_changed = afb_daemon_make_event(afbitf->daemon, cmd_evlist[4]); + command_event_list[0].name = cmd_evlist[0]; + command_event_list[0].event = &ev_volume_changed; + command_event_list[1].name = cmd_evlist[1]; + command_event_list[1].event = &ev_new_connection; + command_event_list[2].name = cmd_evlist[2]; + command_event_list[2].event = &ev_removed_main_connection; + command_event_list[3].name = cmd_evlist[3]; + command_event_list[3].event = &ev_sink_mute_state_changed; + command_event_list[4].name = cmd_evlist[4]; + command_event_list[4].event = &ev_main_connection_state_changed; + + /* create routing event */ + ev_set_routing_ready = afb_daemon_make_event(afbitf->daemon, route_evlist[0]); + ev_set_routing_rundown = afb_daemon_make_event(afbitf->daemon, route_evlist[1]); + ev_async_connect = afb_daemon_make_event(afbitf->daemon, route_evlist[2]); + ev_async_set_source_state = afb_daemon_make_event(afbitf->daemon, route_evlist[3]); + ev_async_disconnect = afb_daemon_make_event(afbitf->daemon, route_evlist[4]); + + routing_event_list[0].name = route_evlist[0]; + routing_event_list[0].event = &ev_set_routing_ready; + routing_event_list[1].name = route_evlist[1]; + routing_event_list[1].event = &ev_set_routing_rundown; + routing_event_list[2].name = route_evlist[2]; + routing_event_list[2].event = &ev_async_connect; + routing_event_list[3].name = route_evlist[3]; + routing_event_list[3].event = &ev_async_set_source_state; + routing_event_list[4].name = route_evlist[4]; + routing_event_list[4].event = &ev_async_disconnect; + /*for(size_t i = 0; i < size; ++i) + { + struct afb_event afbev = afb_daemon_make_event(afbitf->daemon, cmd_evlist[i])); + size_t afbev_size = sizeof afbev; + size_t key_size = sizeof cmd_evlist[i]; + + struct event ev = {cmd_evlist[i],afbev}; + command_event_list[i] = malloc(key_size + afbev_size); + command_event_list[i] = ev; + search_result = hsearch(entry, FIND); + if(search_result) + NOTICE(afbitf, "event name is %s", search_result->key); + }*/ + + /* Initialize dbus event thread */ + if(!am_cmd_bus || !am_route_bus) + { + goto ev_init_out; + } + pthread_t thread_id; + ret = pthread_create(&thread_id, NULL, dbus_event_loop_run, NULL); + if(ret != 0) + { + goto ev_init_out; + } + /* initialize signal from audio manager command interface */ + g_signal_connect(am_cmd_bus, + "volume_changed", + G_CALLBACK(on_volume_changed), + NULL); + g_signal_connect(am_cmd_bus, + "new_main_connection", + G_CALLBACK(on_new_main_connection), + NULL); + g_signal_connect(am_cmd_bus, + "removed_main_connection", + G_CALLBACK(on_removed_main_connection), + NULL); + g_signal_connect(am_cmd_bus, + "sink_mute_state_changed", + G_CALLBACK(on_sink_mute_state_changed), + NULL); + g_signal_connect(am_cmd_bus, + "main_connection_state_changed", + G_CALLBACK(on_main_connection_state_changed), + NULL); + g_signal_connect(am_route_bus, + "set_routing_ready", + G_CALLBACK(on_set_routing_ready), + NULL); + g_signal_connect(am_route_bus, + "set_routing_rundown", + G_CALLBACK(on_set_routing_rundown), + NULL); + + /* Get soundmanager adapter bus */ + g_bus_own_name(G_BUS_TYPE_SYSTEM, SOUND_MANAGER_BUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE, + NULL,NULL, on_name_lost, NULL, NULL); + ret = create_adapter(); + if(ret != 0) + { + goto ev_init_out; + } + ret = registerDomain(); + + if(ret != 0) + { + goto ev_init_out; + } + + INFO(afbitf,"Finish Initialize event receive setting"); + return 0; + +ev_init_out: + if(loop != NULL) + { + g_main_loop_unref(loop); + } + NOTICE(afbitf, "DBus connection is not created"); + return -1; +} + +/* + * activation function for registering the binding called by afb-daemon + */ +const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) +{ + afbitf = itf; // records the interface for accessing afb-daemon + + int ret = init(); // Set Dbus communication with audio mangaer + return (ret == 0) ? &binding_description : NULL; +} + +int afbBindingV1ServiceInit(struct afb_service service) +{ + NOTICE(afbitf, "Initializing Audio Manager Notification \n"); + int ret = sm_event_init(); + return ret; +} diff --git a/test/call-sm-binding-method_test.sh b/test/call-sm-binding-method_test.sh new file mode 100755 index 0000000..e3f1139 --- /dev/null +++ b/test/call-sm-binding-method_test.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +echo "please call method after launch afb-client-demo" +echo " # ./sm-binding-test.sh" +echo "To get soundmanager api " +echo "example) monitor get {\"apis\":[\"monitor\"]}" +echo "example) soundmanager disconnect {\"mainConnectionID\":1}" +port=12345 +token=123456 +if test $1;then +port=$1 +fi +if test $2; then +token=$2 +fi +afb-client-demo ws://localhost:${port}/api?token=${token} + diff --git a/test/dbus-call-connect-test.sh b/test/dbus-call-connect-test.sh new file mode 100755 index 0000000..882afae --- /dev/null +++ b/test/dbus-call-connect-test.sh @@ -0,0 +1,12 @@ +#!/bin/sh +echo How to call connect and disconnect of AudioManager +echo Connect +echo dbus-send --system --dest=org.genivi.audiomanager --type=method_call \ + --print-reply /org/genivi/audiomanager/commandinterface \ + org.genivi.audiomanager.commandinterface.Connect uint16:xxx uint16:xxx +echo +echo Disconnect +echo dbus-send --system --dest=org.genivi.audiomanager --type=method_call \ + --print-reply /org/genivi/audiomanager/commandinterface \ + org.genivi.audiomanager.commandinterface.Disconnect uint16:xxx + diff --git a/test/dbus-call-test.sh b/test/dbus-call-test.sh new file mode 100755 index 0000000..f20af35 --- /dev/null +++ b/test/dbus-call-test.sh @@ -0,0 +1,17 @@ +#!/bin/sh +echo "This is the dbus call test to check main source/sink/connection" + +echo Get List Main Sources +dbus-send --system --dest=org.genivi.audiomanager --type=method_call \ + --print-reply /org/genivi/audiomanager/commandinterface \ + org.genivi.audiomanager.commandinterface.GetListMainSources + +echo Get List Main Sinks +dbus-send --system --dest=org.genivi.audiomanager --type=method_call \ + --print-reply /org/genivi/audiomanager/commandinterface \ + org.genivi.audiomanager.commandinterface.GetListMainSinks + +echo Get List Main Connections +dbus-send --system --dest=org.genivi.audiomanager --type=method_call \ + --print-reply /org/genivi/audiomanager/commandinterface \ + org.genivi.audiomanager.commandinterface.GetListMainConnections \ No newline at end of file diff --git a/test/sm-binding-test-gdb.sh b/test/sm-binding-test-gdb.sh new file mode 100755 index 0000000..f9a58a3 --- /dev/null +++ b/test/sm-binding-test-gdb.sh @@ -0,0 +1,21 @@ +#!/bin/sh + +echo "launch soundmanager binder test" +cmd=/usr/bin/afb-daemon +libsm="soundmanager-binding.so" +port="12345" +token="123456" +if test $1; then + port=$1 +fi +if test $2; then + token=$2 +fi +libpath="/lib/soundmanager" +arg="--verbose --verbose --verbose --port=${port} --token=${token} --binding=${libpath}/${libsm}" +echo "gdb $cmd $arg" +gdb $cmd +echo $! $? +if(test $! -gt 0); then + echo "success to launch" +fi diff --git a/test/sm-binding-test.sh b/test/sm-binding-test.sh new file mode 100755 index 0000000..a159fd7 --- /dev/null +++ b/test/sm-binding-test.sh @@ -0,0 +1,21 @@ +#!/bin/sh + +echo "launch soundmanager binder test" +cmd=/usr/bin/afb-daemon +libsm="soundmanager-binding.so" +port="12345" +token="123456" +if test $1; then + port=$1 +fi +if test $2; then + token=$2 +fi +libpath="/lib/soundmanager" +arg="--verbose --verbose --verbose --port=${port} --token=${token} --binding=${libpath}/${libsm}" +echo "$cmd $arg" +$cmd $arg & +echo $! $? +if(test $! -gt 0); then + echo "success to launch" +fi -- 2.16.6